diff --git a/.cargo/config.toml b/.cargo/config.toml
index 9d360ec0167..f6795e3c6ec 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,3 +1,5 @@
-[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.
+[registries.crates-io]
+protocol = "sparse"
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/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 00000000000..4bd1bc06468
--- /dev/null
+++ b/.devcontainer/devcontainer.json
@@ -0,0 +1,42 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/rust
+{
+	"name": "Rust",
+	"dockerComposeFile": "docker-compose.yml",
+	"service": "devcontainer",
+	"workspaceFolder": "/workspaces/${localWorkspaceFolderBasename}",
+	"features": {
+		"ghcr.io/devcontainers/features/rust:1": {
+			"version": "1.66.0"
+		}
+	},
+	"customizations": {
+		"vscode": {
+		  "extensions": [
+			"rust-lang.rust-analyzer@prerelease", // rust analyser, pre-release has less bugs 
+			"cschleiden.vscode-github-actions", // github actions
+			"serayuzgur.crates", // crates
+			"vadimcn.vscode-lldb" //debug
+		  ],
+		  "settings": {
+			"editor.formatOnSave": true,
+			"terminal.integrated.defaultProfile.linux": "zsh"
+		  }
+		}
+	  },
+
+	// Use 'mounts' to make the cargo cache persistent in a Docker Volume.
+	// "mounts": [
+	// 	{
+	// 		"source": "devcontainer-cargo-cache-${devcontainerId}",
+	// 		"target": "/usr/local/cargo",
+	// 		"type": "volume"
+	// 	}
+	// ]
+	"forwardPorts": [
+		8000, // GraphiQL on node-port
+		8020, // create and deploy subgraphs
+		5001 //ipfs
+	]
+
+}
diff --git a/.devcontainer/docker-compose.yml b/.devcontainer/docker-compose.yml
new file mode 100644
index 00000000000..d26201cc800
--- /dev/null
+++ b/.devcontainer/docker-compose.yml
@@ -0,0 +1,32 @@
+version: '3'
+
+services:
+  devcontainer:
+    image: mcr.microsoft.com/vscode/devcontainers/rust:bullseye
+    volumes:
+      - ../..:/workspaces:cached
+    network_mode: service:database
+    command: sleep infinity
+  ipfs:
+    image: ipfs/kubo:v0.18.1
+    restart: unless-stopped
+    network_mode: service:database
+  database:
+    image: postgres:latest
+    restart: unless-stopped
+    command:
+      [
+        "postgres",
+        "-cshared_preload_libraries=pg_stat_statements"
+      ]
+    volumes:
+      - postgres-data:/var/lib/postgresql/data
+    environment:
+      POSTGRES_USER: graph-node
+      POSTGRES_PASSWORD: let-me-in
+      POSTGRES_DB: graph-node
+      
+      POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C"
+
+volumes:
+  postgres-data:
\ No newline at end of file
diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
deleted file mode 100644
index cb67232349c..00000000000
--- a/.github/ISSUE_TEMPLATE.md
+++ /dev/null
@@ -1,7 +0,0 @@
-**Do you want to request a *feature* or report a *bug*?**
-
-**What is the current behavior?**
-
-**If the current behavior is a bug, please provide the steps to reproduce and if possible a minimal demo of the problem.**
-
-**What is the expected behavior?**
diff --git a/.github/ISSUE_TEMPLATE/bug.yml b/.github/ISSUE_TEMPLATE/bug.yml
new file mode 100644
index 00000000000..4fe935160de
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug.yml
@@ -0,0 +1,54 @@
+name: Bug report
+description: Use this issue template if something is not working the way it should be.
+title: "[Bug] "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        Thanks for taking the time to fill out this bug report!
+  - type: textarea
+    id: bug-report
+    attributes:
+      label: Bug report
+      description: Please provide a detailed overview of the expected behavior, and what happens instead. The more details, the better. You can use Markdown.
+  - type: textarea
+    id: graph-node-logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output (either graph-node or hosted service logs). This will be automatically formatted into code, so no need for backticks. Leave blank if it doesn't apply.
+      render: Shell
+  - type: markdown
+    attributes:
+      value: Does this bug affect a specific subgraph deployment? If not, leave the following blank.
+  - type: input
+    attributes:
+      label: IPFS hash
+      placeholder: e.g. QmST8VZnjHrwhrW5gTyaiWJDhVcx6TooRv85B49zG7ziLH
+    validations:
+      required: false
+  - type: input
+    attributes:
+      label: Subgraph name or link to explorer
+      placeholder: e.g. https://thegraph.com/explorer/subgraphs/3nXfK3RbFrj6mhkGdoKRowEEti2WvmUdxmz73tben6Mb?view=Overview&chain=mainnet
+    validations:
+      required: false
+  - type: checkboxes
+    id: checkboxes
+    attributes:
+      label: Some information to help us out
+      options:
+        - label: Tick this box if this bug is caused by a regression found in the latest release.
+        - label: Tick this box if this bug is specific to the hosted service.
+        - label: I have searched the issue tracker to make sure this issue is not a duplicate.
+          required: true
+  - type: dropdown
+    id: operating-system
+    attributes:
+      label: OS information
+      description: What OS are you running? Leave blank if it doesn't apply.
+      options:
+        - Windows
+        - macOS
+        - Linux
+        - Other (please specify in your bug report)
diff --git a/.github/ISSUE_TEMPLATE/feature.yml b/.github/ISSUE_TEMPLATE/feature.yml
new file mode 100644
index 00000000000..47fa2619714
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature.yml
@@ -0,0 +1,24 @@
+name: Feature request
+description: To request or discuss new features.
+title: "[Feature] "
+labels: ["enhancement"]
+body:
+  - type: textarea
+    id: feature-description
+    attributes:
+      label: Description
+      description: Please provide a detailed overview of the desired feature or improvement, along with any examples or useful information. You can use Markdown.
+  - type: textarea
+    id: blockers
+    attributes:
+      label: Are you aware of any blockers that must be resolved before implementing this feature? If so, which? Link to any relevant GitHub issues.
+    validations:
+      required: false
+  - type: checkboxes
+    id: checkboxes
+    attributes:
+      label: Some information to help us out
+      options:
+        - label: Tick this box if you plan on implementing this feature yourself.
+        - label: I have searched the issue tracker to make sure this issue is not a duplicate.
+          required: true
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 44043c3072e..977a3b8fc50 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,5 +1,17 @@
 version: 2
 updates:
+
+- package-ecosystem: npm
+  directory: tests/integration-tests
+  schedule:
+    interval: weekly
+  open-pull-requests-limit: 10
+  allow:
+    # We always want to test against the latest Graph CLI tooling: `graph-cli`,
+    # `graph-ts`.
+    - dependency-name: "@graphprotocol/graph-*"
+  versioning-strategy: lockfile-only
+
 - package-ecosystem: cargo
   directory: "/"
   schedule:
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 bd8dead4c92..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,36 +33,51 @@ 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: Checkout sources
-        uses: actions/checkout@v2
-      - uses: Swatinem/rust-cache@v2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
 
-      - name: Install lld
-        run: sudo apt-get install -y lld protobuf-compiler
+      - name: Setup dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y lld protobuf-compiler
 
-      - name: Run unit tests
-        uses: actions-rs/cargo@v1
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48 # 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
@@ -62,84 +86,116 @@ 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: Checkout sources
-        uses: actions/checkout@v2
-      - uses: Swatinem/rust-cache@v2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
 
-      - name: Install lld
-        run: sudo apt-get install -y lld protobuf-compiler
+      - name: Setup dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y lld protobuf-compiler
 
-      - name: Run runner tests
-        id: runner-tests-1
-        uses: actions-rs/cargo@v1
-        env:
-          TESTS_GANACHE_HARD_WAIT_SECONDS: "60"
+      - name: Setup rust toolchain
+        uses: actions-rust-lang/setup-rust-toolchain@fb51252c7ba57d633bc668f941da052e410add48 # 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 --package graph-tests -- --skip parallel_integration_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
-    env:
-      RUSTFLAGS: "-C link-arg=-fuse-ld=lld -D warnings"
+    runs-on: nscloud-ubuntu-22.04-amd64-16x32
+    timeout-minutes: 20
+    services:
+      ipfs:
+        image: ipfs/go-ipfs:v0.10.0
+        ports:
+          - 3001:5001
+      postgres:
+        image: postgres
+        env:
+          POSTGRES_USER: graph-node
+          POSTGRES_PASSWORD: let-me-in
+          POSTGRES_DB: graph-node
+          POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C -c max_connections=1000 -c shared_buffers=2GB"
+        options: >-
+          --health-cmd "pg_isready -U graph-node"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+          --name postgres
+        ports:
+          - 3011:5432
     steps:
-      - name: Checkout sources
-        uses: actions/checkout@v2
-      - uses: Swatinem/rust-cache@v2
+      - uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5
 
-      - name: Install Node 14
-        uses: actions/setup-node@v3
-        with:
-          node-version: "14"
-          cache: yarn
-          cache-dependency-path: "tests/integration-tests/yarn.lock"
+      - 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: Build graph-node
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --bin graph-node
-
-      # Integration tests are a bit flaky, running them twice increases the
-      # chances of one run succeeding.
-      - name: Run integration tests (round 1)
-        id: integration-tests-1
-        uses: actions-rs/cargo@v1
-        env:
-          N_CONCURRENT_TESTS: "4"
-          TESTS_GANACHE_HARD_WAIT_SECONDS: "30"
+      - name: Setup just
+        uses: extractions/setup-just@e33e0265a09d6d736e2ee1e0eb685ef1de4669ff # v3
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@82dee4ba654bd2146511f85f0d013af94670c4de # v1
         with:
-          command: test
-          args: --verbose --package graph-tests parallel_integration_tests -- --nocapture
-        continue-on-error: true
-      - name: Run integration tests (round 2)
-        id: integration-tests-2
-        uses: actions-rs/cargo@v1
-        if: ${{ steps.integration-tests-1.outcome == 'failure' }}
-        env:
-          N_CONCURRENT_TESTS: "4"
-          TESTS_GANACHE_HARD_WAIT_SECONDS: "30"
+          version: v1.4.0
+
+      - name: Install pnpm
+        uses: pnpm/action-setup@a7487c7e89a18df4991f7f222e4898a00d66ddda # v4
+
+      - name: Install Node.js
+        uses: actions/setup-node@49933ea5288caeca8642d1e84afbd3f7d6820020 # v4
         with:
-          command: test
-          args: --verbose --package graph-tests parallel_integration_tests -- --nocapture
+          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
+        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
@@ -148,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
+        run: just check --release
diff --git a/.github/workflows/code-coverage.yml b/.github/workflows/code-coverage.yml
deleted file mode 100644
index 2f476c797cb..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
-      - 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 bf084b6c226..0480ebcf19b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -22,9 +22,20 @@ lcov.info
 
 /tests/**/build
 /tests/**/generated
-/tests/**/node_modules
-/tests/**/yarn-error.log
 
-# Built solidity contracts.
-/tests/**/bin
-/tests/**/truffle_output
+# Node dependencies
+node_modules/
+.pnpm-store/
+
+# Docker volumes and debug logs
+.postgres
+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/CONTRIBUTING.md b/CONTRIBUTING.md
index aa67ac5d73d..7992c32c49f 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -5,7 +5,7 @@ Welcome to the Graph Protocol! Thanks a ton for your interest in contributing.
 
 If you run into any problems feel free to create an issue. PRs are much appreciated for simple things. Here's [a list of good first issues](https://github.com/graphprotocol/graph-node/labels/good%20first%20issue). If it's something more complex we'd appreciate having a quick chat in GitHub Issues or Discord.
 
-Join the conversation on our [Discord](https://discord.gg/9a5VCua).
+Join the conversation on our [Discord](https://discord.gg/graphprotocol).
 
 Please follow the [Code of Conduct](https://github.com/graphprotocol/graph-node/blob/master/CODE_OF_CONDUCT.md) for all the communications and at events. Thank you!
 
@@ -15,7 +15,7 @@ Install development helpers:
 
 ```sh
 cargo install cargo-watch
-rustup component add rustfmt-preview
+rustup component add rustfmt
 ```
 
 Set environment variables:
@@ -79,7 +79,7 @@ Please do not merge master into your branch as you develop your pull
 request; instead, rebase your branch on top of the latest master if your
 pull request branch is long-lived.
 
-We try to keep the hostory of the `master` branch linear, and avoid merge
+We try to keep the history of the `master` branch linear, and avoid merge
 commits. Once your pull request is approved, merge it following these
 steps:
 ```
diff --git a/Cargo.lock b/Cargo.lock
index 13a40c7430c..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,5630 +14,10318 @@ dependencies = [
 
 [[package]]
 name = "addr2line"
-version = "0.15.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7a2e47a1fbe209ee101dd6d61285226744c6c8d3c21c8dc878ba6cb9f467f3a"
-dependencies = [
- "gimli 0.24.0",
-]
-
-[[package]]
-name = "addr2line"
-version = "0.16.0"
+version = "0.26.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e61f2b7f93d2c7d2b08263acaa4a363b3e276806c68af6134c44f523bf1aacd"
+checksum = "59317f77929f0e679d39364702289274de2f0f0b22cbf50b2b8cff2169a0b27a"
 dependencies = [
- "gimli 0.25.0",
+ "gimli",
 ]
 
 [[package]]
-name = "adler"
-version = "1.0.2"
+name = "adler2"
+version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
-name = "aho-corasick"
-version = "0.7.18"
+name = "ahash"
+version = "0.8.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
 dependencies = [
- "memchr",
+ "cfg-if",
+ "const-random",
+ "getrandom 0.3.1",
+ "once_cell",
+ "version_check",
+ "zerocopy",
 ]
 
 [[package]]
-name = "android_system_properties"
-version = "0.1.5"
+name = "aho-corasick"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
- "libc",
+ "memchr",
 ]
 
 [[package]]
-name = "anyhow"
-version = "1.0.69"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "224afbd727c3d6e4b90103ece64b8d1b67fbb1973b1046c2281eed3f3803f800"
-
-[[package]]
-name = "arc-swap"
-version = "1.3.0"
+name = "alloc-no-stdlib"
+version = "2.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e906254e445520903e7fc9da4f709886c84ae4bc4ddaf0e093188d66df4dc820"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
 
 [[package]]
-name = "arrayref"
-version = "0.3.6"
+name = "alloc-stdlib"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4c527152e37cf757a3f78aae5a06fbeefdb07ccc535c980a3208ee3060dd544"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
 
 [[package]]
-name = "arrayvec"
-version = "0.5.2"
+name = "allocator-api2"
+version = "0.2.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
 
 [[package]]
-name = "arrayvec"
-version = "0.7.2"
+name = "alloy"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8da52d66c7071e2e3fa2a1e5c6d088fec47b593032b254f5e980de8ea54454d6"
+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 = "ascii"
-version = "0.9.3"
+name = "alloy-chains"
+version = "0.2.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eab1c04a571841102f5345a8fc0f6bb3d31c315dec879b5c6e42e40ce7ffa34e"
+checksum = "ef3a72a2247c34a8545ee99e562b1b9b69168e5000567257ae51e91b4e6b1193"
+dependencies = [
+ "alloy-primitives",
+ "num_enum",
+ "strum 0.27.2",
+]
 
 [[package]]
-name = "assert-json-diff"
-version = "2.0.2"
+name = "alloy-consensus"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12"
+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 = "async-recursion"
-version = "1.0.0"
+name = "alloy-consensus-any"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cda8f4bcc10624c4e85bc66b3f452cca98cfa5ca002dc83a16aad2367641bea"
+checksum = "5406343e306856dc2be762700e98a16904de45dee14a07f233e742ce68daff2f"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "arbitrary",
+ "serde",
 ]
 
 [[package]]
-name = "async-stream"
-version = "0.3.4"
+name = "alloy-contract"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad445822218ce64be7a341abfb0b1ea43b5c23aa83902542a4542e78309d8e5e"
+checksum = "3ae8b60d71b92824e095b4003ff01fd2bc923017b7568997c5f459240e83499c"
 dependencies = [
- "async-stream-impl",
- "futures-core",
- "pin-project-lite",
+ "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 = "async-stream-impl"
-version = "0.3.4"
+name = "alloy-core"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4655ae1a7b0cdf149156f780c5bf3f1352bc53cbd9e0a361a7ef7b22947e965"
+checksum = "62ddde5968de6044d67af107ad835bc0069a7ca245870b94c5958a7d8712b184"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "alloy-dyn-abi",
+ "alloy-json-abi",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-sol-types",
 ]
 
 [[package]]
-name = "async-trait"
-version = "0.1.51"
+name = "alloy-dyn-abi"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44318e776df68115a881de9a8fd1b9e53368d7a4a5ce4cc48517da3393233a5e"
+checksum = "a475bb02d9cef2dbb99065c1664ab3fe1f9352e21d6d5ed3f02cdbfc06ed1abc"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "alloy-json-abi",
+ "alloy-primitives",
+ "alloy-sol-type-parser",
+ "alloy-sol-types",
+ "arbitrary",
+ "itoa",
+ "proptest",
+ "serde",
+ "serde_json",
+ "winnow 1.0.0",
 ]
 
 [[package]]
-name = "atomic_refcell"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "857253367827bd9d0fd973f0ef15506a96e79e41b0ad7aa691203a4e3214f6c8"
-
-[[package]]
-name = "atty"
-version = "0.2.14"
+name = "alloy-eip2124"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
+checksum = "741bdd7499908b3aa0b159bba11e71c8cddd009a2c2eb7a06e825f1ec87900a5"
 dependencies = [
- "hermit-abi 0.1.19",
- "libc",
- "winapi",
+ "alloy-primitives",
+ "alloy-rlp",
+ "arbitrary",
+ "crc",
+ "rand 0.8.6",
+ "serde",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "autocfg"
-version = "1.0.1"
+name = "alloy-eip2930"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+checksum = "9441120fa82df73e8959ae0e4ab8ade03de2aaae61be313fbf5746277847ce25"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rlp",
+ "arbitrary",
+ "borsh",
+ "rand 0.8.6",
+ "serde",
+]
 
 [[package]]
-name = "axum"
-version = "0.6.1"
+name = "alloy-eip7702"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08b108ad2665fa3f6e6a517c3d80ec3e77d224c47d605167aefaa5d7ef97fa48"
+checksum = "2919c5a56a1007492da313e7a3b6d45ef5edc5d33416fdec63c0d7a2702a0d20"
 dependencies = [
- "async-trait",
- "axum-core",
- "bitflags",
- "bytes",
- "futures-util",
- "http",
- "http-body",
- "hyper",
- "itoa 1.0.1",
- "matchit",
- "memchr",
- "mime",
- "percent-encoding",
- "pin-project-lite",
- "rustversion",
+ "alloy-primitives",
+ "alloy-rlp",
+ "arbitrary",
+ "borsh",
+ "k256",
+ "rand 0.8.6",
  "serde",
- "sync_wrapper",
- "tower 0.4.13",
- "tower-http",
- "tower-layer 0.3.2",
- "tower-service 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "axum-core"
-version = "0.3.0"
+name = "alloy-eip7928"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79b8558f5a0581152dc94dcd289132a1d377494bdeafcd41869b3258e3e2ad92"
+checksum = "d3231de68d5d6e75332b7489cfcc7f4dfabeba94d990a10e4b923af0e6623540"
 dependencies = [
- "async-trait",
- "bytes",
- "futures-util",
- "http",
- "http-body",
- "mime",
- "rustversion",
- "tower-layer 0.3.2",
- "tower-service 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "alloy-primitives",
+ "alloy-rlp",
+ "arbitrary",
+ "borsh",
+ "serde",
 ]
 
 [[package]]
-name = "backtrace"
-version = "0.3.61"
+name = "alloy-eips"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7a905d892734eea339e896738c14b9afce22b5318f64b951e70bf3844419b01"
+checksum = "0dca4c89ace90684b4b77366d00631ed498c9af962079af2a5dbc593a0618a77"
 dependencies = [
- "addr2line 0.16.0",
- "cc",
- "cfg-if 1.0.0",
- "libc",
- "miniz_oxide 0.4.4",
- "object 0.26.0",
- "rustc-demangle",
+ "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 = "base-x"
-version = "0.2.11"
+name = "alloy-genesis"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cbbc9d0964165b47557570cce6c952866c2678457aca742aafc9fb771d30270"
+checksum = "ab0e0fe9e6d1120ad7bb9254c3fc2b9bc80a8df42a033fb626be6559c13d5153"
+dependencies = [
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-serde",
+ "alloy-trie",
+ "borsh",
+ "serde",
+ "serde_with",
+]
 
 [[package]]
-name = "base64"
-version = "0.13.1"
+name = "alloy-json-abi"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+checksum = "7c36c9d7f9021601b04bfef14a4b64849f6d73116a4e91e071d7fbfe10247901"
+dependencies = [
+ "alloy-primitives",
+ "alloy-sol-type-parser",
+ "serde",
+ "serde_json",
+]
 
 [[package]]
-name = "base64"
-version = "0.20.0"
+name = "alloy-json-rpc"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ea22880d78093b0cbe17c89f64a7d457941e65759157ec6cb31a31d652b05e5"
+checksum = "ec0a82e56b1843bce483942d54fcadea92e676f1bde162e93c7d3b621fabc4e1"
+dependencies = [
+ "alloy-primitives",
+ "alloy-sol-types",
+ "http 1.4.2",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+ "tracing",
+]
 
 [[package]]
-name = "base64-url"
-version = "1.4.13"
+name = "alloy-network"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67a99c239d0c7e77c85dddfa9cebce48704b3c49550fcd3b84dd637e4484899f"
+checksum = "a7db7b095b0b1db1d18ce7e91dcd2e82007f2d52bfb8125e6b64633a74a06bc3"
 dependencies = [
- "base64 0.13.1",
+ "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",
+ "auto_impl",
+ "derive_more",
+ "futures-utils-wasm",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "beef"
-version = "0.5.2"
+name = "alloy-network-primitives"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
+checksum = "cd28d9bfd11729037d194f2b1d43db8642eb3f342032691f4ca96bb745479c3c"
 dependencies = [
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-serde",
  "serde",
 ]
 
 [[package]]
-name = "bigdecimal"
-version = "0.1.2"
+name = "alloy-primitives"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1374191e2dd25f9ae02e3aa95041ed5d747fc77b3c102b49fe2dd9a8117a6244"
+checksum = "4885c1409b6936c4898e646ef58baf6ec54edaf6d8179f79df805a7b85b7cf3e"
 dependencies = [
- "num-bigint",
- "num-integer",
- "num-traits",
+ "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 = "bincode"
-version = "1.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f45e9417d87227c7a56d22e471c6206462cba514c7590c09aff4cf6d1ddcad"
-dependencies = [
+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 = "bitflags"
-version = "1.3.1"
+name = "alloy-pubsub"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2da1976d75adbe5fbc88130ecd119529cf1cc6a93ae1546d8696ee66f0d21af1"
+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 = "bitvec"
-version = "1.0.0"
+name = "alloy-rlp"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1489fcb93a5bb47da0462ca93ad252ad6af2145cce58d10d46a83931ba9f016b"
+checksum = "5f70d83b765fdc080dbcd4f4db70d8d23fe4761f2f02ebfa9146b833900634b4"
 dependencies = [
- "funty",
- "radium",
- "tap",
- "wyz",
+ "alloy-rlp-derive",
+ "arrayvec",
+ "bytes",
 ]
 
 [[package]]
-name = "blake2b_simd"
-version = "1.0.0"
+name = "alloy-rlp-derive"
+version = "0.3.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72936ee4afc7f8f736d1c38383b56480b5497b4617b4a77bdbf1d2ababc76127"
+checksum = "64b728d511962dda67c1bc7ea7c03736ec275ed2cf4c35d9585298ac9ccf3b73"
 dependencies = [
- "arrayref",
- "arrayvec 0.7.2",
- "constant_time_eq 0.1.5",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "blake2s_simd"
-version = "1.0.0"
+name = "alloy-rpc-client"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db539cc2b5f6003621f1cd9ef92d7ded8ea5232c7de0f9faa2de251cd98730d4"
+checksum = "24f461f091dc8f657e73b5dea18fd63d5c7049720cd252f1eade4a7ebed6a7e1"
 dependencies = [
- "arrayref",
- "arrayvec 0.7.2",
- "constant_time_eq 0.1.5",
+ "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 = "blake3"
-version = "0.3.8"
+name = "alloy-rpc-types"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b64485778c4f16a6a5a9d335e80d449ac6c70cdd6a06d2af18a6f6f775a125b3"
+checksum = "052c031d1f7c5611997056bbcb8814e5cbf20f7efeee8c3de690555172038cf2"
 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-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 = "blake3"
-version = "1.3.3"
+name = "alloy-rpc-types-anvil"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42ae2468a89544a466886840aa467a25b766499f4f04bf7d9fcd10ecee9fccef"
+checksum = "2ff111a54268dc0bbd3b17f98571a7e27cc661dc081ad2999d91888647eb2e11"
 dependencies = [
- "arrayref",
- "arrayvec 0.7.2",
- "cc",
- "cfg-if 1.0.0",
- "constant_time_eq 0.2.4",
- "digest 0.10.5",
+ "alloy-primitives",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
+ "serde",
 ]
 
 [[package]]
-name = "block-buffer"
-version = "0.9.0"
+name = "alloy-rpc-types-any"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4152116fd6e9dadb291ae18fc1ec3575ed6d84c29642d97890f4b4a3417297e4"
+checksum = "0a6561ed4759c974d9c144500a59e3fb8c1d87327a12900d5ce455c0cae6dcb6"
 dependencies = [
- "generic-array",
+ "alloy-consensus-any",
+ "alloy-network-primitives",
+ "alloy-primitives",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "block-buffer"
-version = "0.10.2"
+name = "alloy-rpc-types-debug"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bf7fe51849ea569fd452f37822f606a5cabb684dc918707a0193fd4664ff324"
+checksum = "48b9ad6eee93dd35a9ec0a6c1c6b180892a900ee17a6ed6500921552dd71e846"
 dependencies = [
- "generic-array",
+ "alloy-primitives",
+ "alloy-rlp",
+ "derive_more",
+ "serde",
+ "serde_with",
 ]
 
 [[package]]
-name = "bollard"
-version = "0.10.1"
+name = "alloy-rpc-types-engine"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "699194c00f3a2effd3358d47f880646818e3d483190b17ebcdf598c654fb77e9"
+checksum = "7eba59e1c069f168a01982f42a57797736923b76aa854194df4930be17867e1c"
 dependencies = [
- "base64 0.13.1",
- "bollard-stubs",
- "bytes",
- "chrono",
- "ct-logs",
- "dirs-next",
- "futures-core",
- "futures-util",
- "hex",
- "http",
- "hyper",
- "hyper-unix-connector",
- "log",
- "pin-project",
+ "alloy-consensus",
+ "alloy-eips",
+ "alloy-primitives",
+ "alloy-rlp",
+ "alloy-serde",
+ "arbitrary",
+ "derive_more",
+ "rand 0.8.6",
  "serde",
- "serde_derive",
- "serde_json",
- "serde_urlencoded",
- "thiserror",
- "tokio",
- "tokio-util 0.6.7",
- "url",
- "winapi",
+ "strum 0.27.2",
 ]
 
 [[package]]
-name = "bollard-stubs"
-version = "1.41.0"
+name = "alloy-rpc-types-eth"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed2f2e73fffe9455141e170fb9c1feb0ac521ec7e7dcd47a7cab72a658490fb8"
+checksum = "175a2a5b6017d7f61b5e4b800d21215fe8e94fe729d00828e13bb6d93dcf3492"
 dependencies = [
- "chrono",
+ "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 = "bs58"
-version = "0.4.0"
+name = "alloy-rpc-types-trace"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "771fe0050b883fcc3ea2359b1a96bcfbc090b7116eae7c3c512c7a083fdf23d3"
+checksum = "514b4b1ce3354f65067b4fc7eb75358e0f2ec8be3340c96dea65d6894f9ca435"
+dependencies = [
+ "alloy-primitives",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+]
 
 [[package]]
-name = "bstr"
-version = "0.2.16"
+name = "alloy-rpc-types-txpool"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90682c8d613ad3373e66de8c6411e0ae2ab2571e879d2efbf73558cc66f21279"
+checksum = "76e34a42ebb4a71ab0bfdebc6d2f3c7bf809f01edf154d08fed159d10d1ef1d4"
 dependencies = [
- "memchr",
+ "alloy-primitives",
+ "alloy-rpc-types-eth",
+ "alloy-serde",
+ "serde",
 ]
 
 [[package]]
-name = "bumpalo"
-version = "3.12.0"
+name = "alloy-serde"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
+checksum = "cc21a8772af7d78bba286726aa245bd2ff81cd9abe230afea2e91578996831c9"
+dependencies = [
+ "alloy-primitives",
+ "arbitrary",
+ "serde",
+ "serde_json",
+]
 
 [[package]]
-name = "byte-slice-cast"
-version = "1.2.0"
+name = "alloy-signer"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d30c751592b77c499e7bce34d99d67c2c11bdc0574e9a488ddade14150a4698"
+checksum = "8ffbce94c50dd9d4d1f83e044c5595bbd3ada981bd3057ce28b3a5470e77385d"
+dependencies = [
+ "alloy-primitives",
+ "async-trait",
+ "auto_impl",
+ "either",
+ "elliptic-curve",
+ "k256",
+ "thiserror 2.0.18",
+]
 
 [[package]]
-name = "byteorder"
-version = "1.4.3"
+name = "alloy-signer-local"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
+checksum = "e48366d2c42b8d95ef951101bafa28486590f21b7a1e68b6b2d069746557bbe3"
+dependencies = [
+ "alloy-consensus",
+ "alloy-network",
+ "alloy-primitives",
+ "alloy-signer",
+ "async-trait",
+ "k256",
+ "rand 0.8.6",
+ "thiserror 2.0.18",
+]
 
 [[package]]
-name = "bytes"
-version = "1.2.1"
+name = "alloy-sol-macro"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec8a7b6a70fde80372154c65702f00a0f56f3e1c36abbc6c440484be248856db"
+checksum = "840128ed2b2971d6d4668a553fe403a82683d3acc646c73e75887e7157408033"
+dependencies = [
+ "alloy-sol-macro-expander",
+ "alloy-sol-macro-input",
+ "proc-macro-error2",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
 
 [[package]]
-name = "cc"
-version = "1.0.69"
+name = "alloy-sol-macro-expander"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e70cc2f62c6ce1868963827bd677764c62d07c3d9a3e1fb1177ee1a9ab199eb2"
+checksum = "63ec265e5d65d725175f6ca7711c970824c90ef9c0d1f1973711d4150ee612dd"
 dependencies = [
- "jobserver",
+ "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 = "cfg-if"
-version = "0.1.10"
+name = "alloy-sol-macro-input"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+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 = "cfg-if"
-version = "1.0.0"
+name = "alloy-sol-type-parser"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+checksum = "857b470ecdd2ed38beaf82ad1a38c516a8ff75266750f38b9eeed001d575241b"
+dependencies = [
+ "serde",
+ "winnow 1.0.0",
+]
 
 [[package]]
-name = "chrono"
-version = "0.4.23"
+name = "alloy-sol-types"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16b0a3d9ed01224b22057780a37bb8c5dbfe1be8ba48678e7bf57ec4b385411f"
+checksum = "384cf252de0db2dec52821eac037a7f57e2aa33fe5b900ce6fe39973402341f1"
 dependencies = [
- "iana-time-zone",
- "js-sys",
- "num-integer",
- "num-traits",
+ "alloy-json-abi",
+ "alloy-primitives",
+ "alloy-sol-macro",
  "serde",
- "time 0.1.44",
- "wasm-bindgen",
- "winapi",
 ]
 
 [[package]]
-name = "cid"
-version = "0.10.1"
+name = "alloy-transport"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd94671561e36e4e7de75f753f577edafb0e7c05d6e4547229fdf7938fbcd2c3"
+checksum = "86052fdcec72d37ca4aa4b66254601e7453c45a6e1c70aa4561033d002fb80cc"
 dependencies = [
- "core2",
- "multibase",
- "multihash 0.18.0",
+ "alloy-json-rpc",
+ "auto_impl",
+ "base64",
+ "derive_more",
+ "futures 0.3.31",
+ "futures-utils-wasm",
+ "parking_lot",
  "serde",
- "unsigned-varint",
+ "serde_json",
+ "thiserror 2.0.18",
+ "tokio",
+ "tower 0.5.2",
+ "tracing",
+ "url",
+ "wasmtimer",
 ]
 
 [[package]]
-name = "clap"
-version = "3.2.23"
+name = "alloy-transport-http"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71655c45cb9845d3270c9d6df84ebe72b4dad3c2ba3f7023ad47c144e4e473a5"
+checksum = "b273587487921274f4f5d0ef2c7ef36944dcbb75a4e2318e69eae822bd263f91"
 dependencies = [
- "atty",
- "bitflags",
- "clap_derive",
- "clap_lex",
- "indexmap",
- "once_cell",
- "strsim",
- "termcolor",
- "textwrap",
+ "alloy-json-rpc",
+ "alloy-transport",
+ "itertools 0.13.0",
+ "reqwest 0.13.2",
+ "serde_json",
+ "tower 0.5.2",
+ "tracing",
+ "url",
 ]
 
 [[package]]
-name = "clap_derive"
-version = "3.2.18"
+name = "alloy-transport-ipc"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea0c8bce528c4be4da13ea6fead8965e95b6073585a2f05204bd8f4119f82a65"
+checksum = "bfb89df168b24773ef603af14f2449c05a7d3f27d05d3eceaea6bf96cccae168"
 dependencies = [
- "heck 0.4.1",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn",
+ "alloy-json-rpc",
+ "alloy-pubsub",
+ "alloy-transport",
+ "bytes",
+ "futures 0.3.31",
+ "interprocess",
+ "pin-project",
+ "serde",
+ "serde_json",
+ "tokio",
+ "tokio-util",
+ "tracing",
 ]
 
 [[package]]
-name = "clap_lex"
-version = "0.2.2"
+name = "alloy-transport-ws"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5538cd660450ebeb4234cfecf8f2284b844ffc4c50531e66d584ad5b91293613"
+checksum = "33e32e0b47d3b3bf5770b7c132090c614b008d307c5e1544f1925f5b7e9e9af6"
 dependencies = [
- "os_str_bytes",
+ "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 = "combine"
-version = "3.8.1"
+name = "alloy-trie"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da3da6baa321ec19e1cc41d31bf599f00c783d0517095cdaf0332e3fe8d20680"
+checksum = "428aa0f0e0658ff091f8f667c406e034b431cb10abd39de4f507520968acc499"
 dependencies = [
- "ascii",
- "byteorder",
- "either",
- "memchr",
- "unreachable",
+ "alloy-primitives",
+ "alloy-rlp",
+ "arbitrary",
+ "arrayvec",
+ "derive_arbitrary",
+ "derive_more",
+ "nybbles",
+ "proptest",
+ "proptest-derive 0.5.1",
+ "serde",
+ "smallvec",
+ "tracing",
 ]
 
 [[package]]
-name = "common-multipart-rfc7578"
-version = "0.6.0"
+name = "alloy-tx-macros"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5baee326bc603965b0f26583e1ecd7c111c41b49bd92a344897476a352798869"
+checksum = "01a0035943b75fe1e249f52e688492d7a1b1826bc2d19b8e1d5d3c24a2ad8f50"
 dependencies = [
- "bytes",
- "futures-core",
- "futures-util",
- "http",
- "mime",
- "mime_guess",
- "rand",
- "thiserror",
+ "darling 0.23.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "console"
-version = "0.13.0"
+name = "android_system_properties"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a50aab2529019abfabfa93f1e6c41ef392f91fbf179b347a7e96abb524884a08"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
 dependencies = [
- "encode_unicode",
- "lazy_static",
  "libc",
- "regex",
- "terminal_size",
- "unicode-width",
- "winapi",
- "winapi-util",
 ]
 
 [[package]]
-name = "const_fn_assert"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27d614f23f34f7b5165a77dc1591f497e2518f9cec4b4f4b92bfc4dc6cf7a190"
-
-[[package]]
-name = "constant_time_eq"
-version = "0.1.5"
+name = "anstream"
+version = "0.6.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse 0.2.4",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
 
 [[package]]
-name = "constant_time_eq"
-version = "0.2.4"
+name = "anstream"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3ad85c1f65dc7b37604eb0e89748faf0b9653065f2a8ef69f96a687ec1e9279"
+checksum = "824a212faf96e9acacdbd09febd34438f8f711fb84e09a8916013cd7815ca28d"
+dependencies = [
+ "anstyle",
+ "anstyle-parse 1.0.0",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
 
 [[package]]
-name = "convert_case"
-version = "0.4.0"
+name = "anstyle"
+version = "1.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+checksum = "940b3a0ca603d1eade50a4846a2afffd5ef57a9feac2c0e2ec2e14f9ead76000"
 
 [[package]]
-name = "core-foundation"
-version = "0.9.1"
+name = "anstyle-parse"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a89e2ae426ea83155dccf10c0fa6b1463ef6d5fcb44cee0b224a408fa640a62"
+checksum = "c03a11a9034d92058ceb6ee011ce58af4a9bf61491aa7e1e59ecd24bd40d22d4"
 dependencies = [
- "core-foundation-sys",
- "libc",
+ "utf8parse",
 ]
 
 [[package]]
-name = "core-foundation-sys"
-version = "0.8.3"
+name = "anstyle-parse"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5827cebf4670468b8772dd191856768aedcb1b0278a04f989f7766351917b9dc"
+checksum = "52ce7f38b242319f7cabaa6813055467063ecdc9d355bbb4ce0c68908cd8130e"
+dependencies = [
+ "utf8parse",
+]
 
 [[package]]
-name = "core2"
-version = "0.4.0"
+name = "anstyle-query"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b49ba7ef1ad6107f8824dbe97de947cbaac53c44e7f9756a1fba0d37c1eec505"
+checksum = "ad186efb764318d35165f1758e7dcef3b10628e26d41a44bc5550652e6804391"
 dependencies = [
- "memchr",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "cpp_demangle"
-version = "0.3.3"
+name = "anstyle-wincon"
+version = "3.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ea47428dc9d2237f3c6bc134472edfd63ebba0af932e783506dcfd66f10d18a"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
 dependencies = [
- "cfg-if 1.0.0",
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
-name = "cpufeatures"
-version = "0.1.5"
+name = "anyhow"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "66c99696f6c9dd7f35d486b9d04d7e6e202aa3e8c40d553f2fdf5e7e0c6a71ef"
-dependencies = [
- "libc",
-]
+checksum = "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3"
 
 [[package]]
-name = "cpufeatures"
-version = "0.2.2"
+name = "arbitrary"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59a6001667ab124aebae2a495118e11d30984c3a653e99d86d58971708cf5e4b"
+checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
 dependencies = [
- "libc",
+ "derive_arbitrary",
 ]
 
 [[package]]
-name = "cranelift-bforest"
-version = "0.74.0"
+name = "arc-swap"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8ca3560686e7c9c7ed7e0fe77469f2410ba5d7781b1acaa9adc8d8deea28e3e"
+checksum = "6a3a1fd6f75306b68087b831f025c712524bcb19aad54e557b1129cfa0a2b207"
 dependencies = [
- "cranelift-entity",
+ "rustversion",
 ]
 
 [[package]]
-name = "cranelift-codegen"
-version = "0.74.0"
+name = "arcstr"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf9bf1ffffb6ce3d2e5ebc83549bd2436426c99b31cc550d521364cbe35d276"
-dependencies = [
- "cranelift-bforest",
- "cranelift-codegen-meta",
- "cranelift-codegen-shared",
- "cranelift-entity",
- "gimli 0.24.0",
- "log",
- "regalloc",
- "serde",
- "smallvec",
- "target-lexicon",
-]
+checksum = "03918c3dbd7701a85c6b9887732e2921175f26c350b4563841d0958c21d57e6d"
 
 [[package]]
-name = "cranelift-codegen-meta"
-version = "0.74.0"
+name = "ark-ff"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4cc21936a5a6d07e23849ffe83e5c1f6f50305c074f4b2970ca50c13bf55b821"
+checksum = "6b3235cc41ee7a12aaaf2c575a2ad7b46713a8a50bda2fc3b003a04845c05dd6"
 dependencies = [
- "cranelift-codegen-shared",
- "cranelift-entity",
+ "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 = "cranelift-codegen-shared"
-version = "0.74.0"
+name = "ark-ff"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca5b6ffaa87560bebe69a5446449da18090b126037920b0c1c6d5945f72faf6b"
+checksum = "ec847af850f44ad29048935519032c33da8aa03340876d351dfab5660d2966ba"
 dependencies = [
- "serde",
+ "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-entity"
-version = "0.74.0"
+name = "ark-ff"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d6b4a8bef04f82e4296782646f733c641d09497df2fabf791323fefaa44c64c"
-dependencies = [
- "serde",
+checksum = "a177aba0ed1e0fbb62aa9f6d0502e9b46dad8c2eab04c14258a1212d2557ea70"
+dependencies = [
+ "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-frontend"
-version = "0.74.0"
+name = "ark-ff-asm"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c31b783b351f966fce33e3c03498cb116d16d97a8f9978164a60920bd0d3a99c"
+checksum = "db02d390bf6643fb404d3d22d31aee1c4bc4459600aef9113833d17e786c6e44"
 dependencies = [
- "cranelift-codegen",
- "log",
- "smallvec",
- "target-lexicon",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
-name = "cranelift-native"
-version = "0.74.0"
+name = "ark-ff-asm"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a77c88d3dd48021ff1e37e978a00098524abd3513444ae252c08d37b310b3d2a"
+checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348"
 dependencies = [
- "cranelift-codegen",
- "target-lexicon",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
-name = "cranelift-wasm"
-version = "0.74.0"
+name = "ark-ff-asm"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edb6d408e2da77cdbbd65466298d44c86ae71c1785d2ab0d8657753cdb4d9d89"
+checksum = "62945a2f7e6de02a31fe400aa489f0e0f5b2502e69f95f853adb82a96c7a6b60"
 dependencies = [
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-frontend",
- "itertools",
- "log",
- "serde",
- "smallvec",
- "thiserror",
- "wasmparser",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "crc32fast"
-version = "1.2.1"
+name = "ark-ff-macros"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81156fece84ab6a9f2afdb109ce3ae577e42b1228441eded99bd77f627953b1a"
+checksum = "db2fd794a08ccb318058009eefdf15bcaaaaf6f8161eb3345f907222bac38b20"
 dependencies = [
- "cfg-if 1.0.0",
+ "num-bigint 0.4.6",
+ "num-traits",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
-name = "crossbeam"
-version = "0.8.2"
+name = "ark-ff-macros"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2801af0d36612ae591caa9568261fddce32ce6e08a7275ea334a06a4ad021a2c"
+checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-epoch",
- "crossbeam-queue",
- "crossbeam-utils",
+ "num-bigint 0.4.6",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
 ]
 
 [[package]]
-name = "crossbeam-channel"
-version = "0.5.5"
+name = "ark-ff-macros"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c02a4d71819009c192cf4872265391563fd6a84c81ff2c0f2a7026ca4c1d85c"
+checksum = "09be120733ee33f7693ceaa202ca41accd5653b779563608f1234f78ae07c4b3"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
+ "num-bigint 0.4.6",
+ "num-traits",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "crossbeam-deque"
-version = "0.8.1"
+name = "ark-serialize"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6455c0ca19f0d2fbf751b908d5c55c1f5cbc65e03c4225427254b46890bdde1e"
+checksum = "1d6c2b318ee6e10f8c2853e73a83adc0ccb88995aa978d8a3408d492ab2ee671"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-epoch",
- "crossbeam-utils",
+ "ark-std 0.3.0",
+ "digest 0.9.0",
 ]
 
 [[package]]
-name = "crossbeam-epoch"
-version = "0.9.5"
+name = "ark-serialize"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
+checksum = "adb7b85a02b83d2f22f89bd5cac66c9c89474240cb6207cb1efc16d098e822a5"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
- "lazy_static",
- "memoffset",
- "scopeguard",
+ "ark-std 0.4.0",
+ "digest 0.10.7",
+ "num-bigint 0.4.6",
 ]
 
 [[package]]
-name = "crossbeam-queue"
-version = "0.3.2"
+name = "ark-serialize"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b10ddc024425c88c2ad148c1b0fd53f4c6d38db9697c9f1588381212fa657c9"
+checksum = "3f4d068aaf107ebcd7dfb52bc748f8030e0fc930ac8e360146ca54c1203088f7"
 dependencies = [
- "cfg-if 1.0.0",
- "crossbeam-utils",
+ "ark-std 0.5.0",
+ "arrayvec",
+ "digest 0.10.7",
+ "num-bigint 0.4.6",
 ]
 
 [[package]]
-name = "crossbeam-utils"
-version = "0.8.8"
+name = "ark-std"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bf124c720b7686e3c2663cf54062ab0f68a88af2fb6a030e87e30bf721fcb38"
+checksum = "1df2c09229cbc5a028b1d70e00fdb2acee28b1055dfb5ca73eea49c5a25c4e7c"
 dependencies = [
- "cfg-if 1.0.0",
- "lazy_static",
+ "num-traits",
+ "rand 0.8.6",
 ]
 
 [[package]]
-name = "crunchy"
-version = "0.2.2"
+name = "ark-std"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185"
+dependencies = [
+ "num-traits",
+ "rand 0.8.6",
+]
 
 [[package]]
-name = "crypto-common"
-version = "0.1.3"
+name = "ark-std"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57952ca27b5e3606ff4dd79b0020231aaf9d6aa76dc05fd30137538c50bd3ce8"
+checksum = "246a225cc6131e9ee4f24619af0f19d67761fff15d7ccc22e42b80846e69449a"
 dependencies = [
- "generic-array",
- "typenum",
+ "num-traits",
+ "rand 0.8.6",
 ]
 
 [[package]]
-name = "crypto-mac"
-version = "0.8.0"
+name = "arrayvec"
+version = "0.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b584a330336237c1eecd3e94266efb216c56ed91225d634cb2991c5f3fd1aeab"
+checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
 dependencies = [
- "generic-array",
- "subtle",
+ "serde",
 ]
 
 [[package]]
-name = "crypto-mac"
-version = "0.10.1"
+name = "arrow"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bff07008ec701e8028e2ceb8f83f0e4274ee62bd2dbdc4fefff2e9a91824081a"
+checksum = "ffaaa3e009861fd829d0a24dd6f115aa8e4634324bb092147d43baafe69ca4a7"
 dependencies = [
- "generic-array",
- "subtle",
+ "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 = "ct-logs"
-version = "0.8.0"
+name = "arrow-arith"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1a816186fa68d9e426e3cb4ae4dff1fcd8e4a2c34b781bf7a822574a0d0aac8"
+checksum = "3ac95125e1d71c4a252b5a9c729aef111e80418f08aaa6dbabd1ba66918247fc"
 dependencies = [
- "sct 0.6.1",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "num-traits",
 ]
 
 [[package]]
-name = "ctor"
-version = "0.1.20"
+name = "arrow-array"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e98e2ad1a782e33928b96fc3948e7c355e5af34ba4de7670fe8bac2a3b2006d"
+checksum = "0c60c79628e9a97cb90d7a0dc3e944f216a902f837d4ecabc14d524bddbbc137"
 dependencies = [
- "quote",
- "syn",
+ "ahash",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "chrono",
+ "half",
+ "hashbrown 0.17.0",
+ "num-complex",
+ "num-integer",
+ "num-traits",
 ]
 
 [[package]]
-name = "darling"
-version = "0.13.0"
+name = "arrow-buffer"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "757c0ded2af11d8e739c4daea1ac623dd1624b06c844cf3f5a39f1bdbd99bb12"
+checksum = "6026f638c400e9878c1b1cc05c3cfd46fbf381285916ab408678701c1df46c1a"
 dependencies = [
- "darling_core",
- "darling_macro",
+ "bytes",
+ "half",
+ "num-bigint 0.4.6",
+ "num-traits",
 ]
 
 [[package]]
-name = "darling_core"
-version = "0.13.0"
+name = "arrow-cast"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c34d8efb62d0c2d7f60ece80f75e5c63c1588ba68032740494b0b9a996466e3"
+checksum = "c82c236c3caf8df5664284f3f1fbe89938852163998c3fdbf37e84ac220445e9"
 dependencies = [
- "fnv",
- "ident_case",
- "proc-macro2",
- "quote",
- "strsim",
- "syn",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
+ "atoi",
+ "base64",
+ "chrono",
+ "half",
+ "lexical-core",
+ "num-traits",
+ "ryu",
 ]
 
 [[package]]
-name = "darling_macro"
-version = "0.13.0"
+name = "arrow-csv"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ade7bff147130fe5e6d39f089c6bd49ec0250f35d70b2eebf72afdfc919f15cc"
+checksum = "12714e5fb7954159af1e26d4e0d37108bcf1a2ad5ee5c5bf02a944d564d588b7"
 dependencies = [
- "darling_core",
- "quote",
- "syn",
+ "arrow-array",
+ "arrow-cast",
+ "arrow-schema",
+ "chrono",
+ "csv",
+ "csv-core",
+ "regex",
 ]
 
 [[package]]
-name = "data-encoding"
-version = "2.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ee2393c4a91429dffb4bedf19f4d6abf27d8a732c8ce4980305d782e5426d57"
-
-[[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",
+ "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",
+ "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",
- "bitflags",
- "byteorder",
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-cast",
+ "arrow-ord",
+ "arrow-schema",
+ "arrow-select",
  "chrono",
- "diesel_derives",
- "num-bigint",
- "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 0.4.1",
- "proc-macro2",
- "quote",
- "syn",
+ "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",
-]
+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"
+name = "arrow-string"
+version = "59.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e25ea47919b1560c4e3b7fe0aaab9becf5b84a10325ddf7db0f0ba5e1026499"
+checksum = "99bc95847f3ff62a2b03d6f8ce2e3e78f01362060549a2a311898dd442f6256d"
+dependencies = [
+ "arrow-array",
+ "arrow-buffer",
+ "arrow-data",
+ "arrow-schema",
+ "arrow-select",
+ "memchr",
+ "num-traits",
+ "regex",
+ "regex-syntax",
+]
 
 [[package]]
-name = "difflib"
-version = "0.4.0"
+name = "ascii_utils"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
+checksum = "71938f30533e4d95a6d17aa530939da3842c2ab6f4f84b9dae68447e4129f74a"
 
 [[package]]
-name = "digest"
-version = "0.9.0"
+name = "assert-json-diff"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3dd60d1080a57a05ab032377049e0591415d2b31afd7028356dbf3cc6dcb066"
+checksum = "47e4f2b81832e72834d7518d8487a0396a28cc408186a2e8854c0f98011faf12"
 dependencies = [
- "generic-array",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "digest"
-version = "0.10.5"
+name = "async-compression"
+version = "0.4.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "adfbc57365a37acbd2ebf2b64d7e69bb766e2fea813521ed536f5d0520dcf86c"
+checksum = "ddb939d66e4ae03cee6091612804ba446b12878410cfa17f785f4dd67d4014e8"
 dependencies = [
- "block-buffer 0.10.2",
- "crypto-common",
- "subtle",
+ "brotli",
+ "flate2",
+ "futures-core",
+ "memchr",
+ "pin-project-lite",
+ "tokio",
 ]
 
 [[package]]
-name = "directories-next"
-version = "2.0.0"
+name = "async-graphql"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "339ee130d97a610ea5a5872d2bbb130fdf68884ff09d3028b81bec8a1ac23bbc"
+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"
-version = "4.0.0"
+name = "async-graphql-axum"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
+checksum = "a1e37c5532e4b686acf45e7162bc93da91fc2c702fb0d465efc2c20c8f973795"
 dependencies = [
- "dirs-sys",
+ "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-next"
-version = "2.0.0"
+name = "async-graphql-derive"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1"
+checksum = "2e6cbeadc8515e66450fba0985ce722192e28443697799988265d86304d7cc68"
 dependencies = [
- "cfg-if 1.0.0",
- "dirs-sys-next",
+ "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 = "dirs-sys"
-version = "0.3.7"
+name = "async-graphql-parser"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
+checksum = "e64ef70f77a1c689111e52076da1cd18f91834bcb847de0a9171f83624b07fbf"
 dependencies = [
- "libc",
- "redox_users",
- "winapi",
+ "async-graphql-value",
+ "pest",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "dirs-sys-next"
-version = "0.1.2"
+name = "async-graphql-value"
+version = "7.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d"
+checksum = "3e3ef112905abea9dea592fc868a6873b10ebd3f983e83308f995d6284e9ba41"
 dependencies = [
- "libc",
- "redox_users",
- "winapi",
+ "bytes",
+ "indexmap 2.14.0",
+ "serde",
+ "serde_json",
 ]
 
 [[package]]
-name = "either"
-version = "1.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90e5c1c8368803113bf0c9584fc495a58b86dc8a29edbf8fe877d21d9507e797"
-
-[[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-io"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80df024fbc5ac80f87dfef0d9f5209a252f2a497f7f42944cff24d8253cac065"
+checksum = "456b8a8feb6f42d237746d4b3e9a178494627745c3c56c6ea55d92ba50d026fc"
 dependencies = [
- "cfg-if 1.0.0",
+ "autocfg",
+ "cfg-if",
+ "concurrent-queue",
+ "futures-io",
+ "futures-lite",
+ "parking",
+ "polling",
+ "rustix 1.1.4",
+ "slab",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "env_logger"
-version = "0.7.1"
+name = "async-lock"
+version = "3.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36"
+checksum = "290f7f2596bd5b78a9fec8088ccd89180d7f9f55b94b0576823bbbdc72ee8311"
 dependencies = [
- "atty",
- "humantime 1.3.0",
- "log",
- "regex",
- "termcolor",
+ "event-listener",
+ "event-listener-strategy",
+ "pin-project-lite",
 ]
 
 [[package]]
-name = "env_logger"
-version = "0.9.3"
+name = "async-recursion"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7"
+checksum = "3b43422f69d8ff38f95f1b2bb76517c91589a924d1559a0e935d7c8ce0274c11"
 dependencies = [
- "atty",
- "humantime 2.1.0",
- "log",
- "regex",
- "termcolor",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "envconfig"
-version = "0.10.0"
+name = "async-stream"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea81cc7e21f55a9d9b1efb6816904978d0bfbe31a50347cb24b2e75564bcac9b"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
 dependencies = [
- "envconfig_derive",
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
 ]
 
 [[package]]
-name = "envconfig_derive"
-version = "0.10.0"
+name = "async-stream-impl"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dfca278e5f84b45519acaaff758ebfa01f18e96998bc24b8f1b722dd804b9bf"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "errno"
-version = "0.2.7"
+name = "async-trait"
+version = "0.1.89"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fa68f2fb9cae9d37c9b2b3584aba698a2e97f72d7aef7b9f7aa71d8b54ce46fe"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
 dependencies = [
- "errno-dragonfly",
- "libc",
- "winapi",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "errno-dragonfly"
-version = "0.1.1"
+name = "async_io_stream"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14ca354e36190500e1e1fb267c647932382b54053c50b14970856c0b00a35067"
+checksum = "b6d7b9decdf35d8908a7e3ef02f64c5e9b1695e230154c0e8de3969142d9b94c"
 dependencies = [
- "gcc",
- "libc",
+ "futures 0.3.31",
+ "pharos",
+ "rustc_version 0.4.0",
 ]
 
 [[package]]
-name = "ethabi"
-version = "17.2.0"
+name = "asynk-strim"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e4966fba78396ff92db3b817ee71143eccd98acf0f876b8d600e585a670c5d1b"
+checksum = "52697735bdaac441a29391a9e97102c74c6ef0f9b60a40cf109b1b404e29d2f6"
 dependencies = [
- "ethereum-types",
- "hex",
- "once_cell",
- "regex",
- "serde",
- "serde_json",
- "sha3",
- "thiserror",
- "uint",
+ "futures-core",
+ "pin-project-lite",
 ]
 
 [[package]]
-name = "ethbloom"
-version = "0.12.1"
+name = "atoi"
+version = "2.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11da94e443c60508eb62cf256243a64da87304c2802ac2528847f79d750007ef"
+checksum = "f28d99ec8bfea296261ca1af174f24225171fea9664ba9003cbebee704810528"
 dependencies = [
- "crunchy",
- "fixed-hash",
- "impl-rlp",
- "impl-serde",
- "tiny-keccak 2.0.2",
+ "num-traits",
 ]
 
 [[package]]
-name = "ethereum-types"
-version = "0.13.1"
+name = "atomic-waker"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2827b94c556145446fcce834ca86b7abf0c39a805883fe20e72c5bfdb5a0dc6"
-dependencies = [
- "ethbloom",
- "fixed-hash",
- "impl-rlp",
- "impl-serde",
- "primitive-types",
- "uint",
-]
+checksum = "1505bd5d3d116872e7271a6d4e16d81d0c8570876c8de68093a09ac269d8aac0"
 
 [[package]]
-name = "fallible-iterator"
-version = "0.2.0"
+name = "atomic_refcell"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
+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"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
-[[package]]
-name = "foreign-types"
-version = "0.3.2"
+name = "axum"
+version = "0.8.9"
 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.1.0"
+name = "backon"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
+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.16"
+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 = "74ed2411805f6e4e3d9bc904c95d5d423b89b3b25dc0250aa74729de20629ff9"
+checksum = "1374191e2dd25f9ae02e3aa95041ed5d747fc77b3c102b49fe2dd9a8117a6244"
 dependencies = [
- "futures-core",
- "futures-sink",
+ "num-bigint 0.2.6",
+ "num-integer",
+ "num-traits",
+ "serde",
 ]
 
 [[package]]
-name = "futures-core"
-version = "0.3.16"
+name = "bimap"
+version = "0.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af51b1b4a7fdff033703db39de8802c673eb91855f2e0d47dcf3bf2c0ef01f99"
+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.16"
+name = "bit-vec"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b0e06c393068f3a6ef246c75cdca793d6a46347e75286933e5e75fd2fd11582"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
 
 [[package]]
-name = "futures-macro"
-version = "0.3.16"
+name = "bitcoin-io"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c54913bae956fb8df7f4dc6fc90362aa72e69148e3f39041fbe8742d21e0ac57"
-dependencies = [
- "autocfg",
- "proc-macro-hack",
- "proc-macro2",
- "quote",
- "syn",
-]
+checksum = "2dee39a0ee5b4095224a0cfc6bf4cc1baf0f9624b96b367e53b66d974e51d953"
 
 [[package]]
-name = "futures-sink"
-version = "0.3.16"
+name = "bitcoin_hashes"
+version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0f30aaa67363d119812743aa5f33c201a7a66329f97d1a887022971feea4b53"
+checksum = "26ec84b80c482df901772e931a9a681e26a1b9ee2302edeff23cb30328745c8b"
+dependencies = [
+ "bitcoin-io",
+ "hex-conservative",
+]
 
 [[package]]
-name = "futures-task"
-version = "0.3.16"
+name = "bitflags"
+version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbe54a98670017f3be909561f6ad13e810d9a51f3f061b902062ca3da80799f2"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
-name = "futures-timer"
-version = "3.0.2"
+name = "bitflags"
+version = "2.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c"
+checksum = "c4512299f36f043ab09a583e57bceb5a5aab7a73db1805848e8fef3c9e8c78b3"
 
 [[package]]
-name = "futures-util"
-version = "0.3.16"
+name = "bitvec"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67eb846bfd58e44a8481a00049e82c43e0ccb5d61f8dc071057cb19249dd4d78"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
 dependencies = [
- "autocfg",
- "futures 0.1.31",
- "futures-channel",
- "futures-core",
- "futures-io",
- "futures-macro",
- "futures-sink",
- "futures-task",
- "memchr",
- "pin-project-lite",
- "pin-utils",
- "proc-macro-hack",
- "proc-macro-nested",
- "slab",
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
 ]
 
 [[package]]
-name = "gcc"
-version = "0.3.55"
+name = "blake3"
+version = "1.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f5f3913fa0bfe7ee1fd8248b6b9f42a5af4b9d65ec2dd2c3c26132b950ecfc2"
+checksum = "6d9e454fc11f76977dc803893aff6304ed33d6a26efae8696573bea74baa27ae"
+dependencies = [
+ "arrayvec",
+ "cc",
+ "cfg-if",
+ "constant_time_eq",
+ "cpufeatures 0.3.0",
+]
 
 [[package]]
-name = "generic-array"
-version = "0.14.4"
+name = "block-buffer"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "501466ecc8a30d1d3b7fc9229b122b2ce8ed6e9d9223f1138d4babb253e51817"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
 dependencies = [
- "typenum",
- "version_check",
+ "generic-array",
 ]
 
 [[package]]
-name = "getrandom"
-version = "0.2.3"
+name = "block-buffer"
+version = "0.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcd999463524c52659517fe2cea98493cfe485d10565e7b0fb07dbba7ad2753"
+checksum = "cdd35008169921d80bc60d3d0ab416eecb028c4cd653352907921d95084790be"
 dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "wasi",
+ "hybrid-array",
 ]
 
 [[package]]
-name = "gimli"
-version = "0.24.0"
+name = "blst"
+version = "0.3.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0e4075386626662786ddb0ec9081e7c7eeb1ba31951f447ca780ef9f5d568189"
+checksum = "dcdb4c7013139a150f9fc55d123186dbfaba0d912817466282c73ac49e71fb45"
 dependencies = [
- "fallible-iterator",
- "indexmap",
- "stable_deref_trait",
+ "cc",
+ "glob",
+ "threadpool",
+ "zeroize",
 ]
 
 [[package]]
-name = "gimli"
-version = "0.25.0"
+name = "borsh"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0a01e0497841a3b2db4f8afa483cce65f7e96a3498bd6c541734792aeac8fe7"
+checksum = "d1da5ab77c1437701eeff7c88d968729e7766172279eab0676857b3d63af7a6f"
+dependencies = [
+ "borsh-derive",
+ "cfg_aliases",
+]
 
 [[package]]
-name = "git-testament"
-version = "0.2.4"
+name = "borsh-derive"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "986bf57c808270f3a0a0652c3bfce0f5d667aa5f5b465616dc697c7f390834b1"
+checksum = "0686c856aa6aac0c4498f936d7d6a02df690f614c03e4d906d1018062b5c5e2c"
 dependencies = [
- "git-testament-derive",
- "no-std-compat",
+ "once_cell",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "git-testament-derive"
-version = "0.1.14"
+name = "brotli"
+version = "8.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a782db5866c7ab75f3552dda4cbf34e3e257cc64c963c6ed5af1e12818e8ae6"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
 dependencies = [
- "log",
- "proc-macro2",
- "quote",
- "syn",
- "time 0.3.17",
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
 ]
 
 [[package]]
-name = "globset"
-version = "0.4.8"
+name = "brotli-decompressor"
+version = "5.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10463d9ff00a2a068db14231982f5132edebad0d7660cd956a1c30292dbcbfbd"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
 dependencies = [
- "aho-corasick",
- "bstr",
- "fnv",
- "log",
- "regex",
+ "alloc-no-stdlib",
+ "alloc-stdlib",
 ]
 
 [[package]]
-name = "graph"
-version = "0.30.0"
+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 = "bf88ba1141d185c399bee5288d850d63b8369520c1eafc32a0430b5b6c287bf4"
 dependencies = [
- "Inflector",
- "anyhow",
- "async-stream",
- "async-trait",
- "atomic_refcell",
- "bigdecimal",
- "bytes",
- "chrono",
- "cid",
- "clap",
- "diesel",
- "diesel_derives",
- "envconfig",
- "ethabi",
- "futures 0.1.31",
- "futures 0.3.16",
- "graphql-parser",
- "hex",
- "http",
- "isatty",
- "itertools",
- "lazy_static",
- "maplit",
- "num-bigint",
- "num-traits",
- "num_cpus",
- "parking_lot 0.12.1",
- "petgraph",
- "priority-queue",
- "prometheus",
- "prost",
- "prost-types",
- "rand",
- "regex",
- "reqwest",
- "semver",
- "serde",
- "serde_derive",
- "serde_json",
- "serde_plain",
- "serde_yaml",
- "slog",
- "slog-async",
- "slog-envlogger",
- "slog-term",
- "stable-hash 0.3.3",
- "stable-hash 0.4.2",
- "strum",
- "strum_macros",
- "test-store",
- "thiserror",
- "tiny-keccak 1.5.0",
- "tokio",
- "tokio-retry",
- "tokio-stream",
- "tonic",
- "tonic-build",
- "url",
- "wasmparser",
- "web3",
+ "tinyvec",
 ]
 
 [[package]]
-name = "graph-chain-arweave"
-version = "0.30.0"
+name = "bstr"
+version = "1.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05efc5cfd9110c8416e471df0e96702d58690178e206e61b7173706673c93706"
 dependencies = [
- "base64-url",
- "diesel",
- "graph",
- "graph-runtime-derive",
- "graph-runtime-wasm",
- "prost",
- "prost-types",
+ "memchr",
  "serde",
- "sha2 0.10.6",
- "tonic-build",
 ]
 
 [[package]]
-name = "graph-chain-common"
-version = "0.30.0"
+name = "bumpalo"
+version = "3.20.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
 dependencies = [
- "anyhow",
- "heck 0.4.1",
- "protobuf 3.2.0",
- "protobuf-parse",
+ "allocator-api2",
 ]
 
 [[package]]
-name = "graph-chain-cosmos"
-version = "0.30.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",
- "graph",
- "graph-chain-common",
- "graph-runtime-derive",
- "graph-runtime-wasm",
- "prost",
- "prost-types",
- "semver",
  "serde",
- "tonic-build",
 ]
 
 [[package]]
-name = "graph-chain-ethereum"
-version = "0.30.0"
+name = "c-kzg"
+version = "2.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e00bf4b112b07b505472dbefd19e37e53307e2bfed5a79e0cc161d58ccd0e687"
 dependencies = [
- "anyhow",
- "base64 0.20.0",
- "dirs-next",
- "envconfig",
- "futures 0.1.31",
- "graph",
- "graph-mock",
- "graph-runtime-derive",
- "graph-runtime-wasm",
+ "arbitrary",
+ "blst",
+ "cc",
+ "glob",
  "hex",
- "http",
- "itertools",
- "jsonrpc-core",
- "lazy_static",
- "prost",
- "prost-types",
- "semver",
+ "libc",
+ "once_cell",
  "serde",
- "test-store",
- "tiny-keccak 1.5.0",
- "tonic-build",
 ]
 
 [[package]]
-name = "graph-chain-near"
-version = "0.30.0"
+name = "cc"
+version = "1.2.60"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43c5703da9466b66a946814e1adf53ea2c90f10063b86290cc9eb67ce3478a20"
 dependencies = [
- "base64 0.20.0",
- "diesel",
- "graph",
- "graph-runtime-derive",
- "graph-runtime-wasm",
- "prost",
- "prost-types",
- "serde",
- "tonic-build",
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
 ]
 
 [[package]]
-name = "graph-chain-substreams"
-version = "0.30.0"
+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 = [
- "anyhow",
- "async-stream",
- "base64 0.20.0",
- "dirs-next",
- "envconfig",
- "futures 0.1.31",
- "graph",
- "graph-core",
- "graph-runtime-wasm",
- "hex",
- "http",
- "itertools",
- "jsonrpc-core",
- "lazy_static",
- "prost",
- "prost-types",
- "semver",
- "serde",
- "tiny-keccak 1.5.0",
- "tokio",
- "tonic-build",
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "rand_core 0.10.0",
 ]
 
 [[package]]
-name = "graph-core"
-version = "0.30.0"
+name = "chrono"
+version = "0.4.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1aa79e62e7697b8e29b513a68abacf485adcd1fe8284a4316c5ae868e6633327"
 dependencies = [
- "anyhow",
- "async-stream",
- "async-trait",
- "atomic_refcell",
- "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-substreams",
- "graph-mock",
- "graph-runtime-wasm",
- "graphql-parser",
- "hex",
- "ipfs-api",
- "ipfs-api-backend-hyper",
- "lazy_static",
- "lru_time_cache",
- "pretty_assertions",
- "semver",
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
  "serde",
- "serde_json",
- "serde_yaml",
- "test-store",
- "tower 0.4.12",
- "tower-test",
- "uuid",
+ "wasm-bindgen",
+ "windows-link 0.2.1",
 ]
 
 [[package]]
-name = "graph-graphql"
-version = "0.30.0"
+name = "cid"
+version = "0.11.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21a304f95f84d169a6f31c4d0a30d784643aaa0bbc9c1e449a2c23e963ec4971"
 dependencies = [
- "Inflector",
- "anyhow",
- "async-recursion",
- "crossbeam",
- "defer",
- "graph",
- "graph-chain-ethereum",
- "graphql-parser",
- "graphql-tools",
- "indexmap",
- "lazy_static",
- "parking_lot 0.12.1",
- "pretty_assertions",
- "stable-hash 0.3.3",
- "stable-hash 0.4.2",
- "test-store",
+ "multibase",
+ "multihash",
+ "unsigned-varint",
 ]
 
 [[package]]
-name = "graph-mock"
-version = "0.30.0"
+name = "clap"
+version = "4.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "84b3edb18336f4df585bc9aa31dd99c036dfa5dc5e9a2939a722a188f3a8970d"
 dependencies = [
- "graph",
+ "clap_builder",
+ "clap_derive",
 ]
 
 [[package]]
-name = "graph-node"
-version = "0.30.0"
+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",
- "crossbeam-channel",
- "diesel",
- "env_logger 0.9.3",
- "futures 0.3.16",
- "git-testament",
- "graph",
- "graph-chain-arweave",
- "graph-chain-cosmos",
- "graph-chain-ethereum",
- "graph-chain-near",
- "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",
- "lazy_static",
- "prometheus",
- "serde",
- "serde_regex",
- "shellexpand",
- "termcolor",
- "toml 0.7.1",
- "url",
 ]
 
 [[package]]
-name = "graph-runtime-derive"
-version = "0.30.0"
+name = "clap_derive"
+version = "4.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2bac35c6dafb060fd4d275d9a4ffae97917c13a6327903a8be2153cd964f7085"
 dependencies = [
- "heck 0.4.1",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "graph-runtime-test"
-version = "0.30.0"
+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 = [
- "graph",
- "graph-chain-ethereum",
- "graph-core",
- "graph-mock",
- "graph-runtime-derive",
- "graph-runtime-wasm",
- "rand",
- "semver",
- "test-store",
- "wasmtime",
+ "cc",
 ]
 
 [[package]]
-name = "graph-runtime-wasm"
-version = "0.30.0"
+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 = [
- "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",
+ "futures-core",
+ "memchr",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
 ]
 
 [[package]]
-name = "graph-server-http"
-version = "0.30.0"
+name = "concurrent-queue"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ca0197aee26d1ae37445ee532fefce43251d24cc7c166799f4d46817f1d3973"
 dependencies = [
- "futures 0.1.31",
- "graph",
- "graph-graphql",
- "graph-mock",
- "graphql-parser",
- "http",
- "hyper",
- "serde",
+ "crossbeam-utils",
 ]
 
 [[package]]
-name = "graph-server-index-node"
-version = "0.30.0"
+name = "console"
+version = "0.15.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "054ccb5b10f9f2cbf51eb355ca1d05c2d279ce1804688d0db74b4733a5aeafd8"
 dependencies = [
- "blake3 1.3.3",
- "either",
- "futures 0.3.16",
- "graph",
- "graph-chain-arweave",
- "graph-chain-cosmos",
- "graph-chain-ethereum",
- "graph-chain-near",
- "graph-graphql",
- "graphql-parser",
- "http",
- "hyper",
- "lazy_static",
- "serde",
+ "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.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-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",
+ "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",
+ "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 = "pin-project"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+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 = [
+ "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",
+]
+
+[[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",
+ "tokio-postgres",
+]
+
+[[package]]
+name = "postgres-openssl"
+version = "0.5.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06743eefaa1a5c0ef2ccb6d9abf6528790a229eabd62ddcabf9b2a3aeff09fa4"
+dependencies = [
+ "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",
+ "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",
+]
+
+[[package]]
+name = "proc-macro-crate"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d37c51ca738a55da99dc0c4a34860fd675453b8b36209178c2249bb13651284"
+dependencies = [
+ "toml_edit",
+]
+
+[[package]]
+name = "proc-macro-error-attr2"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96de42df36bb9bba5542fe9f1a054b8cc87e172759a1868aa05c1f3acc89dfc5"
+dependencies = [
+ "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",
+ "libc",
+ "memchr",
+ "parking_lot",
+ "protobuf",
+ "reqwest 0.12.23",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+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 = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
+
+[[package]]
+name = "proptest-derive"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c57924a81864dddafba92e1bf92f9bf82f97096c44489548a60e888e1547549b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "graph-server-json-rpc"
-version = "0.30.0"
+name = "prost"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "528ac67416ff8646872a3c02cad9cc4ee5dc9f9540c9b10771855c95cb2e5ae1"
 dependencies = [
- "graph",
- "jsonrpsee",
- "serde",
+ "bytes",
+ "prost-derive",
 ]
 
 [[package]]
-name = "graph-server-metrics"
-version = "0.30.0"
+name = "prost-build"
+version = "0.14.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "343d3bd7056eda839b03204e68deff7d1b13aba7af2b2fd16890697274262ee7"
 dependencies = [
- "graph",
- "hyper",
+ "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-websocket"
-version = "0.30.0"
+name = "prost-derive"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b570b25f7617e43d59005d0990ccb79e950a423952cea19671b7a876da390adf"
 dependencies = [
  "anyhow",
- "futures 0.1.31",
- "graph",
- "graphql-parser",
- "http",
- "lazy_static",
- "serde",
- "serde_derive",
- "tokio-tungstenite",
- "uuid",
+ "itertools 0.13.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "graph-store-postgres"
-version = "0.30.0"
+name = "prost-types"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f94967dc7688f3054c7fac87473ffae4cc4c3904800e2d9f5b857246d8963b0a"
 dependencies = [
- "Inflector",
- "anyhow",
- "async-trait",
- "blake3 1.3.3",
- "clap",
- "derive_more",
- "diesel",
- "diesel-derive-enum",
- "diesel-dynamic-schema",
- "diesel_derives",
- "diesel_migrations",
- "fallible-iterator",
- "futures 0.3.16",
- "git-testament",
- "graph",
- "graph-chain-ethereum",
- "graph-graphql",
- "graph-mock",
- "graphql-parser",
- "hex",
- "hex-literal",
- "itertools",
- "lazy_static",
- "lru_time_cache",
- "maybe-owned",
- "openssl",
- "pin-utils",
- "postgres",
- "postgres-openssl",
- "pretty_assertions",
- "rand",
- "serde",
- "stable-hash 0.3.3",
- "test-store",
- "uuid",
+ "prost",
 ]
 
 [[package]]
-name = "graph-tests"
-version = "0.30.0"
+name = "protobuf"
+version = "3.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d65a1d4ddae7d8b5de68153b48f6aa3bba8cb002b243dbdbc55a5afbc98f99f4"
 dependencies = [
- "anyhow",
- "assert-json-diff",
- "async-stream",
- "bollard",
- "cid",
- "futures 0.3.16",
- "graph",
- "graph-chain-ethereum",
- "graph-chain-near",
- "graph-core",
- "graph-graphql",
- "graph-mock",
- "graph-node",
- "graph-runtime-wasm",
- "graph-server-index-node",
- "graph-store-postgres",
- "graphql-parser",
- "hyper",
- "lazy_static",
- "serde",
- "serde_yaml",
- "slog",
- "tokio",
- "tokio-stream",
- "uuid",
+ "once_cell",
+ "protobuf-support",
+ "thiserror 1.0.61",
 ]
 
 [[package]]
-name = "graphql-parser"
-version = "0.4.0"
+name = "protobuf-parse"
+version = "3.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2ebc8013b4426d5b81a4364c419a95ed0b404af2b82e2457de52d9348f0e474"
+checksum = "b4aeaa1f2460f1d348eeaeed86aea999ce98c1bded6f089ff8514c9d9dbdc973"
 dependencies = [
- "combine",
- "thiserror",
+ "anyhow",
+ "indexmap 2.14.0",
+ "log",
+ "protobuf",
+ "protobuf-support",
+ "tempfile",
+ "thiserror 1.0.61",
+ "which",
 ]
 
 [[package]]
-name = "graphql-tools"
-version = "0.2.1"
+name = "protobuf-support"
+version = "3.7.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7bc3a979aca9d796ff03ff71f4013e203a1f69bf1f37899ae4a8e676bb236608"
+checksum = "3e36c2f31e0a47f9280fb347ef5e461ffcd2c52dd520d8e216b52f93b0b0d7d6"
 dependencies = [
- "graphql-parser",
- "lazy_static",
- "serde",
- "serde_json",
+ "thiserror 1.0.61",
 ]
 
 [[package]]
-name = "h2"
-version = "0.3.13"
+name = "psm"
+version = "0.1.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "37a82c6d637fc9515a4694bbf1cb2457b79d81ce52b3108bdeea58b07dd34a57"
+checksum = "5787f7cda34e3033a72192c018bc5883100330f362ef279a8cbccfce8bb4e874"
 dependencies = [
- "bytes",
- "fnv",
- "futures-core",
- "futures-sink",
- "futures-util",
- "http",
- "indexmap",
- "slab",
- "tokio",
- "tokio-util 0.7.1",
- "tracing",
+ "cc",
 ]
 
 [[package]]
-name = "hashbrown"
-version = "0.12.1"
+name = "pulldown-cmark"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db0d4cf898abf0081f964436dc980e96670a0f36863e4b83aaacdb65c9d7ccc3"
+checksum = "1e8bbe1a966bd2f362681a44f6edce3c2310ac21e4d5067a6e7ec396297a6ea0"
+dependencies = [
+ "bitflags 2.11.1",
+ "memchr",
+ "unicase",
+]
 
 [[package]]
-name = "hdrhistogram"
-version = "7.5.2"
+name = "pulldown-cmark-to-cmark"
+version = "22.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f19b9f54f7c7f55e31401bb647626ce0cf0f67b0004982ce815b3ee72a02aa8"
+checksum = "50793def1b900256624a709439404384204a5dc3a6ec580281bfaac35e882e90"
 dependencies = [
- "byteorder",
- "num-traits",
+ "pulldown-cmark",
 ]
 
 [[package]]
-name = "headers"
-version = "0.3.5"
+name = "pulley-interpreter"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4c4eb0471fcb85846d8b0690695ef354f9afb11cb03cac2e1d7c9253351afb0"
+checksum = "38b92604caae1a1899b6a5b54967289dd538177c626004c91accf9d0ec7e4a12"
 dependencies = [
- "base64 0.13.1",
- "bitflags",
- "bytes",
- "headers-core",
- "http",
- "httpdate",
- "mime",
- "sha-1 0.9.7",
+ "cranelift-bitset",
+ "log",
+ "pulley-macros",
+ "wasmtime-internal-core",
 ]
 
 [[package]]
-name = "headers-core"
-version = "0.2.0"
+name = "pulley-macros"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7f66481bfee273957b1f20485a4ff3362987f85b2c236580d81b4eb7a326429"
+checksum = "5a7ac85c0bb3fb351f10d531230aaa5e366b46d7c4e5328e5f02801d6dac1165"
 dependencies = [
- "http",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "heck"
-version = "0.3.3"
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
+[[package]]
+name = "quick-xml"
+version = "0.40.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d621efb26863f0e9924c6ac577e8275e5e6b77455db64ffa6c65c904e9e132c"
+checksum = "2474bd2e5029e7ccb6abb2ba48cf2383a333851dedf495901544281590c7da7f"
 dependencies = [
- "unicode-segmentation",
+ "memchr",
+ "serde",
 ]
 
 [[package]]
-name = "heck"
-version = "0.4.1"
+name = "quinn"
+version = "0.11.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+checksum = "b9e20a958963c291dc322d98411f541009df2ced7b5a4f2bd52337638cfccf20"
+dependencies = [
+ "bytes",
+ "cfg_aliases",
+ "pin-project-lite",
+ "quinn-proto",
+ "quinn-udp",
+ "rustc-hash",
+ "rustls",
+ "socket2",
+ "thiserror 2.0.18",
+ "tokio",
+ "tracing",
+ "web-time",
+]
 
 [[package]]
-name = "hermit-abi"
-version = "0.1.19"
+name = "quinn-proto"
+version = "0.11.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
+checksum = "434b42fec591c96ef50e21e886936e66d3cc3f737104fdb9b737c40ffb94c098"
 dependencies = [
- "libc",
+ "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 = "hermit-abi"
-version = "0.2.6"
+name = "quinn-udp"
+version = "0.5.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
+checksum = "addec6a0dcad8a8d96a771f815f0eaf55f9d1805756410b39f5fa81332574cbd"
 dependencies = [
+ "cfg_aliases",
  "libc",
+ "once_cell",
+ "socket2",
+ "tracing",
+ "windows-sys 0.60.2",
 ]
 
 [[package]]
-name = "hex"
-version = "0.4.3"
+name = "quote"
+version = "1.0.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
+dependencies = [
+ "proc-macro2",
+]
 
 [[package]]
-name = "hex-literal"
-version = "0.3.4"
+name = "r-efi"
+version = "6.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ebdb29d2ea9ed0083cd8cece49bbd968021bd99b0849edb4a9a7ee0fdf6a4e0"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
 
 [[package]]
-name = "hmac"
-version = "0.10.1"
+name = "r2d2"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1441c6b1e930e2817404b5046f1f989899143a12bf92de603b69f4e0aee1e15"
+checksum = "51de85fb3fb6524929c8a2eb85e6b6d363de4e8c48f9e2c2eac4944abc181c93"
 dependencies = [
- "crypto-mac 0.10.1",
- "digest 0.9.0",
+ "log",
+ "parking_lot",
+ "scheduled-thread-pool",
 ]
 
 [[package]]
-name = "http"
-version = "0.2.8"
+name = "radium"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "75f43d41e26995c17e71ee126451dd3941010b0514a81a9d11f3b341debc2399"
-dependencies = [
- "bytes",
- "fnv",
- "itoa 1.0.1",
-]
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
 [[package]]
-name = "http-body"
-version = "0.4.5"
+name = "rand"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
+checksum = "5ca0ecfa931c29007047d1bc58e623ab12e5590e8c7cc53200d5202b69266d8a"
 dependencies = [
- "bytes",
- "http",
- "pin-project-lite",
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+ "serde",
 ]
 
 [[package]]
-name = "http-range-header"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0bfe8eed0a9285ef776bb792479ea3834e8b94e13d615c2f66d03dd50a435a29"
-
-[[package]]
-name = "httparse"
-version = "1.7.1"
+name = "rand"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "496ce29bb5a52785b44e0f7ca2847ae0bb839c9bd28f69acac9b99d461c0c04c"
+checksum = "7ec095654a25171c2124e9e3393a930bddbffdc939556c914957a4c3e0a87166"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
+ "serde",
+]
 
 [[package]]
-name = "httpdate"
-version = "1.0.1"
+name = "rand"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6456b8a6c8f33fee7d958fcd1b60d55b11940a79e63ae87013e6d22e26034440"
+checksum = "d2e8e8bcc7961af1fdac401278c6a831614941f6164ee3bf4ce61b7edb162207"
+dependencies = [
+ "chacha20",
+ "getrandom 0.4.2",
+ "rand_core 0.10.0",
+]
 
 [[package]]
-name = "humantime"
-version = "1.3.0"
+name = "rand_chacha"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df004cfca50ef23c36850aaaa59ad52cc70d0e90243c3c7737a4dd32dc7a3c4f"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
 dependencies = [
- "quick-error",
+ "ppv-lite86",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
-name = "humantime"
-version = "2.1.0"
+name = "rand_chacha"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
+]
 
 [[package]]
-name = "hyper"
-version = "0.14.18"
+name = "rand_core"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b26ae0a80afebe130861d90abf98e3814a4f28a4c6ffeb5ab8ebb2be311e0ef2"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
 dependencies = [
- "bytes",
- "futures-channel",
- "futures-core",
- "futures-util",
- "h2",
- "http",
- "http-body",
- "httparse",
- "httpdate",
- "itoa 1.0.1",
- "pin-project-lite",
- "socket2",
- "tokio",
- "tower-service 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "tracing",
- "want",
+ "getrandom 0.2.15",
 ]
 
 [[package]]
-name = "hyper-multipart-rfc7578"
-version = "0.8.0"
+name = "rand_core"
+version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0eb2cf73e96e9925f4bed948e763aa2901c2f1a3a5f713ee41917433ced6671"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
 dependencies = [
- "bytes",
- "common-multipart-rfc7578",
- "futures-core",
- "http",
- "hyper",
+ "getrandom 0.3.1",
+ "serde",
 ]
 
 [[package]]
-name = "hyper-rustls"
-version = "0.23.0"
+name = "rand_core"
+version = "0.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0c8d0fd677905edcbeedbf2edb6494d676f0e98d54d5cf9bda0b061cb8fb8aba"
+
+[[package]]
+name = "rand_xorshift"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d87c48c02e0dc5e3b849a2041db3029fd066650f8f717c07bf8ed78ccb895cac"
+checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
 dependencies = [
- "http",
- "hyper",
- "log",
- "rustls",
- "rustls-native-certs",
- "tokio",
- "tokio-rustls",
+ "rand_core 0.9.3",
 ]
 
 [[package]]
-name = "hyper-timeout"
-version = "0.4.1"
+name = "rapidhash"
+version = "4.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1"
+checksum = "5d8b5b858a440a0bc02625b62dd95131b9201aa9f69f411195dd4a7cfb1de3d7"
 dependencies = [
- "hyper",
- "pin-project-lite",
- "tokio",
- "tokio-io-timeout",
+ "rustversion",
 ]
 
 [[package]]
-name = "hyper-tls"
-version = "0.5.0"
+name = "rayon"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
 dependencies = [
- "bytes",
- "hyper",
- "native-tls",
- "tokio",
- "tokio-native-tls",
+ "either",
+ "rayon-core",
 ]
 
 [[package]]
-name = "hyper-unix-connector"
-version = "0.2.2"
+name = "rayon-core"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "24ef1fd95d34b4ff007d3f0590727b5cf33572cace09b42032fc817dc8b16557"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
 dependencies = [
- "anyhow",
- "hex",
- "hyper",
- "pin-project",
- "tokio",
+ "crossbeam-deque",
+ "crossbeam-utils",
 ]
 
 [[package]]
-name = "iana-time-zone"
-version = "0.1.47"
+name = "recursive"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c495f162af0bf17656d0014a0eded5f3cd2f365fdd204548c2869db89359dc7"
+checksum = "0786a43debb760f491b1bc0269fe5e84155353c67482b9e60d0cfb596054b43e"
 dependencies = [
- "android_system_properties",
- "core-foundation-sys",
- "js-sys",
- "once_cell",
- "wasm-bindgen",
- "winapi",
+ "recursive-proc-macro-impl",
+ "stacker",
 ]
 
 [[package]]
-name = "ibig"
-version = "0.3.2"
+name = "recursive-proc-macro-impl"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c5022ee7f7a2feb0bd2fdc4b8ec882cd14903cebf33e7c1847e3f3a282f8b7"
+checksum = "76009fbe0614077fc1a2ce255e3a1881a2e3a3527097d5dc6d8212c585e7e38b"
 dependencies = [
- "cfg-if 1.0.0",
- "const_fn_assert",
- "num-traits",
- "rand",
- "static_assertions",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "ident_case"
-version = "1.0.1"
+name = "recvmsg"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+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.3.0"
+name = "redox_syscall"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
+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",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "indexmap"
-version = "1.9.2"
+name = "regalloc2"
+version = "0.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885e79c1fc4b10f0e172c475f458b7f7b93061064d98c3293e98c5ba0c8b399"
+checksum = "de2c52737737f8609e94f975dee22854a2d5c125772d4b1cf292120f4d45c186"
 dependencies = [
- "autocfg",
- "hashbrown",
+ "allocator-api2",
+ "bumpalo",
+ "hashbrown 0.17.0",
+ "log",
+ "rustc-hash",
  "serde",
+ "smallvec",
 ]
 
 [[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 = "ipfs-api"
-version = "0.17.0"
+name = "regex-automata"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d8cc57cf12ae4af611e53dd04053e1cfb815917c51c410aa30399bf377046ab"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 dependencies = [
- "ipfs-api-backend-hyper",
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
 ]
 
 [[package]]
-name = "ipfs-api-backend-hyper"
-version = "0.6.0"
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+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 = "isatty"
-version = "0.1.9"
+name = "ring"
+version = "0.17.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e31a8281fc93ec9693494da65fbf28c0c2aa60a2eaec25dc58e2f31952e95edc"
+checksum = "70ac5d832aa16abd7d1def883a8545280c20a60f523a370aa3a9617c2b8550ee"
 dependencies = [
- "cfg-if 0.1.10",
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.15",
  "libc",
- "redox_syscall 0.1.57",
- "winapi",
+ "untrusted",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "itertools"
-version = "0.10.5"
+name = "rlp"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+checksum = "bb919243f34364b6bd2fc10ef797edbfa75f33c252e7998527479c6d6b47e1ec"
 dependencies = [
- "either",
+ "bytes",
+ "rustc-hex",
 ]
 
 [[package]]
-name = "itoa"
-version = "0.4.7"
+name = "ruint"
+version = "1.17.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c141e807189ad38a07276942c6623032d3753c8859c146104ac2e4d68865945a"
+dependencies = [
+ "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 = "ruint-macro"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
+checksum = "48fd7bd8a6377e15ad9d42a8ec25371b94ddc67abe7c8b9127bec79bebaaae18"
 
 [[package]]
-name = "itoa"
-version = "1.0.1"
+name = "rustc-demangle"
+version = "0.1.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1aab8fc367588b89dcee83ab0fd66b72b50b72fa1904d7095045ace2b0c81c35"
+checksum = "719b953e2095829ee67db738b3bfa9fa368c94900df327b3f07fe6e794d2fe1f"
 
 [[package]]
-name = "jobserver"
-version = "0.1.23"
+name = "rustc-hash"
+version = "2.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5ca711fd837261e14ec9e674f092cbb931d3fa1482b017ae59328ddc6f3212b"
-dependencies = [
- "libc",
-]
+checksum = "357703d41365b4b27c590e3ed91eabb1b663f07c4c084095e60cbed4362dff0d"
 
 [[package]]
-name = "js-sys"
-version = "0.3.59"
+name = "rustc-hex"
+version = "2.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "258451ab10b34f8af53416d1fdab72c22e805f0c92a1136d59470ec0b11138b2"
-dependencies = [
- "wasm-bindgen",
-]
+checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6"
 
 [[package]]
-name = "json-structural-diff"
-version = "0.1.0"
+name = "rustc_version"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25c7940d3c84d2079306c176c7b2b37622b6bc5e43fbd1541b1e4a4e1fd02045"
+checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee"
 dependencies = [
- "console",
- "difflib",
- "regex",
- "serde_json",
+ "semver 0.11.0",
 ]
 
 [[package]]
-name = "jsonrpc-core"
-version = "18.0.0"
+name = "rustc_version"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14f7f76aef2d054868398427f6c54943cf3d1caa9a7ec7d0c38d69df97a965eb"
+checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
 dependencies = [
- "futures 0.3.16",
- "futures-executor",
- "futures-util",
- "log",
- "serde",
- "serde_derive",
- "serde_json",
+ "semver 1.0.28",
 ]
 
 [[package]]
-name = "jsonrpsee"
-version = "0.15.1"
+name = "rustix"
+version = "0.38.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bd0d559d5e679b1ab2f869b486a11182923863b1b3ee8b421763cdd707b783a"
+checksum = "70dc5ec042f7a43c4a73241207cecc9873a06d45debb38b329f8541d85c2730f"
 dependencies = [
- "jsonrpsee-core",
- "jsonrpsee-http-server",
- "jsonrpsee-types",
+ "bitflags 2.11.1",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.4.14",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "jsonrpsee-core"
-version = "0.15.1"
+name = "rustix"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3dc3e9cf2ba50b7b1d7d76a667619f82846caa39e8e8daa8a4962d74acaddca"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
 dependencies = [
- "anyhow",
- "arrayvec 0.7.2",
- "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",
+ "bitflags 2.11.1",
+ "errno",
+ "libc",
+ "linux-raw-sys 0.12.1",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "jsonrpsee-http-server"
-version = "0.15.1"
+name = "rustls"
+version = "0.23.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "03802f0373a38c2420c70b5144742d800b509e2937edc4afb116434f07120117"
+checksum = "6b92b125634d9b795e7beca796cc790df15a7fb38323bf3196fda83292d06b1f"
 dependencies = [
- "futures-channel",
- "futures-util",
- "hyper",
- "jsonrpsee-core",
- "jsonrpsee-types",
- "serde",
- "serde_json",
- "tokio",
- "tracing",
- "tracing-futures",
+ "aws-lc-rs",
+ "log",
+ "once_cell",
+ "rustls-pki-types",
+ "rustls-webpki",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "jsonrpsee-types"
-version = "0.15.1"
+name = "rustls-native-certs"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e290bba767401b646812f608c099b922d8142603c9e73a50fb192d3ac86f4a0d"
+checksum = "7fcff2dd52b58a8d98a70243663a0d234c4e2b79235637849d15913394a247d3"
 dependencies = [
- "anyhow",
- "beef",
- "serde",
- "serde_json",
- "thiserror",
- "tracing",
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework 3.7.0",
 ]
 
 [[package]]
-name = "keccak"
-version = "0.1.0"
+name = "rustls-pki-types"
+version = "1.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67c21572b4949434e4fc1e1978b99c5f77064153c59d998bf13ecd96fb5ecba7"
+checksum = "30a7197ae7eb376e574fe940d068c30fe0462554a3ddbe4eca7838e049c937a9"
+dependencies = [
+ "web-time",
+ "zeroize",
+]
 
 [[package]]
-name = "lazy_static"
-version = "1.4.0"
+name = "rustls-platform-verifier"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
+checksum = "1d99feebc72bae7ab76ba994bb5e121b8d83d910ca40b36e0921f53becc41784"
+dependencies = [
+ "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 = "leb128"
-version = "0.2.4"
+name = "rustls-platform-verifier-android"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3576a87f2ba00f6f106fdfcd16db1d698d648a26ad8e0573cad8537c3c362d2a"
+checksum = "f87165f0995f63a9fbeea62b64d10b4d9d8e78ec6d7d51fb2125fda7bb36788f"
 
 [[package]]
-name = "libc"
-version = "0.2.131"
+name = "rustls-webpki"
+version = "0.103.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04c3b4822ccebfa39c02fc03d1534441b22ead323fa0f48bb7ddd8e6ba076a40"
+checksum = "61c429a8649f110dddef65e2a5ad240f747e85f7758a6bccc7e5777bd33f756e"
+dependencies = [
+ "aws-lc-rs",
+ "ring",
+ "rustls-pki-types",
+ "untrusted",
+]
 
 [[package]]
-name = "linked-hash-map"
-version = "0.5.4"
+name = "rustversion"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fb9b38af92608140b86b693604b9ffcc5824240a484d1ecd4795bacb2fe88f3"
+checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
 
 [[package]]
-name = "lock_api"
-version = "0.4.6"
+name = "rusty-fork"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b"
+checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2"
 dependencies = [
- "scopeguard",
+ "fnv",
+ "quick-error",
+ "tempfile",
+ "wait-timeout",
 ]
 
 [[package]]
-name = "log"
-version = "0.4.17"
+name = "ryu"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
-dependencies = [
- "cfg-if 1.0.0",
-]
+checksum = "a50f4cf475b65d88e057964e0e9bb1f0aa9bbb2036dc65c64596b42932536984"
 
 [[package]]
-name = "lru_time_cache"
-version = "0.11.11"
+name = "same-file"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9106e1d747ffd48e6be5bb2d97fa706ed25b144fbee4d5c02eae110cd8d6badd"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
 
 [[package]]
-name = "mach"
-version = "0.3.2"
+name = "schannel"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa"
+checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
 dependencies = [
- "libc",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "maplit"
-version = "1.0.2"
+name = "scheduled-thread-pool"
+version = "0.2.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e2e65a1a2e43cfcb47a895c4c8b10d1f4a61097f9f254f183aee60cad9c651d"
+checksum = "3cbc66816425a074528352f5789333ecff06ca41b36b0b0efdfbb29edc391a19"
+dependencies = [
+ "parking_lot",
+]
 
 [[package]]
-name = "matches"
-version = "0.1.8"
+name = "schemars"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ffc5c5338469d4d3ea17d269fa8ea3512ad247247c30bd2df69e68309ed0a08"
+checksum = "4cd191f9397d57d581cddd31014772520aa448f65ef991055d7f61582c65165f"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
 
 [[package]]
-name = "matchit"
-version = "0.7.0"
+name = "schemars"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b87248edafb776e59e6ee64a79086f65890d3510f2c656c000bf2a7e8a0aea40"
+checksum = "a2b42f36aa1cd011945615b92222f6bf73c599a102a300334cd7f8dbeec726cc"
+dependencies = [
+ "dyn-clone",
+ "ref-cast",
+ "serde",
+ "serde_json",
+]
 
 [[package]]
-name = "maybe-owned"
-version = "0.3.4"
+name = "scopeguard"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4facc753ae494aeb6e3c22f839b158aebd4f9270f55cd3c79906c45476c47ab4"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
-name = "md-5"
-version = "0.9.1"
+name = "sec1"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b5a279bb9607f9f53c22d496eade00d138d1bdcccd07d74650387cf94942a15"
+checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
 dependencies = [
- "block-buffer 0.9.0",
- "digest 0.9.0",
- "opaque-debug",
+ "base16ct",
+ "der",
+ "generic-array",
+ "pkcs8",
+ "serdect",
+ "subtle",
+ "zeroize",
 ]
 
 [[package]]
-name = "memchr"
-version = "2.5.0"
+name = "secp256k1"
+version = "0.30.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "b50c5943d326858130af85e049f2661ba3c78b26589b8ab98e65e80ae44a1252"
+dependencies = [
+ "bitcoin_hashes",
+ "rand 0.8.6",
+ "secp256k1-sys 0.10.1",
+ "serde",
+]
 
 [[package]]
-name = "memoffset"
-version = "0.6.4"
+name = "secp256k1"
+version = "0.31.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"
+checksum = "2c3c81b43dc2d8877c216a3fccf76677ee1ebccd429566d3e67447290d0c42b2"
 dependencies = [
- "autocfg",
+ "bitcoin_hashes",
+ "rand 0.9.3",
+ "secp256k1-sys 0.11.0",
 ]
 
 [[package]]
-name = "migrations_internals"
-version = "1.4.1"
+name = "secp256k1-sys"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b4fc84e4af020b837029e017966f86a1c2d5e83e64b589963d5047525995860"
+checksum = "d4387882333d3aa8cb20530a17c69a3752e97837832f34f6dccc760e715001d9"
 dependencies = [
- "diesel",
+ "cc",
 ]
 
 [[package]]
-name = "migrations_macros"
-version = "1.4.2"
+name = "secp256k1-sys"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9753f12909fd8d923f75ae5c3258cae1ed3c8ec052e1b38c93c21a6d157f789c"
+checksum = "dcb913707158fadaf0d8702c2db0e857de66eb003ccfdda5924b5f5ac98efb38"
 dependencies = [
- "migrations_internals",
- "proc-macro2",
- "quote",
- "syn",
+ "cc",
 ]
 
 [[package]]
-name = "mime"
-version = "0.3.16"
+name = "security-framework"
+version = "2.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a60c7ce501c71e03a9c9c0d35b861413ae925bd979cc7a4e30d060069aaac8d"
+checksum = "c627723fd09706bacdb5cf41499e95098555af3c3c29d014dc3c458ef6be11c0"
+dependencies = [
+ "bitflags 2.11.1",
+ "core-foundation 0.9.4",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
 
 [[package]]
-name = "mime_guess"
-version = "2.0.3"
+name = "security-framework"
+version = "3.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2684d4c2e97d99848d30b324b00c8fcc7e5c897b7cbb5819b09e7c90e8baf212"
+checksum = "b7f4bc775c73d9a02cde8bf7b2ec4c9d12743edf609006c7facc23998404cd1d"
 dependencies = [
- "mime",
- "unicase",
+ "bitflags 2.11.1",
+ "core-foundation 0.10.0",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
 ]
 
 [[package]]
-name = "miniz_oxide"
-version = "0.4.4"
+name = "security-framework-sys"
+version = "2.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
+checksum = "6ce2691df843ecc5d231c0b14ece2acc3efb62c0a398c7e1d875f3983ce020e3"
 dependencies = [
- "adler",
- "autocfg",
+ "core-foundation-sys",
+ "libc",
 ]
 
 [[package]]
-name = "miniz_oxide"
-version = "0.6.2"
+name = "semver"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa"
+checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
 dependencies = [
- "adler",
+ "semver-parser",
 ]
 
 [[package]]
-name = "mio"
-version = "0.7.13"
+name = "semver"
+version = "1.0.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c2bdb6314ec10835cd3293dd268473a835c02b7b352e788be788b3c6ca6bb16"
+checksum = "8a7852d02fc848982e0c167ef163aaff9cd91dc640ba85e263cb1ce46fae51cd"
 dependencies = [
- "libc",
- "log",
- "miow",
- "ntapi",
- "winapi",
+ "serde",
+ "serde_core",
 ]
 
 [[package]]
-name = "miow"
-version = "0.3.7"
+name = "semver-parser"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9f1c5b025cda876f66ef43a113f91ebc9f4ccef34843000e0adf6ebbab84e21"
+checksum = "9900206b54a3527fdc7b8a938bffd94a568bac4f4aa8113b209df75a09c0dec2"
 dependencies = [
- "winapi",
+ "pest",
 ]
 
 [[package]]
-name = "more-asserts"
-version = "0.2.1"
+name = "send_wrapper"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0debeb9fcf88823ea64d64e4a815ab1643f33127d995978e099942ce38f25238"
+checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
 
 [[package]]
-name = "multiaddr"
-version = "0.17.0"
+name = "seq-macro"
+version = "0.3.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b53e0cc5907a5c216ba6584bf74be8ab47d6d6289f72793b2dddbf15dc3bf8c"
-dependencies = [
- "arrayref",
- "byteorder",
- "data-encoding",
- "multibase",
- "multihash 0.17.0",
- "percent-encoding",
- "serde",
- "static_assertions",
- "unsigned-varint",
- "url",
-]
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
 
 [[package]]
-name = "multibase"
-version = "0.9.1"
+name = "serde"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b3539ec3c1f04ac9748a260728e855f261b4977f5c3406612c884564f329404"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
 dependencies = [
- "base-x",
- "data-encoding",
- "data-encoding-macro",
+ "serde_core",
+ "serde_derive",
 ]
 
 [[package]]
-name = "multihash"
-version = "0.17.0"
+name = "serde_core"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "835d6ff01d610179fbce3de1694d007e500bf33a7f29689838941d6bf783ae40"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 dependencies = [
- "core2",
- "multihash-derive",
- "unsigned-varint",
+ "serde_derive",
 ]
 
 [[package]]
-name = "multihash"
-version = "0.18.0"
+name = "serde_derive"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15e5d911412e631e1de11eb313e4dd71f73fd964401102aab23d6c8327c431ba"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
- "blake2b_simd",
- "blake2s_simd",
- "blake3 1.3.3",
- "core2",
- "digest 0.10.5",
- "multihash-derive",
- "sha2 0.10.6",
- "sha3",
- "unsigned-varint",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "multihash-derive"
-version = "0.8.0"
+name = "serde_json"
+version = "1.0.150"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc076939022111618a5026d3be019fd8b366e76314538ff9a1b59ffbcbf98bcd"
+checksum = "e8014e44b4736ed0538adeecded0fce2a272f22dc9578a7eb6b2d9993c74cfb9"
 dependencies = [
- "proc-macro-crate",
- "proc-macro-error",
- "proc-macro2",
- "quote",
- "syn",
- "synstructure",
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
 ]
 
 [[package]]
-name = "multimap"
-version = "0.8.3"
+name = "serde_path_to_error"
+version = "0.1.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ce46fe64a9d73be07dcbe690a38ce1b293be448fd8ce1e6c1b8062c9f72c6a"
+checksum = "af99884400da37c88f5e9146b7f1fd0fbcae8f6eec4e9da38b67d05486f814a6"
+dependencies = [
+ "itoa",
+ "serde",
+]
 
 [[package]]
-name = "native-tls"
-version = "0.2.8"
+name = "serde_plain"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48ba9f7719b5a0f42f338907614285fb5fd70e53858141f69898a1fb7203b24d"
+checksum = "9ce1fc6db65a611022b23a0dec6975d63fb80a302cb3388835ff02c097258d50"
 dependencies = [
- "lazy_static",
- "libc",
- "log",
- "openssl",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "security-framework",
- "security-framework-sys",
- "tempfile",
+ "serde",
 ]
 
 [[package]]
-name = "never"
-version = "0.1.0"
+name = "serde_regex"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c96aba5aa877601bb3f6dd6a63a969e1f82e60646e81e71b14496995e9853c91"
+checksum = "bafc8d0c5330cecff10f16b459b479fd9acaa5b4acd7167301414e21b0057012"
+dependencies = [
+ "regex",
+ "serde",
+]
 
 [[package]]
-name = "no-std-compat"
-version = "0.4.1"
+name = "serde_spanned"
+version = "1.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b93853da6d84c2e3c7d730d6473e8817692dd89be387eb01b94d7f108ecb5b8c"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
-name = "nom8"
-version = "0.2.0"
+name = "serde_urlencoded"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae01545c9c7fc4486ab7debaf2aad7003ac19431791868fb2e8066df97fad2f8"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
 dependencies = [
- "memchr",
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
 ]
 
 [[package]]
-name = "ntapi"
-version = "0.3.6"
+name = "serde_with"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f6bb902e437b6d86e03cce10a7e2af662292c5dfef23b65899ea3ac9354ad44"
+checksum = "76a5c54c7310e7b8b9577c286d7e399ddd876c3e12b3ed917a8aabc4b96e9e8c"
 dependencies = [
- "winapi",
+ "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 = "num-bigint"
-version = "0.2.6"
+name = "serde_with_macros"
+version = "3.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "090c7f9998ee0ff65aa5b723e4009f7b217707f1fb5ea551329cc4d6231fb304"
+checksum = "84d57bc0c8b9a17920c178daa6bb924850d54a9c97ab45194bb8c17ad66bb660"
 dependencies = [
- "autocfg",
- "num-integer",
- "num-traits",
- "serde",
+ "darling 0.23.0",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "num-integer"
-version = "0.1.44"
+name = "serde_yaml"
+version = "0.9.34+deprecated"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2cc698a63b549a70bc047073d2949cce27cd1c7b0a4a862d08a8031bc2801db"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
 dependencies = [
- "autocfg",
- "num-traits",
+ "indexmap 2.14.0",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
 ]
 
 [[package]]
-name = "num-traits"
-version = "0.2.15"
+name = "serdect"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "a84f14a19e9a014bb9f4512488d9829a68e04ecabffb0f9904cd1ace94598177"
 dependencies = [
- "autocfg",
+ "base16ct",
+ "serde",
 ]
 
 [[package]]
-name = "num_cpus"
-version = "1.15.0"
+name = "sha1"
+version = "0.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
 dependencies = [
- "hermit-abi 0.2.6",
- "libc",
+ "cfg-if",
+ "cpufeatures 0.2.12",
+ "digest 0.10.7",
 ]
 
 [[package]]
-name = "object"
-version = "0.24.0"
+name = "sha1"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a5b3dd1c072ee7963717671d1ca129f1048fda25edea6b752bfc71ac8854170"
+checksum = "aacc4cc499359472b4abe1bf11d0b12e688af9a805fa5e3016f9a386dc2d0214"
 dependencies = [
- "crc32fast",
- "indexmap",
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "digest 0.11.2",
 ]
 
 [[package]]
-name = "object"
-version = "0.26.0"
+name = "sha1_smol"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbfa15b3dddfee50a0fff136974b3e1bde555604ba463834a7eb7deb6417705d"
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c55827317fb4c08822499848a14237d2874d6f139828893017237e7ab93eb386"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
 dependencies = [
- "memchr",
+ "cfg-if",
+ "cpufeatures 0.2.12",
+ "digest 0.10.7",
 ]
 
 [[package]]
-name = "once_cell"
-version = "1.13.1"
+name = "sha2"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "074864da206b4973b84eb91683020dbefd6a8c3f0f38e054d93954e891935e4e"
+checksum = "446ba717509524cb3f22f17ecc096f10f4822d76ab5c0b9822c5f9c284e825f4"
+dependencies = [
+ "cfg-if",
+ "cpufeatures 0.3.0",
+ "digest 0.11.2",
+]
 
 [[package]]
-name = "opaque-debug"
-version = "0.3.0"
+name = "sha3"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "624a8340c38c1b80fd549087862da4ba43e08858af025b236e509b6649fc13d5"
+checksum = "be176f1a57ce4e3d31c1a166222d9768de5954f811601fb7ca06fc8203905ce1"
+dependencies = [
+ "digest 0.11.2",
+ "keccak",
+]
 
 [[package]]
-name = "openssl"
-version = "0.10.45"
+name = "sha3-asm"
+version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b102428fd03bc5edf97f62620f7298614c45cedf287c271e7ed450bbaf83f2e1"
+checksum = "9f3f15d4e239ebe08413eed880e0f9b5af4b40ee0472543320efa91d488e96a7"
 dependencies = [
- "bitflags",
- "cfg-if 1.0.0",
- "foreign-types",
- "libc",
- "once_cell",
- "openssl-macros",
- "openssl-sys",
+ "cc",
+ "cfg-if",
 ]
 
 [[package]]
-name = "openssl-macros"
-version = "0.1.0"
+name = "shellexpand"
+version = "3.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b501e44f11665960c7e7fcf062c7d96a14ade4aa98116c004b2e37b5be7d736c"
+checksum = "32824fab5e16e6c4d86dc1ba84489390419a39f97699852b66480bb87d297ed8"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "dirs",
 ]
 
 [[package]]
-name = "openssl-probe"
-version = "0.1.4"
+name = "shlex"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28988d872ab76095a6e6ac88d99b54fd267702734fd7ffe610ca27f533ddb95a"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
-name = "openssl-sys"
-version = "0.9.80"
+name = "signal-hook"
+version = "0.3.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23bbbf7854cd45b83958ebe919f0e8e516793727652e27fda10a8384cfc790b7"
+checksum = "d881a16cf4426aa584979d30bd82cb33429027e42122b169753d6ef1085ed6e2"
 dependencies = [
- "autocfg",
- "cc",
  "libc",
- "pkg-config",
- "vcpkg",
+ "signal-hook-registry",
 ]
 
 [[package]]
-name = "os_str_bytes"
-version = "6.0.0"
+name = "signal-hook-mio"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e22443d1643a904602595ba1cd8f7d896afe56d26712531c5ff73a15b2fbf64"
+checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
+dependencies = [
+ "libc",
+ "mio",
+ "signal-hook",
+]
 
 [[package]]
-name = "output_vt100"
-version = "0.1.2"
+name = "signal-hook-registry"
+version = "1.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53cdc5b785b7a58c5aad8216b3dfa114df64b0b06ae6e1501cef91df2fbdf8f9"
+checksum = "a9e9e0b4211b72e7b8b6e85c807d36c212bdb33ea8587f7569562a84df5465b1"
 dependencies = [
- "winapi",
+ "libc",
 ]
 
 [[package]]
-name = "parity-scale-codec"
-version = "3.0.0"
+name = "signature"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a7f3fcf5e45fc28b84dcdab6b983e77f197ec01f325a33f404ba6855afd1070"
+checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de"
 dependencies = [
- "arrayvec 0.7.2",
- "bitvec",
- "byte-slice-cast",
- "impl-trait-for-tuples",
- "parity-scale-codec-derive",
- "serde",
+ "digest 0.10.7",
+ "rand_core 0.6.4",
 ]
 
 [[package]]
-name = "parity-scale-codec-derive"
-version = "3.0.0"
+name = "simd-adler32"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6e626dc84025ff56bf1476ed0e30d10c84d7f89a475ef46ebabee1095a8fba"
-dependencies = [
- "proc-macro-crate",
- "proc-macro2",
- "quote",
- "syn",
-]
+checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
 
 [[package]]
-name = "parity-wasm"
-version = "0.45.0"
+name = "simdutf8"
+version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1ad0aff30c1da14b1254fcb2af73e1fa9a28670e584a626f53a369d0e157304"
+checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
 [[package]]
-name = "parking_lot"
-version = "0.11.2"
+name = "similar"
+version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99"
+checksum = "e6505efef05804732ed8a3f2d4f279429eb485bd69d5b0cc6b19cc02005cda16"
 dependencies = [
- "instant",
- "lock_api",
- "parking_lot_core 0.8.5",
+ "bstr",
 ]
 
 [[package]]
-name = "parking_lot"
-version = "0.12.1"
+name = "siphasher"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
-dependencies = [
- "lock_api",
- "parking_lot_core 0.9.1",
-]
+checksum = "56199f7ddabf13fe5074ce809e7d3f42b42ae711800501b5b16ea82ad029c39d"
 
 [[package]]
-name = "parking_lot_core"
-version = "0.8.5"
+name = "slab"
+version = "0.4.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216"
+checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
 dependencies = [
- "cfg-if 1.0.0",
- "instant",
- "libc",
- "redox_syscall 0.2.10",
- "smallvec",
- "winapi",
+ "autocfg",
 ]
 
 [[package]]
-name = "parking_lot_core"
-version = "0.9.1"
+name = "slog"
+version = "2.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28141e0cc4143da2443301914478dc976a61ffdb3f043058310c70df2fed8954"
+checksum = "9b3b8565691b22d2bdfc066426ed48f837fc0c5f2c8cad8d9718f7f99d6995c1"
 dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "redox_syscall 0.2.10",
- "smallvec",
- "windows-sys",
+ "anyhow",
+ "erased-serde",
+ "rustversion",
+ "serde_core",
 ]
 
 [[package]]
-name = "paste"
-version = "1.0.5"
+name = "slog-async"
+version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acbf547ad0c65e31259204bd90935776d1c693cec2f4ff7abb7a1bbbd40dfe58"
+checksum = "72c8038f898a2c79507940990f05386455b3a317d8f18d4caea7cbc3d5096b84"
+dependencies = [
+ "crossbeam-channel",
+ "slog",
+ "take_mut",
+ "thread_local",
+]
 
 [[package]]
-name = "percent-encoding"
+name = "slog-envlogger"
 version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
+checksum = "906a1a0bc43fed692df4b82a5e2fbfc3733db8dad8bb514ab27a4f23ad04f5c0"
+dependencies = [
+ "log",
+ "regex",
+ "slog",
+ "slog-async",
+ "slog-scope",
+ "slog-stdlog",
+ "slog-term",
+]
 
 [[package]]
-name = "petgraph"
-version = "0.6.3"
+name = "slog-scope"
+version = "4.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dd7d28ee937e54fe3080c91faa1c3a46c06de6252988a7f4592ba2310ef22a4"
+checksum = "2f95a4b4c3274cd2869549da82b57ccc930859bdbf5bcea0424bc5f140b3c786"
 dependencies = [
- "fixedbitset",
- "indexmap",
+ "arc-swap",
+ "lazy_static",
+ "slog",
 ]
 
 [[package]]
-name = "phf"
-version = "0.8.0"
+name = "slog-stdlog"
+version = "4.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12"
+checksum = "6706b2ace5bbae7291d3f8d2473e2bfab073ccd7d03670946197aec98471fa3e"
 dependencies = [
- "phf_shared",
+ "log",
+ "slog",
+ "slog-scope",
 ]
 
 [[package]]
-name = "phf_shared"
-version = "0.8.0"
+name = "slog-term"
+version = "2.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7"
+checksum = "b6e022d0b998abfe5c3782c1f03551a596269450ccd677ea51c56f8b214610e8"
 dependencies = [
- "siphasher",
+ "is-terminal",
+ "slog",
+ "term",
+ "thread_local",
+ "time",
 ]
 
 [[package]]
-name = "pin-project"
-version = "1.0.12"
+name = "smallvec"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad29a609b6bcd67fee905812e544992d216af9d755757c05ed2d0e15a74c6ecc"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 dependencies = [
- "pin-project-internal",
+ "arbitrary",
+ "serde",
 ]
 
 [[package]]
-name = "pin-project-internal"
-version = "1.0.12"
+name = "snap"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b6b67fb9a61334225b5b790716f609cd58395f895b3fe8b328786812a40bc3b"
+
+[[package]]
+name = "socket2"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "069bdb1e05adc7a8990dce9cc75370895fbe4e3d58b9b73bf1aee56359344a55"
+checksum = "233504af464074f9d066d7b5416c5f9b894a5862a6506e306f7b816cdd6f1807"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "libc",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
-name = "pin-project-lite"
-version = "0.2.9"
+name = "spin"
+version = "0.9.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
 
 [[package]]
-name = "pin-utils"
-version = "0.1.0"
+name = "spki"
+version = "0.7.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d"
+dependencies = [
+ "base64ct",
+ "der",
+]
 
 [[package]]
-name = "pkg-config"
-version = "0.3.19"
+name = "sqlparser"
+version = "0.57.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3831453b3449ceb48b6d9c7ad7c96d5ea673e9b470a1dc578c2ce6521230884c"
+checksum = "07c5f081b292a3d19637f0b32a79e28ff14a9fd23ef47bd7fce08ff5de221eca"
+dependencies = [
+ "log",
+ "recursive",
+ "sqlparser_derive 0.3.0",
+]
 
 [[package]]
-name = "postgres"
-version = "0.19.1"
+name = "sqlparser"
+version = "0.62.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7871ee579860d8183f542e387b176a25f2656b9fb5211e045397f745a68d1c2"
+checksum = "13c6d1b651dc4edf07eead2a0c6c78016ce971bc2c10da5266861b13f25e7cec"
 dependencies = [
- "bytes",
- "fallible-iterator",
- "futures 0.3.16",
  "log",
- "tokio",
- "tokio-postgres",
+ "recursive",
+ "sqlparser_derive 0.5.0",
 ]
 
 [[package]]
-name = "postgres-openssl"
-version = "0.5.0"
+name = "sqlparser_derive"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1de0ea6504e07ca78355a6fb88ad0f36cafe9e696cbc6717f16a207f3a60be72"
+checksum = "da5fc6819faabb412da764b99d3b713bb55083c11e7e0c00144d386cd6a1939c"
 dependencies = [
- "futures 0.3.16",
- "openssl",
- "tokio",
- "tokio-openssl",
- "tokio-postgres",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "postgres-protocol"
-version = "0.6.1"
+name = "sqlparser_derive"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff3e0f70d32e20923cabf2df02913be7c1842d4c772db8065c00fcfdd1d1bff3"
+checksum = "a6dd45d8fc1c79299bfbb7190e42ccbbdf6a5f52e4a6ad98d92357ea965bd289"
 dependencies = [
- "base64 0.13.1",
- "byteorder",
- "bytes",
- "fallible-iterator",
- "hmac",
- "md-5",
- "memchr",
- "rand",
- "sha2 0.9.5",
- "stringprep",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "postgres-types"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "430f4131e1b7657b0cd9a2b0c3408d77c9a43a042d300b8c77f981dffcc43a2f"
+name = "stable-hash"
+version = "0.3.4"
+source = "git+https://github.com/graphprotocol/stable-hash?rev=42b85d936c6b9f1b7a4b8385d2f081d5564daa69#42b85d936c6b9f1b7a4b8385d2f081d5564daa69"
 dependencies = [
- "bytes",
- "fallible-iterator",
- "postgres-protocol",
+ "blake3",
+ "firestorm 0.4.6",
+ "ibig",
+ "lazy_static",
+ "leb128",
+ "num-traits",
 ]
 
 [[package]]
-name = "ppv-lite86"
-version = "0.2.10"
+name = "stable-hash"
+version = "0.4.4"
+source = "git+https://github.com/graphprotocol/stable-hash?rev=70300f974e61529675aef3f20803f26a23f0e0ea#70300f974e61529675aef3f20803f26a23f0e0ea"
+dependencies = [
+ "blake3",
+ "firestorm 0.5.1",
+ "ibig",
+ "lazy_static",
+ "leb128",
+ "num-traits",
+ "uint 0.10.1",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 
 [[package]]
-name = "pq-sys"
-version = "0.4.6"
+name = "stacker"
+version = "0.1.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ac25eee5a0582f45a67e837e350d784e7003bd29a5f460796772061ca49ffda"
+checksum = "e1f8b29fb42aafcea4edeeb6b2f2d7ecd0d969c48b4cf0d2e64aafc471dd6e59"
 dependencies = [
- "vcpkg",
+ "cc",
+ "cfg-if",
+ "libc",
+ "psm",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
-name = "pretty_assertions"
-version = "1.3.0"
+name = "static_assertions"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a25e9bcb20aa780fd0bb16b72403a9064d6b3f22f026946029acb941a50af755"
-dependencies = [
- "ctor",
- "diff",
- "output_vt100",
- "yansi",
-]
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
-name = "prettyplease"
-version = "0.1.10"
+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 = "d9e07e3a46d0771a8a06b5f4441527802830b43e679ba12f44960f48dd4c6803"
+checksum = "7b4df3d392d81bd458a8a621b8bffbd2302a12ffe288a9d931670948749463b1"
 dependencies = [
- "proc-macro2",
- "syn",
+ "unicode-bidi",
+ "unicode-normalization",
+ "unicode-properties",
 ]
 
 [[package]]
-name = "primitive-types"
+name = "strsim"
 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",
-]
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
 
 [[package]]
-name = "priority-queue"
-version = "0.7.0"
+name = "strum"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a03dfae8e64d4aa651415e2a4321f9f09f2e388a2f8bec36bed03bc22c0b687"
+checksum = "af23d6f6c1a224baef9d3f61e287d2761385a5b88fdab4eb4c6f11aeb54c4bcf"
 dependencies = [
- "indexmap",
- "take_mut",
+ "strum_macros 0.27.2",
 ]
 
 [[package]]
-name = "proc-macro-crate"
-version = "1.1.0"
+name = "strum"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ebace6889caf889b4d3f76becee12e90353f2b8c7d875534a71e5742f8f6f83"
+checksum = "9628de9b8791db39ceda2b119bbe13134770b56c138ec1d3af810d045c04f9bd"
 dependencies = [
- "thiserror",
- "toml 0.5.11",
+ "strum_macros 0.28.0",
 ]
 
 [[package]]
-name = "proc-macro-error"
-version = "1.0.4"
+name = "strum_macros"
+version = "0.27.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
+checksum = "7695ce3845ea4b33927c055a39dc438a45b059f7c1b3d91d38d10355fb8cbca7"
 dependencies = [
- "proc-macro-error-attr",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
- "syn",
- "version_check",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "proc-macro-error-attr"
-version = "1.0.4"
+name = "strum_macros"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
+checksum = "ab85eea0270ee17587ed4156089e10b9e6880ee688791d45a905f5b1ca36f664"
 dependencies = [
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
- "version_check",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "proc-macro-hack"
-version = "0.5.19"
+name = "subtle"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
 [[package]]
-name = "proc-macro-nested"
-version = "0.1.7"
+name = "syn"
+version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc881b2c22681370c6a780e47af9840ef841837bc98118431d4e1868bd0c1086"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
 
 [[package]]
-name = "proc-macro2"
-version = "1.0.51"
+name = "syn"
+version = "2.0.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d727cae5b39d21da60fa540906919ad737832fe0b1c165da3a34d6548c849d6"
+checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
 dependencies = [
+ "proc-macro2",
+ "quote",
  "unicode-ident",
 ]
 
 [[package]]
-name = "prometheus"
-version = "0.13.3"
+name = "syn-solidity"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "449811d15fbdf5ceb5c1144416066429cf82316e2ec8ce0c1f6f8a02e7bbcf8c"
+checksum = "ec005042c7d952febc1a3ef5b0f6674e9054aa836877a31c90b20e25b3d31744"
 dependencies = [
- "cfg-if 1.0.0",
- "fnv",
- "lazy_static",
- "libc",
- "memchr",
- "parking_lot 0.12.1",
- "protobuf 2.25.0",
- "reqwest",
- "thiserror",
+ "paste",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "prost"
-version = "0.11.6"
+name = "sync_wrapper"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "21dc42e00223fc37204bd4aa177e69420c604ca4a183209a8f9de30c6d934698"
+checksum = "0bf256ce5efdfa370213c1dabab5935a12e49f2c58d15e9eac2870d3b4f27263"
 dependencies = [
- "bytes",
- "prost-derive",
+ "futures-core",
 ]
 
 [[package]]
-name = "prost-build"
-version = "0.11.5"
+name = "synstructure"
+version = "0.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb5320c680de74ba083512704acb90fe00f28f79207286a848e730c45dd73ed6"
+checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
 dependencies = [
- "bytes",
- "heck 0.4.1",
- "itertools",
- "lazy_static",
- "log",
- "multimap",
- "petgraph",
- "prettyplease",
- "prost",
- "prost-types",
- "regex",
- "syn",
- "tempfile",
- "which",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "prost-derive"
-version = "0.11.6"
+name = "system-configuration"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bda8c0881ea9f722eb9629376db3d0b903b462477c1aafcb0566610ac28ac5d"
+checksum = "a13f3d0daba03132c0aa9767f98351b3488edc2c100cda2d2ec2b04f3d8d3c8b"
 dependencies = [
- "anyhow",
- "itertools",
- "proc-macro2",
- "quote",
- "syn",
+ "bitflags 2.11.1",
+ "core-foundation 0.9.4",
+ "system-configuration-sys",
 ]
 
 [[package]]
-name = "prost-types"
-version = "0.11.6"
+name = "system-configuration-sys"
+version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e0526209433e96d83d750dd81a99118edbc55739e7e61a46764fd2ad537788"
+checksum = "8e1d1b10ced5ca923a1fcb8d03e96b8d3268065d724548c0211415ff6ac6bac4"
 dependencies = [
- "bytes",
- "prost",
+ "core-foundation-sys",
+ "libc",
 ]
 
 [[package]]
-name = "protobuf"
-version = "2.25.0"
+name = "take_mut"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "020f86b07722c5c4291f7c723eac4676b3892d47d9a7708dc2779696407f039b"
+checksum = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60"
 
 [[package]]
-name = "protobuf"
-version = "3.2.0"
+name = "tap"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b55bad9126f378a853655831eb7363b7b01b81d19f8cb1218861086ca4a1a61e"
-dependencies = [
- "once_cell",
- "protobuf-support",
- "thiserror",
-]
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
-name = "protobuf-parse"
-version = "3.2.0"
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "tempfile"
+version = "3.27.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d39b14605eaa1f6a340aec7f320b34064feb26c93aec35d6a9a2272a8ddfa49"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
 dependencies = [
- "anyhow",
- "indexmap",
- "log",
- "protobuf 3.2.0",
- "protobuf-support",
- "tempfile",
- "thiserror",
- "which",
+ "fastrand",
+ "getrandom 0.4.2",
+ "once_cell",
+ "rustix 1.1.4",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "protobuf-support"
-version = "3.2.0"
+name = "term"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5d4d7b8601c814cfb36bcebb79f0e61e45e1e93640cf778837833bbed05c372"
+checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
 dependencies = [
- "thiserror",
+ "dirs-next",
+ "rustversion",
+ "winapi",
 ]
 
 [[package]]
-name = "psm"
-version = "0.1.14"
+name = "termcolor"
+version = "1.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "14ce37fa8c0428a37307d163292add09b3aedc003472e6b3622486878404191d"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
 dependencies = [
- "cc",
+ "winapi-util",
 ]
 
 [[package]]
-name = "quick-error"
-version = "1.2.3"
+name = "terminal_size"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+checksum = "21bebf2b7c9e0a515f6e0f8c51dc0f8e4696391e6f1ff30379559f8365fb0df7"
+dependencies = [
+ "rustix 0.38.34",
+ "windows-sys 0.48.0",
+]
 
 [[package]]
-name = "quote"
-version = "1.0.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8856d8364d252a14d474036ea1358d63c9e6965c8e5c1885c18f73d70bff9c7b"
+name = "test-store"
+version = "0.45.0"
 dependencies = [
- "proc-macro2",
+ "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",
+ "tokio",
 ]
 
 [[package]]
-name = "r2d2"
-version = "0.8.9"
+name = "thiserror"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "545c5bc2b880973c9c10e4067418407a0ccaa3091781d1671d46eb35107cb26f"
+checksum = "c546c80d6be4bc6a00c0f01730c08df82eaa7a7a61f11d656526506112cc1709"
 dependencies = [
- "log",
- "parking_lot 0.11.2",
- "scheduled-thread-pool",
+ "thiserror-impl 1.0.61",
 ]
 
 [[package]]
-name = "radium"
-version = "0.7.0"
+name = "thiserror"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
+dependencies = [
+ "thiserror-impl 2.0.18",
+]
 
 [[package]]
-name = "rand"
-version = "0.8.5"
+name = "thiserror-impl"
+version = "1.0.61"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+checksum = "46c3384250002a6d5af4d114f2845d37b57521033f30d5c3f46c4d70e1197533"
 dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "rand_chacha"
-version = "0.3.1"
+name = "thiserror-impl"
+version = "2.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
 dependencies = [
- "ppv-lite86",
- "rand_core",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "rand_core"
-version = "0.6.3"
+name = "thread_local"
+version = "1.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d34f1408f55294453790c48b2f1ebbb1c5b4b7563eb1f418bcfcfdbb06ebb4e7"
+checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
 dependencies = [
- "getrandom",
+ "cfg-if",
+ "once_cell",
 ]
 
 [[package]]
-name = "rayon"
-version = "1.5.1"
+name = "threadpool"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
+checksum = "d050e60b33d41c19108b32cea32164033a9013fe3b46cbd4457559bfbf77afaa"
 dependencies = [
- "autocfg",
- "crossbeam-deque",
- "either",
- "rayon-core",
+ "num_cpus",
 ]
 
 [[package]]
-name = "rayon-core"
-version = "1.9.1"
+name = "time"
+version = "0.3.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
+checksum = "743bd48c283afc0388f9b8827b976905fb217ad9e647fae3a379a9283c4def2c"
 dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-utils",
- "lazy_static",
- "num_cpus",
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde_core",
+ "time-core",
+ "time-macros",
 ]
 
 [[package]]
-name = "redox_syscall"
-version = "0.1.57"
+name = "time-core"
+version = "0.1.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce"
+checksum = "7694e1cfe791f8d31026952abf09c69ca6f6fa4e1a1229e18988f06a04a12dca"
 
 [[package]]
-name = "redox_syscall"
-version = "0.2.10"
+name = "time-macros"
+version = "0.2.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8383f39639269cde97d255a32bdb68c047337295414940c68bdd30c2e13203ff"
+checksum = "2e70e4c5a0e0a8a4823ad65dfe1a6930e4f4d756dcd9dd7939022b5e8c501215"
 dependencies = [
- "bitflags",
+ "num-conv",
+ "time-core",
 ]
 
 [[package]]
-name = "redox_users"
-version = "0.4.0"
+name = "tiny-keccak"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "528532f3d801c87aec9def2add9ca802fe569e44a544afe633765267840abe64"
+checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
 dependencies = [
- "getrandom",
- "redox_syscall 0.2.10",
+ "crunchy",
 ]
 
 [[package]]
-name = "regalloc"
-version = "0.0.31"
+name = "tinystr"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "571f7f397d61c4755285cd37853fe8e03271c243424a907415909379659381c5"
+checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
 dependencies = [
- "log",
- "rustc-hash",
- "serde",
- "smallvec",
+ "displaydoc",
+ "zerovec",
 ]
 
 [[package]]
-name = "regex"
-version = "1.5.5"
+name = "tinyvec"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a11647b6b25ff05a515cb92c365cec08801e83423a235b51e231e1808747286"
+checksum = "ce6b6a2fb3a985e99cebfaefa9faa3024743da73304ca1c683a36429613d3d22"
 dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
+ "tinyvec_macros",
 ]
 
 [[package]]
-name = "regex-syntax"
-version = "0.6.25"
+name = "tinyvec_macros"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
-name = "region"
-version = "2.2.0"
+name = "tokio"
+version = "1.50.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877e54ea2adcd70d80e9179344c97f93ef0dffd6b03e1f4529e6e83ab2fa9ae0"
+checksum = "27ad5e34374e03cfffefc301becb44e9dc3c17584f414349ebe29ed26661822d"
 dependencies = [
- "bitflags",
+ "bytes",
  "libc",
- "mach",
- "winapi",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "remove_dir_all"
-version = "0.5.3"
+name = "tokio-macros"
+version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
 dependencies = [
- "winapi",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "reqwest"
-version = "0.11.4"
+name = "tokio-native-tls"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "246e9f61b9bb77df069a947682be06e31ac43ea37862e244a69f177694ea6d22"
+checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
+dependencies = [
+ "native-tls",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-openssl"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ffab79df67727f6acf57f1ff743091873c24c579b1e2ce4d8f53e47ded4d63d"
 dependencies = [
- "base64 0.13.1",
- "bytes",
- "encoding_rs",
- "futures-core",
  "futures-util",
- "http",
- "http-body",
- "hyper",
- "hyper-tls",
- "ipnet",
- "js-sys",
- "lazy_static",
+ "openssl",
+ "openssl-sys",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-postgres"
+version = "0.7.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b40d66d9b2cfe04b628173409368e58247e8eddbbd3b0e6c6ba1d09f20f6c9e"
+dependencies = [
+ "async-trait",
+ "byteorder",
+ "bytes",
+ "fallible-iterator 0.2.0",
+ "futures-channel",
+ "futures-util",
  "log",
- "mime",
- "mime_guess",
- "native-tls",
+ "parking_lot",
  "percent-encoding",
+ "phf",
  "pin-project-lite",
- "serde",
- "serde_json",
- "serde_urlencoded",
+ "postgres-protocol",
+ "postgres-types",
+ "rand 0.9.3",
+ "socket2",
  "tokio",
- "tokio-native-tls",
- "url",
- "wasm-bindgen",
- "wasm-bindgen-futures",
- "web-sys",
- "winreg",
+ "tokio-util",
+ "whoami",
 ]
 
 [[package]]
-name = "ring"
-version = "0.16.20"
+name = "tokio-retry"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+checksum = "4a129d95275ebf4c493ec53bf0f8cd95f5ac161bc4f381700809a54f595d4470"
 dependencies = [
- "cc",
- "libc",
- "once_cell",
- "spin",
- "untrusted",
- "web-sys",
- "winapi",
+ "pin-project-lite",
+ "rand 0.10.1",
+ "tokio",
 ]
 
 [[package]]
-name = "rlp"
-version = "0.5.1"
+name = "tokio-rustls"
+version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "999508abb0ae792aabed2460c45b89106d97fe4adac593bdaef433c2605847b5"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
 dependencies = [
- "bytes",
- "rustc-hex",
+ "rustls",
+ "tokio",
 ]
 
 [[package]]
-name = "rustc-demangle"
-version = "0.1.20"
+name = "tokio-stream"
+version = "0.1.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dead70b0b5e03e9c814bcb6b01e03e68f7c57a80aa48c72ec92152ab3e818d49"
+checksum = "32da49809aab5c3bc678af03902d4ccddea2a87d028d86392a4b1560c6906c70"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+]
 
 [[package]]
-name = "rustc-hash"
-version = "1.1.0"
+name = "tokio-test"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+checksum = "2468baabc3311435b55dd935f702f42cd1b8abb7e754fb7dfb16bd36aa88f9f7"
+dependencies = [
+ "async-stream",
+ "bytes",
+ "futures-core",
+ "tokio",
+ "tokio-stream",
+]
 
 [[package]]
-name = "rustc-hex"
-version = "2.1.0"
+name = "tokio-tungstenite"
+version = "0.28.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6"
+checksum = "d25a406cddcc431a75d3d9afc6a7c0f7428d4891dd973e4d54c56b46127bf857"
+dependencies = [
+ "futures-util",
+ "log",
+ "rustls",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-rustls",
+ "tungstenite 0.28.0",
+ "webpki-roots 0.26.11",
+]
 
 [[package]]
-name = "rustc_version"
-version = "0.4.0"
+name = "tokio-tungstenite"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
+checksum = "8f72a05e828585856dacd553fba484c242c46e391fb0e58917c942ee9202915c"
 dependencies = [
- "semver",
+ "futures-util",
+ "log",
+ "tokio",
+ "tungstenite 0.29.0",
 ]
 
 [[package]]
-name = "rustls"
-version = "0.20.4"
+name = "tokio-util"
+version = "0.7.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fbfeb8d0ddb84706bc597a5574ab8912817c52a397f819e5b614e2265206921"
+checksum = "9ae9cec805b01e8fc3fd2fe289f89149a9b66dd16786abd8b19cfa7b48cb0098"
 dependencies = [
- "log",
- "ring",
- "sct 0.7.0",
- "webpki",
+ "bytes",
+ "futures-core",
+ "futures-io",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
 ]
 
 [[package]]
-name = "rustls-native-certs"
-version = "0.6.2"
+name = "toml"
+version = "0.9.12+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0167bac7a9f490495f3c33013e7722b53cb087ecbe082fb0c6387c96f634ea50"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
 dependencies = [
- "openssl-probe",
- "rustls-pemfile",
- "schannel",
- "security-framework",
+ "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 = "rustls-pemfile"
-version = "1.0.0"
+name = "toml"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7522c9de787ff061458fe9a829dc790a3f5b22dc571694fc5883f448b94d9a9"
+checksum = "81f3d15e84cbcd896376e6730314d59fb5a87f31e4b038454184435cd57defee"
 dependencies = [
- "base64 0.13.1",
+ "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 = "rustversion"
-version = "1.0.11"
+name = "toml_datetime"
+version = "0.6.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5583e89e108996506031660fe09baa5011b9dd0341b89029313006d1fb508d70"
+checksum = "4badfd56924ae69bcc9039335b2e017639ce3f9b001c393c1b2d1ef846ce2cbf"
 
 [[package]]
-name = "ryu"
-version = "1.0.5"
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
 
 [[package]]
-name = "same-file"
-version = "1.0.6"
+name = "toml_datetime"
+version = "1.1.1+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+checksum = "3165f65f62e28e0115a00b2ebdd37eb6f3b641855f9d636d3cd4103767159ad7"
 dependencies = [
- "winapi-util",
+ "serde_core",
 ]
 
 [[package]]
-name = "schannel"
-version = "0.1.19"
+name = "toml_edit"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f05ba609c234e60bee0d547fe94a4c7e9da733d1c962cf6e59efa4cd9c8bc75"
+checksum = "6a8534fd7f78b5405e860340ad6575217ce99f38d4d5c8f2442cb5ecb50090e1"
 dependencies = [
- "lazy_static",
- "winapi",
+ "indexmap 2.14.0",
+ "toml_datetime 0.6.6",
+ "winnow 0.5.40",
 ]
 
 [[package]]
-name = "scheduled-thread-pool"
-version = "0.2.5"
+name = "toml_parser"
+version = "1.1.2+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc6f74fd1204073fa02d5d5d68bec8021be4c38690b61264b2fdb48083d0e7d7"
+checksum = "a2abe9b86193656635d2411dc43050282ca48aa31c2451210f4202550afb7526"
 dependencies = [
- "parking_lot 0.11.2",
+ "winnow 1.0.0",
 ]
 
 [[package]]
-name = "scopeguard"
-version = "1.1.0"
+name = "toml_writer"
+version = "1.1.1+spec-1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
 
 [[package]]
-name = "scroll"
-version = "0.10.2"
+name = "tonic"
+version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fda28d4b4830b807a8b43f7b0e6b5df875311b3e7621d84577188c175b6ec1ec"
+checksum = "ac2a5518c70fa84342385732db33fb3f44bc4cc748936eb5833d2df34d6445ef"
 dependencies = [
- "scroll_derive",
+ "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 = "scroll_derive"
-version = "0.10.5"
+name = "tonic-build"
+version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaaae8f38bb311444cfb7f1979af0bc9240d95795f75f9ceddf6a59b79ceffa0"
+checksum = "c68f61875ac5293cf72e6c8cf0158086428c82c37229e98c840878f1706b0322"
 dependencies = [
+ "prettyplease",
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "sct"
-version = "0.6.1"
+name = "tonic-prost"
+version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b362b83898e0e69f38515b82ee15aa80636befe47c3b6d3d89a911e78fc228ce"
+checksum = "50849f68853be452acf590cde0b146665b8d507b3b8af17261df47e02c209ea0"
 dependencies = [
- "ring",
- "untrusted",
+ "bytes",
+ "prost",
+ "tonic",
 ]
 
 [[package]]
-name = "sct"
-version = "0.7.0"
+name = "tonic-prost-build"
+version = "0.14.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d53dcdb7c9f8158937a7981b48accfd39a43af418591a5d008c7b22b5e1b7ca4"
+checksum = "654e5643eff75d7f8c99197ce1440ed19a3474eada74c12bbac488b2cafdae27"
 dependencies = [
- "ring",
- "untrusted",
+ "prettyplease",
+ "proc-macro2",
+ "prost-build",
+ "prost-types",
+ "quote",
+ "syn 2.0.118",
+ "tempfile",
+ "tonic-build",
 ]
 
 [[package]]
-name = "secp256k1"
-version = "0.21.3"
+name = "tower"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c42e6f1735c5f00f51e43e28d6634141f2bcad10931b2609ddd74a86d751260"
+checksum = "d039ad9159c98b70ecfd540b2573b97f7f52c3e8d9f8ad57a24b916a536975f9"
 dependencies = [
- "secp256k1-sys",
+ "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 = "secp256k1-sys"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "957da2573cde917463ece3570eab4a0b3f19de6f1646cde62e6fd3868f566036"
+name = "tower"
+version = "0.5.3"
+source = "git+https://github.com/tower-rs/tower.git#df06d70dbea345facbffb5881fe8647f53bf424d"
 dependencies = [
- "cc",
+ "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 = "security-framework"
-version = "2.3.1"
+name = "tower-http"
+version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23a2ac85147a3a11d77ecf1bc7166ec0b92febfa4461c37944e180f319ece467"
+checksum = "4cfcf7e2740e6fc6d4d688b4ef00650406bb94adf4731e43c096c3a19fe40840"
 dependencies = [
- "bitflags",
- "core-foundation",
- "core-foundation-sys",
- "libc",
- "security-framework-sys",
+ "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 = "security-framework-sys"
-version = "2.3.0"
+name = "tower-http"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e4effb91b4b8b6fb7732e670b6cee160278ff8e6bf485c7805d9e319d76e284"
+checksum = "b11f75e912b0c2be01b63d8cf8057b8c3f97cf34abb3d431a3a4c8675498e233"
 dependencies = [
- "core-foundation-sys",
- "libc",
+ "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 = "semver"
-version = "1.0.16"
+name = "tower-layer"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "121c2a6cda46980bb0fcd1647ffaf6cd3fc79a013de288782836f6df9c48780e"
+
+[[package]]
+name = "tower-layer"
+version = "0.3.3"
+source = "git+https://github.com/tower-rs/tower.git#df06d70dbea345facbffb5881fe8647f53bf424d"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58bc9567378fc7690d6b2addae4e60ac2eeea07becb2c64b9f218b53865cba2a"
+checksum = "8df9b6e13f2d32c91b9bd719c00d1958837bc7dec474d94952798cc8e69eeec3"
+
+[[package]]
+name = "tower-service"
+version = "0.3.3"
+source = "git+https://github.com/tower-rs/tower.git#df06d70dbea345facbffb5881fe8647f53bf424d"
+
+[[package]]
+name = "tower-test"
+version = "0.4.1"
+source = "git+https://github.com/tower-rs/tower.git#df06d70dbea345facbffb5881fe8647f53bf424d"
 dependencies = [
- "serde",
+ "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 = "serde"
-version = "1.0.152"
+name = "tracing"
+version = "0.1.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb7d1f0d3021d347a83e556fc4683dea2ea09d87bccdf88ff5c12545d89d5efb"
+checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
 dependencies = [
- "serde_derive",
+ "log",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
 ]
 
 [[package]]
-name = "serde_derive"
-version = "1.0.152"
+name = "tracing-attributes"
+version = "0.1.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af487d118eecd09402d70a5d72551860e788df87b464af30e5ea6a38c75c541e"
+checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "serde_json"
-version = "1.0.66"
+name = "tracing-core"
+version = "0.1.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "336b10da19a12ad094b59d870ebde26a45402e5b470add4b5fd03c5048a32127"
+checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
 dependencies = [
- "itoa 0.4.7",
- "ryu",
- "serde",
+ "once_cell",
 ]
 
 [[package]]
-name = "serde_plain"
-version = "1.0.1"
+name = "try-lock"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6018081315db179d0ce57b1fe4b62a12a0028c9cf9bbef868c9cf477b3c34ae"
+checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
+
+[[package]]
+name = "tungstenite"
+version = "0.28.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8628dcc84e5a09eb3d8423d6cb682965dea9133204e8fb3efee74c2a0c259442"
 dependencies = [
- "serde",
+ "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 = "serde_regex"
-version = "1.1.0"
+name = "tungstenite"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8136f1a4ea815d7eac4101cfd0b16dc0cb5e1fe1b8609dfd728058656b7badf"
+checksum = "6c01152af293afb9c7c2a57e4b559c5620b421f6d133261c60dd2d0cdb38e6b8"
 dependencies = [
- "regex",
- "serde",
+ "bytes",
+ "data-encoding",
+ "http 1.4.2",
+ "httparse",
+ "log",
+ "rand 0.9.3",
+ "sha1 0.10.6",
+ "thiserror 2.0.18",
 ]
 
 [[package]]
-name = "serde_spanned"
-version = "0.6.1"
+name = "twox-hash"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0efd8caf556a6cebd3b285caf480045fcc1ac04f6bd786b09a6f11af30c4fcf4"
-dependencies = [
- "serde",
-]
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
 
 [[package]]
-name = "serde_urlencoded"
-version = "0.7.0"
+name = "typenum"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edfa57a7f8d9c1d260a549e7224100f6c43d43f9103e06dd8b4095a9b2b43ce9"
-dependencies = [
- "form_urlencoded",
- "itoa 0.4.7",
- "ryu",
- "serde",
-]
+checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
 
 [[package]]
-name = "serde_with"
-version = "1.9.4"
+name = "ucd-trie"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad9fdbb69badc8916db738c25efd04f0a65297d26c2f8de4b62e57b8c12bc72"
-dependencies = [
- "rustversion",
- "serde",
- "serde_with_macros",
-]
+checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
 
 [[package]]
-name = "serde_with_macros"
-version = "1.4.2"
+name = "uint"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1569374bd54623ec8bd592cf22ba6e03c0f177ff55fbc8c29a49e296e7adecf"
+checksum = "76f64bba2c53b04fcab63c01a7d7427eadc821e3bc48c34dc9ba29c501164b52"
 dependencies = [
- "darling",
- "proc-macro2",
- "quote",
- "syn",
+ "byteorder",
+ "crunchy",
+ "hex",
+ "static_assertions",
 ]
 
 [[package]]
-name = "serde_yaml"
-version = "0.8.26"
+name = "uint"
+version = "0.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578a7433b776b56a35785ed5ce9a7e777ac0598aac5a6dd1b4b18a307c7fc71b"
+checksum = "6f9227a75a5a540a464c832ad4a4195dbdbecd8787610a56262721fde6f04f90"
 dependencies = [
- "indexmap",
- "ryu",
- "serde",
- "yaml-rust",
+ "byteorder",
+ "crunchy",
+ "hex",
+ "static_assertions",
 ]
 
 [[package]]
-name = "sha-1"
-version = "0.9.7"
+name = "unarray"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a0c8611594e2ab4ebbf06ec7cbbf0a99450b8570e96cbf5188b5d5f6ef18d81"
-dependencies = [
- "block-buffer 0.9.0",
- "cfg-if 1.0.0",
- "cpufeatures 0.1.5",
- "digest 0.9.0",
- "opaque-debug",
-]
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
 [[package]]
-name = "sha-1"
-version = "0.10.0"
+name = "unicase"
+version = "2.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "028f48d513f9678cda28f6e4064755b3fbb2af6acd672f2c209b62323f7aea0f"
+checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
 dependencies = [
- "cfg-if 1.0.0",
- "cpufeatures 0.2.2",
- "digest 0.10.5",
+ "version_check",
 ]
 
 [[package]]
-name = "sha2"
-version = "0.9.5"
+name = "unicode-bidi"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b362ae5752fd2137731f9fa25fd4d9058af34666ca1966fb969119cc35719f12"
-dependencies = [
- "block-buffer 0.9.0",
- "cfg-if 1.0.0",
- "cpufeatures 0.1.5",
- "digest 0.9.0",
- "opaque-debug",
-]
+checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
 
 [[package]]
-name = "sha2"
-version = "0.10.6"
+name = "unicode-ident"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82e6b795fe2e3b1e845bafcb27aa35405c4d47cdfc92af5fc8d3002f76cebdc0"
-dependencies = [
- "cfg-if 1.0.0",
- "cpufeatures 0.2.2",
- "digest 0.10.5",
-]
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
 [[package]]
-name = "sha3"
-version = "0.10.1"
+name = "unicode-normalization"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "881bf8156c87b6301fc5ca6b27f11eeb2761224c7081e69b409d5a1951a70c86"
+checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
 dependencies = [
- "digest 0.10.5",
- "keccak",
+ "tinyvec",
 ]
 
 [[package]]
-name = "shellexpand"
-version = "2.1.0"
+name = "unicode-properties"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83bdb7831b2d85ddf4a7b148aa19d0587eddbe8671a436b7bd1182eaad0f2829"
-dependencies = [
- "dirs-next",
-]
+checksum = "e4259d9d4425d9f0661581b804cb85fe66a4c631cadd8f490d1c13a35d5d9291"
 
 [[package]]
-name = "signal-hook-registry"
-version = "1.4.0"
+name = "unicode-segmentation"
+version = "1.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e51e73328dc4ac0c7ccbda3a494dfa03df1de2f46018127f60c693f2648455b0"
-dependencies = [
- "libc",
-]
+checksum = "f6ccf251212114b54433ec949fd6a7841275f9ada20dddd2f29e9ceea4501493"
 
 [[package]]
-name = "siphasher"
-version = "0.3.6"
+name = "unicode-width"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "729a25c17d72b06c68cb47955d44fda88ad2d3e7d77e025663fdd69b93dd71a1"
+checksum = "1fc81956842c57dac11422a97c3b8195a1ff727f06e85c84ed2e8aa277c9a0fd"
 
 [[package]]
-name = "slab"
-version = "0.4.4"
+name = "unicode-xid"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c307a32c1c5c437f38c7fd45d753050587732ba8628319fbdf12a7e289ccc590"
+checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
 
 [[package]]
-name = "slog"
-version = "2.7.0"
+name = "unit-prefix"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8347046d4ebd943127157b94d63abb990fcf729dc4e9978927fdf4ac3c998d06"
+checksum = "81e544489bf3d8ef66c953931f56617f423cd4b5494be343d9b9d3dda037b9a3"
 
 [[package]]
-name = "slog-async"
-version = "2.7.0"
+name = "unsafe-libyaml"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "766c59b252e62a34651412870ff55d8c4e6d04df19b43eecb2703e417b097ffe"
-dependencies = [
- "crossbeam-channel",
- "slog",
- "take_mut",
- "thread_local",
-]
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
 
 [[package]]
-name = "slog-envlogger"
-version = "2.2.0"
+name = "unsigned-varint"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "906a1a0bc43fed692df4b82a5e2fbfc3733db8dad8bb514ab27a4f23ad04f5c0"
-dependencies = [
- "log",
- "regex",
- "slog",
- "slog-async",
- "slog-scope",
- "slog-stdlog",
- "slog-term",
-]
+checksum = "eb066959b24b5196ae73cb057f45598450d2c5f71460e98c49b738086eff9c06"
 
 [[package]]
-name = "slog-scope"
-version = "4.4.0"
+name = "untrusted"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f95a4b4c3274cd2869549da82b57ccc930859bdbf5bcea0424bc5f140b3c786"
-dependencies = [
- "arc-swap",
- "lazy_static",
- "slog",
-]
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
 
 [[package]]
-name = "slog-stdlog"
-version = "4.1.1"
+name = "url"
+version = "2.5.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6706b2ace5bbae7291d3f8d2473e2bfab073ccd7d03670946197aec98471fa3e"
+checksum = "ff67a8a4397373c3ef660812acab3268222035010ab8680ec4215f38ba3d0eed"
 dependencies = [
- "log",
- "slog",
- "slog-scope",
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+ "serde_derive",
 ]
 
 [[package]]
-name = "slog-term"
-version = "2.8.0"
+name = "utf-8"
+version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95c1e7e5aab61ced6006149ea772770b84a0d16ce0f7885def313e4829946d76"
-dependencies = [
- "atty",
- "chrono",
- "slog",
- "term",
- "thread_local",
-]
+checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
 
 [[package]]
-name = "smallvec"
-version = "1.6.1"
+name = "utf16_iter"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe0f37c9e8f3c5a4a66ad655a93c74daac4ad00c441533bf5c6e7990bb42604e"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
 
 [[package]]
-name = "socket2"
-version = "0.4.1"
+name = "utf8_iter"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "765f090f0e423d2b55843402a07915add955e7d60657db13707a159727326cad"
-dependencies = [
- "libc",
- "winapi",
-]
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
 [[package]]
-name = "soketto"
-version = "0.7.1"
+name = "utf8parse"
+version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "41d1c5305e39e09653383c2c7244f2f78b3bcae37cf50c64cb4789c9f5096ec2"
-dependencies = [
- "base64 0.13.1",
- "bytes",
- "futures 0.3.16",
- "httparse",
- "log",
- "rand",
- "sha-1 0.9.7",
-]
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
-name = "spin"
-version = "0.5.2"
+name = "uuid"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+checksum = "e0f540e3240398cce6128b64ba83fdbdd86129c16a3aa1a3a252efd66eb3d587"
 
 [[package]]
-name = "stable-hash"
-version = "0.3.3"
+name = "valuable"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10196e68950ed99c0d2db7a30ffaf4dfe0bbf2f9af2ae0457ee8ad396e0a2dd7"
-dependencies = [
- "blake3 0.3.8",
- "firestorm 0.4.6",
- "ibig",
- "lazy_static",
- "leb128",
- "num-traits",
-]
+checksum = "ba73ea9cf16a25df0c8caa16c51acb937d5712a8429db78a3ee29d5dcacd3a65"
 
 [[package]]
-name = "stable-hash"
-version = "0.4.2"
+name = "vcpkg"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af75bd21beb162eab69de76abbb803d4111735ead00d5086dcc6f4ddb3b53cc9"
-dependencies = [
- "blake3 0.3.8",
- "firestorm 0.5.0",
- "ibig",
- "lazy_static",
- "leb128",
- "num-traits",
- "xxhash-rust",
-]
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
 
 [[package]]
-name = "stable_deref_trait"
-version = "1.2.0"
+name = "version_check"
+version = "0.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
 
 [[package]]
-name = "static_assertions"
-version = "1.1.0"
+name = "wait-timeout"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
+dependencies = [
+ "libc",
+]
 
 [[package]]
-name = "stringprep"
-version = "0.1.2"
+name = "walkdir"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ee348cb74b87454fff4b551cbf727025810a004f88aeacae7f85b87f4e9a1c1"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
 dependencies = [
- "unicode-bidi",
- "unicode-normalization",
+ "same-file",
+ "winapi-util",
 ]
 
 [[package]]
-name = "strsim"
-version = "0.10.0"
+name = "want"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
+checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
+dependencies = [
+ "try-lock",
+]
 
 [[package]]
-name = "strum"
-version = "0.21.0"
+name = "wasi"
+version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaf86bbcfd1fa9670b7a129f64fc0c9fcbbfe4f1bc4210e9e98fe71ffc12cde2"
+checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
 [[package]]
-name = "strum_macros"
-version = "0.21.1"
+name = "wasi"
+version = "0.13.3+wasi-0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d06aaeeee809dbc59eb4556183dd927df67db1540de5be8d3ec0b6636358a5ec"
+checksum = "26816d2e1a4a36a2940b96c5296ce403917633dff8f3440e9b236ed6f6bacad2"
 dependencies = [
- "heck 0.3.3",
- "proc-macro2",
- "quote",
- "syn",
+ "wit-bindgen-rt",
 ]
 
 [[package]]
-name = "subtle"
-version = "2.4.1"
+name = "wasip2"
+version = "1.0.2+wasi-0.2.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bdef32e8150c2a081110b42772ffe7d7c9032b606bc226c8260fd97e0976601"
+checksum = "9517f9239f02c069db75e65f174b3da828fe5f5b945c4dd26bd25d89c03ebcf5"
+dependencies = [
+ "wit-bindgen",
+]
 
 [[package]]
-name = "syn"
-version = "1.0.107"
+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 = "1f4064b5b16e03ae50984a5a8ed5d4f8803e6bc1fd170a3cda91a1be4b18e3f5"
+checksum = "5428f8bf88ea5ddc08faddef2ac4a67e390b88186c703ce6dbd955e1c145aca5"
 dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
+ "wit-bindgen",
 ]
 
 [[package]]
-name = "sync_wrapper"
-version = "0.1.1"
+name = "wasite"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20518fe4a4c9acf048008599e464deb21beeae3d3578418951a189c235a7a9a8"
+checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
 
 [[package]]
-name = "synstructure"
-version = "0.12.5"
+name = "wasm-bindgen"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "474aaa926faa1603c40b7885a9eaea29b444d1cb2850cb7c0e37bb1a4182f4fa"
+checksum = "8ddb3f79143bced6de84270411622a2699cee572fc0875aeaf1e7867cf9fca1a"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "unicode-xid",
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
 ]
 
 [[package]]
-name = "take_mut"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60"
-
-[[package]]
-name = "tap"
-version = "1.0.1"
+name = "wasm-bindgen-futures"
+version = "0.4.75"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+checksum = "503b14d284f2c8dac03b819967e155ea753f573586193b2b2c95990cb5d69280"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
 
 [[package]]
-name = "target-lexicon"
-version = "0.12.1"
+name = "wasm-bindgen-macro"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0652da4c4121005e9ed22b79f6c5f2d9e2752906b53a33e9490489ba421a6fb"
+checksum = "4e21a184b13fb19e157296e2c46056aec9092264fab83e4ba59e68c61b323c3d"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
 
 [[package]]
-name = "tempfile"
-version = "3.2.0"
+name = "wasm-bindgen-macro-support"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dac1c663cfc93810f88aed9b8941d48cabf856a1b111c29a40439018d870eb22"
+checksum = "fecefd9c35bd935a20fc3fc344b5f29138961e4f47fb03297d88f2587afb5ebd"
 dependencies = [
- "cfg-if 1.0.0",
- "libc",
- "rand",
- "redox_syscall 0.2.10",
- "remove_dir_all",
- "winapi",
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "wasm-bindgen-shared",
 ]
 
 [[package]]
-name = "term"
-version = "0.7.0"
+name = "wasm-bindgen-shared"
+version = "0.2.125"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f"
+checksum = "23939e44bb9a5d7576fa2b563dc2e136628f1224e88a8deed09e04858b77871f"
 dependencies = [
- "dirs-next",
- "rustversion",
- "winapi",
+ "unicode-ident",
 ]
 
 [[package]]
-name = "termcolor"
-version = "1.2.0"
+name = "wasm-compose"
+version = "0.251.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
+checksum = "b089037d7eb453ed57b560fe7833de0707411c8b9fdc429745ced77e2a1bacb9"
 dependencies = [
- "winapi-util",
+ "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 = "terminal_size"
-version = "0.1.17"
+name = "wasm-encoder"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "633c1a546cee861a1a6d0dc69ebeca693bf4296661ba7852b9d21d159e0506df"
+checksum = "990065f2fe63003fe337b932cfb5e3b80e0b4d0f5ff650e6985b1048f62c8319"
 dependencies = [
- "libc",
- "winapi",
+ "leb128fmt",
+ "wasmparser 0.244.0",
 ]
 
 [[package]]
-name = "test-store"
-version = "0.30.0"
+name = "wasm-encoder"
+version = "0.251.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a879a421bd17c528b74721b2abf4c62e8f1d1889c2ba8c3c50d02deaf2ce395"
 dependencies = [
- "diesel",
- "graph",
- "graph-chain-ethereum",
- "graph-graphql",
- "graph-mock",
- "graph-node",
- "graph-store-postgres",
- "graphql-parser",
- "hex-literal",
- "lazy_static",
- "prost-types",
- "serde",
+ "leb128fmt",
+ "wasmparser 0.251.0",
 ]
 
 [[package]]
-name = "textwrap"
-version = "0.16.0"
+name = "wasm-encoder"
+version = "0.252.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
+checksum = "8185ae345fa5687c054626ff9a50e7089797a343d9904d1dc9820eb4c4d3196f"
+dependencies = [
+ "leb128fmt",
+ "wasmparser 0.252.0",
+]
 
 [[package]]
-name = "thiserror"
-version = "1.0.31"
+name = "wasm-instrument"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd829fe32373d27f76265620b5309d0340cb8550f523c1dda251d6298069069a"
+checksum = "2a47ecb37b9734d1085eaa5ae1a81e60801fd8c28d4cabdd8aedb982021918bc"
 dependencies = [
- "thiserror-impl",
+ "parity-wasm",
 ]
 
 [[package]]
-name = "thiserror-impl"
-version = "1.0.31"
+name = "wasm-metadata"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0396bc89e626244658bef819e22d0cc459e795a5ebe878e6ec336d1674a8d79a"
+checksum = "bb0e353e6a2fbdc176932bbaab493762eb1255a7900fe0fea1a2f96c296cc909"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "anyhow",
+ "indexmap 2.14.0",
+ "wasm-encoder 0.244.0",
+ "wasmparser 0.244.0",
 ]
 
 [[package]]
-name = "thread_local"
-version = "1.1.4"
+name = "wasm-streams"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
 dependencies = [
- "once_cell",
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
-name = "time"
-version = "0.1.44"
+name = "wasm-streams"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6db9e6914ab8b1ae1c260a4ae7a49b6c5611b40328a735b21862567685e73255"
+checksum = "9d1ec4f6517c9e11ae630e200b2b65d193279042e28edd4a2cda233e46670bbb"
 dependencies = [
- "libc",
- "wasi",
- "winapi",
+ "futures-util",
+ "js-sys",
+ "wasm-bindgen",
+ "wasm-bindgen-futures",
+ "web-sys",
 ]
 
 [[package]]
-name = "time"
-version = "0.3.17"
+name = "wasmparser"
+version = "0.118.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a561bf4617eebd33bca6434b988f39ed798e527f51a1e797d0ee4f61c0a38376"
+checksum = "77f1154f1ab868e2a01d9834a805faca7bf8b50d041b4ca714d005d0dab1c50c"
 dependencies = [
- "itoa 1.0.1",
- "serde",
- "time-core",
- "time-macros",
+ "indexmap 2.14.0",
+ "semver 1.0.28",
 ]
 
 [[package]]
-name = "time-core"
-version = "0.1.0"
+name = "wasmparser"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
+checksum = "47b807c72e1bac69382b3a6fb3dbe8ea4c0ed87ff5629b8685ae6b9a611028fe"
+dependencies = [
+ "bitflags 2.11.1",
+ "hashbrown 0.15.2",
+ "indexmap 2.14.0",
+ "semver 1.0.28",
+]
 
 [[package]]
-name = "time-macros"
-version = "0.2.6"
+name = "wasmparser"
+version = "0.251.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d967f99f534ca7e495c575c62638eebc2898a8c84c119b89e250477bc4ba16b2"
+checksum = "437970b35b1a85cfde9c74b2398352d8d653f3bd8e3a3db0c063ea8f5b4b36ff"
 dependencies = [
- "time-core",
+ "bitflags 2.11.1",
+ "hashbrown 0.17.0",
+ "indexmap 2.14.0",
+ "semver 1.0.28",
+ "serde",
 ]
 
 [[package]]
-name = "tiny-keccak"
-version = "1.5.0"
+name = "wasmparser"
+version = "0.252.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d8a021c69bb74a44ccedb824a046447e2c84a01df9e5c20779750acb38e11b2"
+checksum = "d3eb099dcadcde5be9eef55e3a337128efd4e44b4c93122487e4d2e4e1c6627c"
 dependencies = [
- "crunchy",
+ "bitflags 2.11.1",
+ "indexmap 2.14.0",
+ "semver 1.0.28",
 ]
 
 [[package]]
-name = "tiny-keccak"
-version = "2.0.2"
+name = "wasmprinter"
+version = "0.251.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237"
+checksum = "8798c1a699bd25648b6708eefe94d97c6f9891febb94b42cca1f7a4b086ea64e"
 dependencies = [
- "crunchy",
+ "anyhow",
+ "termcolor",
+ "wasmparser 0.251.0",
 ]
 
 [[package]]
-name = "tinyvec"
-version = "1.3.1"
+name = "wasmtime"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "848a1e1181b9f6753b5e96a092749e29b11d19ede67dfbbd6c7dc7e0f49b5338"
+checksum = "c4213d2f019a5e44aa8a61d8826dd33a505bff79f749b14a8bafd67321cb9351"
 dependencies = [
- "tinyvec_macros",
+ "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 = "tinyvec_macros"
-version = "0.1.0"
+name = "wasmtime-environ"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cda74da7e1a664f795bb1f8a87ec406fb89a02522cf6e50620d016add6dbbf5c"
+checksum = "d45863de41977ec6453e859cf843d456fa3fcb45a659b66d16e794f90ec4f5b7"
+dependencies = [
+ "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_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 = "tokio"
-version = "1.16.1"
+name = "wasmtime-internal-cache"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c27a64b625de6d309e8c57716ba93021dccf1b3b5c97edd6d3dd2d2135afc0a"
+checksum = "438bc7dc45fb75297d75f79a9a0ce852345d13ebc6a6863f6f688f013836a9dd"
 dependencies = [
- "bytes",
- "libc",
- "memchr",
- "mio",
- "num_cpus",
- "once_cell",
- "parking_lot 0.11.2",
- "pin-project-lite",
- "signal-hook-registry",
- "tokio-macros",
- "winapi",
+ "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 = "tokio-io-timeout"
-version = "1.1.1"
+name = "wasmtime-internal-component-macro"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90c49f106be240de154571dd31fbe48acb10ba6c6dd6f6517ad603abffa42de9"
+checksum = "f1e48f8d4966d62a10b6d70722bc432c1e163890be2801d3b5784589ad36ffc3"
 dependencies = [
- "pin-project-lite",
- "tokio",
+ "anyhow",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-wit-bindgen",
+ "wit-parser 0.251.0",
 ]
 
 [[package]]
-name = "tokio-macros"
-version = "1.7.0"
+name = "wasmtime-internal-component-util"
+version = "46.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819ad5abd5822a22dbf4014475cdfd1fe790707761cd732d74aaa3ba4d5ba489"
+
+[[package]]
+name = "wasmtime-internal-core"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b557f72f448c511a979e2564e55d74e6c4432fc96ff4f6241bc6bded342643b7"
+checksum = "3fc28372e36eaf8cf70faa83b5779137f7e99c8d18569a125d1580e735cc9e4d"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "anyhow",
+ "hashbrown 0.17.0",
+ "libm",
+ "serde",
 ]
 
 [[package]]
-name = "tokio-native-tls"
-version = "0.3.0"
+name = "wasmtime-internal-cranelift"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7d995660bd2b7f8c1568414c1126076c13fbb725c40112dc0120b78eb9b717b"
+checksum = "a433efc6e35112a5457e1dc8bc4d8d39820ac7722267e89bc04e5df641f32124"
 dependencies = [
- "native-tls",
- "tokio",
+ "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 = "tokio-openssl"
-version = "0.6.3"
+name = "wasmtime-internal-fiber"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08f9ffb7809f1b20c1b398d92acf4cc719874b3b2b2d9ea2f09b4a80350878a"
+checksum = "18a1d3a39d0d210f6b8574ee96a4315e0a14c67f3a1fc3cd5372cb10d2fb4422"
 dependencies = [
- "futures-util",
- "openssl",
- "openssl-sys",
- "tokio",
+ "cc",
+ "cfg-if",
+ "libc",
+ "rustix 1.1.4",
+ "wasmtime-environ",
+ "wasmtime-internal-versioned-export-macros",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "tokio-postgres"
-version = "0.7.2"
+name = "wasmtime-internal-jit-debug"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d2b1383c7e4fb9a09e292c7c6afb7da54418d53b045f1c1fac7a911411a2b8b"
+checksum = "9f667288cb4dfa68a4639ffac4d5628535dda64ebdc2b990526efb12b30ba803"
 dependencies = [
- "async-trait",
- "byteorder",
- "bytes",
- "fallible-iterator",
- "futures 0.3.16",
- "log",
- "parking_lot 0.11.2",
- "percent-encoding",
- "phf",
- "pin-project-lite",
- "postgres-protocol",
- "postgres-types",
- "socket2",
- "tokio",
- "tokio-util 0.6.7",
+ "cc",
+ "object",
+ "rustix 1.1.4",
+ "wasmtime-internal-versioned-export-macros",
 ]
 
 [[package]]
-name = "tokio-retry"
-version = "0.3.0"
+name = "wasmtime-internal-jit-icache-coherence"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f57eb36ecbe0fc510036adff84824dd3c24bb781e21bfa67b69d556aa85214f"
+checksum = "eba651d44ab0faad4c58106b3adb45068189fb65ef50f0c404b6d9e3bf81a357"
 dependencies = [
- "pin-project",
- "rand",
- "tokio",
+ "cfg-if",
+ "libc",
+ "wasmtime-internal-core",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
-name = "tokio-rustls"
-version = "0.23.3"
+name = "wasmtime-internal-unwinder"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4151fda0cf2798550ad0b34bcfc9b9dcc2a9d2471c895c68f3a8818e54f2389e"
+checksum = "2ecc52563b0558af2a7487eb710de07cc4532564b55528876129238e83118cb1"
 dependencies = [
- "rustls",
- "tokio",
- "webpki",
+ "cfg-if",
+ "cranelift-codegen",
+ "log",
+ "object",
+ "wasmtime-environ",
 ]
 
 [[package]]
-name = "tokio-stream"
-version = "0.1.12"
+name = "wasmtime-internal-versioned-export-macros"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fb52b74f05dbf495a8fba459fdc331812b96aa086d9eb78101fa0d4569c3313"
+checksum = "e747f4a074699ba1b4e4d841fb263f9b7df5bd1555181c4752bf5990d21ba676"
 dependencies = [
- "futures-core",
- "pin-project-lite",
- "tokio",
- "tokio-util 0.7.1",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "tokio-test"
-version = "0.4.2"
+name = "wasmtime-internal-wit-bindgen"
+version = "46.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53474327ae5e166530d17f2d956afcb4f8a004de581b3cae10f12006bc8163e3"
+checksum = "80009f46991622814196d96fac6fc0a938f46b5cba737a8f4e21e24e5a03856f"
 dependencies = [
- "async-stream",
- "bytes",
- "futures-core",
- "tokio",
- "tokio-stream",
+ "anyhow",
+ "bitflags 2.11.1",
+ "heck 0.5.0",
+ "indexmap 2.14.0",
+ "wit-parser 0.251.0",
 ]
 
 [[package]]
-name = "tokio-tungstenite"
-version = "0.17.2"
+name = "wasmtimer"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f714dd15bead90401d77e04243611caec13726c2408afd5b31901dfcdcb3b181"
+checksum = "1c598d6b99ea013e35844697fc4670d08339d5cda15588f193c6beedd12f644b"
 dependencies = [
- "futures-util",
- "log",
- "tokio",
- "tungstenite",
+ "futures 0.3.31",
+ "js-sys",
+ "parking_lot",
+ "pin-utils",
+ "slab",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "tokio-util"
-version = "0.6.7"
+name = "wast"
+version = "252.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1caa0b0c8d94a049db56b5acf8cba99dc0623aab1b26d5b5f5e2d945846b3592"
+checksum = "942a3449d6a593fccc111a6241c8df52bda168af30e40bf9580d4394d7374c65"
 dependencies = [
- "bytes",
- "futures-core",
- "futures-io",
- "futures-sink",
- "log",
- "pin-project-lite",
- "tokio",
+ "bumpalo",
+ "leb128fmt",
+ "memchr",
+ "unicode-width",
+ "wasm-encoder 0.252.0",
 ]
 
 [[package]]
-name = "tokio-util"
-version = "0.7.1"
+name = "wat"
+version = "1.252.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0edfdeb067411dba2044da6d1cb2df793dd35add7888d73c16e3381ded401764"
+checksum = "c72a4ba7088f7bac94cf516e49882bdf97068904a563768cf249efc839ec42cb"
 dependencies = [
- "bytes",
- "futures-core",
- "futures-sink",
- "pin-project-lite",
- "tokio",
- "tracing",
+ "wast",
 ]
 
 [[package]]
-name = "toml"
-version = "0.5.11"
+name = "web-sys"
+version = "0.3.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+checksum = "a6430a72df5eb332242960fe84b3002a241163998241eb596d4f739b9757061d"
 dependencies = [
- "serde",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "toml"
-version = "0.7.1"
+name = "web-time"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "772c1426ab886e7362aedf4abc9c0d1348a979517efedfc25862944d10137af0"
+checksum = "5a6580f308b1fad9207618087a65c04e7a10bc77e02c8e84e9b00dd4b12fa0bb"
 dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit",
+ "js-sys",
+ "wasm-bindgen",
 ]
 
 [[package]]
-name = "toml_datetime"
-version = "0.6.1"
+name = "webpki-root-certs"
+version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ab8ed2edee10b50132aed5f331333428b011c99402b5a534154ed15746f9622"
+checksum = "f31141ce3fc3e300ae89b78c0dd67f9708061d1d2eda54b8209346fd6be9a92c"
 dependencies = [
- "serde",
+ "rustls-pki-types",
 ]
 
 [[package]]
-name = "toml_edit"
-version = "0.19.1"
+name = "webpki-roots"
+version = "0.26.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "90a238ee2e6ede22fb95350acc78e21dc40da00bb66c0334bde83de4ed89424e"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
 dependencies = [
- "indexmap",
- "nom8",
- "serde",
- "serde_spanned",
- "toml_datetime",
+ "webpki-roots 1.0.5",
 ]
 
 [[package]]
-name = "tonic"
-version = "0.8.3"
+name = "webpki-roots"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f219fad3b929bef19b1f86fbc0358d35daed8f2cac972037ac0dc10bbb8d5fb"
+checksum = "12bed680863276c63889429bfd6cab3b99943659923822de1c8a39c49e4d722c"
 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",
- "tower-layer 0.3.2",
- "tower-service 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "tracing",
- "tracing-futures",
+ "rustls-pki-types",
 ]
 
 [[package]]
-name = "tonic-build"
-version = "0.8.4"
+name = "which"
+version = "4.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bf5e9b9c0f7e0a7c027dcfaba7b2c60816c7049171f679d99ee2ff65d0de8c4"
+checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7"
 dependencies = [
- "prettyplease",
- "proc-macro2",
- "prost-build",
- "quote",
- "syn",
+ "either",
+ "home",
+ "once_cell",
+ "rustix 0.38.34",
 ]
 
 [[package]]
-name = "tower"
-version = "0.4.12"
-source = "git+https://github.com/tower-rs/tower.git#74881d531141ba0f07b7f58e2a72e3594e5a665c"
+name = "whoami"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a44ab49fad634e88f55bf8f9bb3abd2f27d7204172a112c7c9987e01c1c94ea9"
 dependencies = [
- "futures-core",
- "futures-util",
- "hdrhistogram",
- "indexmap",
- "pin-project-lite",
- "slab",
- "sync_wrapper",
- "tokio",
- "tokio-util 0.7.1",
- "tower-layer 0.3.1",
- "tower-service 0.3.1 (git+https://github.com/tower-rs/tower.git)",
- "tracing",
+ "redox_syscall 0.4.1",
+ "wasite",
+ "web-sys",
 ]
 
 [[package]]
-name = "tower"
-version = "0.4.13"
+name = "widestring"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
 dependencies = [
- "futures-core",
- "futures-util",
- "indexmap",
- "pin-project",
- "pin-project-lite",
- "rand",
- "slab",
- "tokio",
- "tokio-util 0.7.1",
- "tower-layer 0.3.2",
- "tower-service 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "tracing",
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
 ]
 
 [[package]]
-name = "tower-http"
-version = "0.3.2"
+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 = "e980386f06883cf4d0578d6c9178c81f68b45d77d00f2c2c1bc034b3439c2c56"
+checksum = "4d4cc384e1e73b93bafa6fb4f1df8c41695c8a91cf9c4c64358067d15a7b6c6b"
 dependencies = [
- "bitflags",
- "bytes",
- "futures-core",
- "futures-util",
- "http",
- "http-body",
- "http-range-header",
- "pin-project-lite",
- "tower 0.4.13",
- "tower-layer 0.3.2",
- "tower-service 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "windows-sys 0.52.0",
 ]
 
 [[package]]
-name = "tower-layer"
-version = "0.3.1"
-source = "git+https://github.com/tower-rs/tower.git#74881d531141ba0f07b7f58e2a72e3594e5a665c"
+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 = "tower-layer"
-version = "0.3.2"
+name = "windows-core"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
+checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
+dependencies = [
+ "windows-targets 0.52.6",
+]
 
 [[package]]
-name = "tower-service"
-version = "0.3.1"
+name = "windows-link"
+version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6"
+checksum = "5e6ad25900d524eaabdbbb96d20b4311e1e7ae1699af4fb28c17ae66c80d798a"
 
 [[package]]
-name = "tower-service"
-version = "0.3.1"
-source = "git+https://github.com/tower-rs/tower.git#74881d531141ba0f07b7f58e2a72e3594e5a665c"
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
-name = "tower-test"
-version = "0.4.0"
-source = "git+https://github.com/tower-rs/tower.git#74881d531141ba0f07b7f58e2a72e3594e5a665c"
+name = "windows-registry"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3bab093bdd303a1240bb99b8aba8ea8a69ee19d34c9e2ef9594e708a4878820"
 dependencies = [
- "futures-util",
- "pin-project-lite",
- "tokio",
- "tokio-test",
- "tower-layer 0.3.1",
- "tower-service 0.3.1 (git+https://github.com/tower-rs/tower.git)",
+ "windows-link 0.1.3",
+ "windows-result",
+ "windows-strings",
 ]
 
 [[package]]
-name = "tracing"
-version = "0.1.36"
+name = "windows-result"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2fce9567bd60a67d08a16488756721ba392f24f29006402881e43b19aac64307"
+checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
 dependencies = [
- "cfg-if 1.0.0",
- "log",
- "pin-project-lite",
- "tracing-attributes",
- "tracing-core",
+ "windows-link 0.1.3",
 ]
 
 [[package]]
-name = "tracing-attributes"
-version = "0.1.22"
+name = "windows-strings"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "11c75893af559bc8e10716548bdef5cb2b983f8e637db9d0e15126b61b484ee2"
+checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "windows-link 0.1.3",
 ]
 
 [[package]]
-name = "tracing-core"
-version = "0.1.29"
+name = "windows-sys"
+version = "0.45.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5aeea4303076558a00714b823f9ad67d58a3bbda1df83d8827d21193156e22f7"
+checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
 dependencies = [
- "once_cell",
+ "windows-targets 0.42.2",
 ]
 
 [[package]]
-name = "tracing-futures"
-version = "0.2.5"
+name = "windows-sys"
+version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
 dependencies = [
- "pin-project",
- "tracing",
+ "windows-targets 0.48.5",
 ]
 
 [[package]]
-name = "try-lock"
-version = "0.2.3"
+name = "windows-sys"
+version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59547bce71d9c38b83d9c0e92b6066c4253371f15005def0c30d9657f50c7642"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
 
 [[package]]
-name = "tungstenite"
-version = "0.17.3"
+name = "windows-sys"
+version = "0.59.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e27992fd6a8c29ee7eef28fc78349aa244134e10ad447ce3b9f0ac0ed0fa4ce0"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
 dependencies = [
- "base64 0.13.1",
- "byteorder",
- "bytes",
- "http",
- "httparse",
- "log",
- "rand",
- "sha-1 0.10.0",
- "thiserror",
- "url",
- "utf-8",
+ "windows-targets 0.52.6",
 ]
 
 [[package]]
-name = "typed-builder"
-version = "0.10.0"
+name = "windows-sys"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89851716b67b937e393b3daa8423e67ddfc4bbbf1654bcf05488e95e0828db0c"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
 dependencies = [
- "proc-macro2",
- "quote",
- "syn",
+ "windows-targets 0.53.3",
 ]
 
 [[package]]
-name = "typenum"
-version = "1.15.0"
+name = "windows-sys"
+version = "0.61.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dcf81ac59edc17cc8697ff311e8f5ef2d99fcbd9817b34cec66f90b6c3dfd987"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link 0.2.1",
+]
 
 [[package]]
-name = "uint"
-version = "0.9.1"
+name = "windows-targets"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6470ab50f482bde894a037a57064480a246dbfdd5960bd65a44824693f08da5f"
+checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
 dependencies = [
- "byteorder",
- "crunchy",
- "hex",
- "static_assertions",
+ "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 = "unicase"
-version = "2.6.0"
+name = "windows-targets"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
 dependencies = [
- "version_check",
+ "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 = "unicode-bidi"
-version = "0.3.5"
+name = "windows-targets"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eeb8be209bb1c96b7c177c7420d26e04eccacb0eeae6b980e35fcb74678107e0"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "matches",
+ "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 = "unicode-ident"
-version = "1.0.1"
+name = "windows-targets"
+version = "0.53.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bd2fe26506023ed7b5e1e315add59d6f584c621d037f9368fea9cfb988f368c"
+checksum = "d5fe6031c4041849d7c496a8ded650796e7b6ecc19df1a431c1a363342e5dc91"
+dependencies = [
+ "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 = "unicode-normalization"
-version = "0.1.19"
+name = "windows_aarch64_gnullvm"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d54590932941a9e9266f0832deed84ebe1bf2e4c9e4a3554d393d18f5e854bf9"
-dependencies = [
- "tinyvec",
-]
+checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 
 [[package]]
-name = "unicode-segmentation"
-version = "1.8.0"
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8895849a949e7845e06bd6dc1aa51731a103c42707010a5b591c0038fb73385b"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
 
 [[package]]
-name = "unicode-width"
-version = "0.1.8"
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
 [[package]]
-name = "unicode-xid"
-version = "0.2.2"
+name = "windows_aarch64_gnullvm"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
+checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
 
 [[package]]
-name = "unreachable"
-version = "1.0.0"
+name = "windows_aarch64_msvc"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "382810877fe448991dfc7f0dd6e3ae5d58088fd0ea5e35189655f84e6814fa56"
-dependencies = [
- "void",
-]
+checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
 [[package]]
-name = "unsigned-varint"
-version = "0.7.1"
+name = "windows_aarch64_msvc"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d86a8dc7f45e4c1b0d30e43038c38f274e77af056aa5f74b93c2cf9eb3c1c836"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
 
 [[package]]
-name = "untrusted"
-version = "0.7.1"
+name = "windows_aarch64_msvc"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
 [[package]]
-name = "url"
-version = "2.3.1"
+name = "windows_aarch64_msvc"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
-dependencies = [
- "form_urlencoded",
- "idna 0.3.0",
- "percent-encoding",
-]
+checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
 
 [[package]]
-name = "utf-8"
-version = "0.7.6"
+name = "windows_i686_gnu"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9"
+checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 
 [[package]]
-name = "uuid"
-version = "1.3.0"
+name = "windows_i686_gnu"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1674845326ee10d37ca60470760d4288a6f80f304007d92e5c53bab78c9cfd79"
-dependencies = [
- "getrandom",
-]
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
 
 [[package]]
-name = "vcpkg"
-version = "0.2.15"
+name = "windows_i686_gnu"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
 [[package]]
-name = "version_check"
-version = "0.9.3"
+name = "windows_i686_gnu"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5fecdca9a5291cc2b8dcf7dc02453fee791a280f3743cb0905f8822ae463b3fe"
+checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
 
 [[package]]
-name = "void"
-version = "1.0.2"
+name = "windows_i686_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
 [[package]]
-name = "walkdir"
-version = "2.3.2"
+name = "windows_i686_gnullvm"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
-dependencies = [
- "same-file",
- "winapi",
- "winapi-util",
-]
+checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.42.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
+
+[[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_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
 
 [[package]]
-name = "want"
-version = "0.3.0"
+name = "windows_x86_64_gnullvm"
+version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
-dependencies = [
- "log",
- "try-lock",
-]
+checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 
 [[package]]
-name = "wasi"
-version = "0.10.0+wasi-snapshot-preview1"
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
 
 [[package]]
-name = "wasm-bindgen"
-version = "0.2.82"
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc7652e3f6c4706c8d9cd54832c4a4ccb9b5336e2c3bd154d5cccfbf1c1f5f7d"
-dependencies = [
- "cfg-if 1.0.0",
- "serde",
- "serde_json",
- "wasm-bindgen-macro",
-]
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
 [[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.82"
+name = "windows_x86_64_gnullvm"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "662cd44805586bd52971b9586b1df85cdbbd9112e4ef4d8f41559c334dc6ac3f"
-dependencies = [
- "bumpalo",
- "log",
- "once_cell",
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-shared",
-]
+checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
 
 [[package]]
-name = "wasm-bindgen-futures"
-version = "0.4.25"
+name = "windows_x86_64_msvc"
+version = "0.42.2"
 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 = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 
 [[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.82"
+name = "windows_x86_64_msvc"
+version = "0.48.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b260f13d3012071dfb1512849c033b1925038373aea48ced3012c09df952c602"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
 
 [[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.82"
+name = "windows_x86_64_msvc"
+version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be8e654bdd9b79216c2929ab90721aa82faf65c48cdf08bdc4e7f51357b80da"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.82"
+name = "windows_x86_64_msvc"
+version = "0.53.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6598dd0bd3c7d51095ff6531a5b23e02acdc81804e30d8f07afb77b7215a140a"
+checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
 
 [[package]]
-name = "wasm-instrument"
-version = "0.2.0"
+name = "winnow"
+version = "0.5.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8bca81f5279342b38b17d9acbf007a46ddeb73144e2bd5f0a21bfa9fc5d4ab3e"
+checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876"
 dependencies = [
- "parity-wasm",
+ "memchr",
 ]
 
 [[package]]
-name = "wasmparser"
-version = "0.78.2"
+name = "winnow"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52144d4c78e5cf8b055ceab8e5fa22814ce4315d6002ad32cfd914f37c12fd65"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 
 [[package]]
-name = "wasmtime"
-version = "0.27.0"
+name = "winnow"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b310b9d20fcf59385761d1ade7a3ef06aecc380e3d3172035b919eaf7465d9f7"
+checksum = "a90e88e4667264a994d34e6d1ab2d26d398dcdca8b7f52bec8668957517fc7d8"
 dependencies = [
- "anyhow",
- "backtrace",
- "bincode",
- "cfg-if 1.0.0",
- "cpp_demangle",
- "indexmap",
- "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",
+ "memchr",
 ]
 
 [[package]]
-name = "wasmtime-cache"
-version = "0.27.0"
+name = "wiremock"
+version = "0.6.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d14d500d5c3dc5f5c097158feee123d64b3097f0d836a2a27dff9c761c73c843"
+checksum = "08db1edfb05d9b3c1542e521aea074442088292f00b5f28e435c714a98f85031"
 dependencies = [
- "anyhow",
- "base64 0.13.1",
- "bincode",
- "directories-next",
- "errno",
- "file-per-thread-logger",
- "libc",
+ "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",
- "sha2 0.9.5",
- "toml 0.5.11",
- "winapi",
- "zstd",
+ "serde_json",
+ "tokio",
+ "url",
 ]
 
 [[package]]
-name = "wasmtime-cranelift"
-version = "0.27.0"
+name = "wit-bindgen"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c525b39f062eada7db3c1298287b96dcb6e472b9f6b22501300b28d9fa7582f6"
+checksum = "d7249219f66ced02969388cf2bb044a09756a083d0fab1e566056b04d9fbcaa5"
 dependencies = [
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-frontend",
- "cranelift-wasm",
- "target-lexicon",
- "wasmparser",
- "wasmtime-environ",
+ "wit-bindgen-rust-macro",
 ]
 
 [[package]]
-name = "wasmtime-debug"
-version = "0.27.0"
+name = "wit-bindgen-core"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5d2a763e7a6fc734218e0e463196762a4f409c483063d81e0e85f96343b2e0a"
+checksum = "ea61de684c3ea68cb082b7a88508a8b27fcc8b797d738bfc99a82facf1d752dc"
 dependencies = [
  "anyhow",
- "gimli 0.24.0",
- "more-asserts",
- "object 0.24.0",
- "target-lexicon",
- "thiserror",
- "wasmparser",
- "wasmtime-environ",
+ "heck 0.5.0",
+ "wit-parser 0.244.0",
 ]
 
 [[package]]
-name = "wasmtime-environ"
-version = "0.27.0"
+name = "wit-bindgen-rt"
+version = "0.33.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f64d0c2d881c31b0d65c1f2695e022d71eb60b9fbdd336aacca28208b58eac90"
+checksum = "3268f3d866458b787f390cf61f4bbb563b922d091359f9608842999eaee3943c"
 dependencies = [
- "cfg-if 1.0.0",
- "cranelift-codegen",
- "cranelift-entity",
- "cranelift-wasm",
- "gimli 0.24.0",
- "indexmap",
- "log",
- "more-asserts",
- "serde",
- "thiserror",
- "wasmparser",
+ "bitflags 2.11.1",
 ]
 
 [[package]]
-name = "wasmtime-fiber"
-version = "0.27.0"
+name = "wit-bindgen-rust"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a089d44cd7e2465d41a53b840a5b4fca1bf6d1ecfebc970eac9592b34ea5f0b3"
+checksum = "b7c566e0f4b284dd6561c786d9cb0142da491f46a9fbed79ea69cdad5db17f21"
 dependencies = [
- "cc",
- "libc",
- "winapi",
+ "anyhow",
+ "heck 0.5.0",
+ "indexmap 2.14.0",
+ "prettyplease",
+ "syn 2.0.118",
+ "wasm-metadata",
+ "wit-bindgen-core",
+ "wit-component",
 ]
 
 [[package]]
-name = "wasmtime-jit"
-version = "0.27.0"
+name = "wit-bindgen-rust-macro"
+version = "0.51.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d4539ea734422b7c868107e2187d7746d8affbcaa71916d72639f53757ad707"
+checksum = "0c0f9bfd77e6a48eccf51359e3ae77140a7f50b1e2ebfe62422d8afdaffab17a"
 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",
+ "prettyplease",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "wit-bindgen-core",
+ "wit-bindgen-rust",
 ]
 
 [[package]]
-name = "wasmtime-obj"
-version = "0.27.0"
+name = "wit-component"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e1a8ff85246d091828e2225af521a6208ed28c997bb5c39eb697366dc2e2f2b"
+checksum = "9d66ea20e9553b30172b5e831994e35fbde2d165325bec84fc43dbf6f4eb9cb2"
 dependencies = [
  "anyhow",
- "more-asserts",
- "object 0.24.0",
- "target-lexicon",
- "wasmtime-debug",
- "wasmtime-environ",
+ "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 = "wasmtime-profiling"
-version = "0.27.0"
+name = "wit-parser"
+version = "0.244.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e24364d522dcd67c897c8fffc42e5bdfc57207bbb6d7eeade0da9d4a7d70105b"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
 dependencies = [
  "anyhow",
- "cfg-if 1.0.0",
- "gimli 0.24.0",
- "lazy_static",
- "libc",
- "object 0.24.0",
- "scroll",
+ "id-arena",
+ "indexmap 2.14.0",
+ "log",
+ "semver 1.0.28",
  "serde",
- "target-lexicon",
- "wasmtime-environ",
- "wasmtime-runtime",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.244.0",
 ]
 
 [[package]]
-name = "wasmtime-runtime"
-version = "0.27.0"
+name = "wit-parser"
+version = "0.251.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c51e57976e8a19a18a18e002c6eb12e5769554204238e47ff155fda1809ef0f7"
+checksum = "e960732e824fab95099971a09e638979347c94ca48568d3c854c945729196947"
 dependencies = [
  "anyhow",
- "backtrace",
- "cc",
- "cfg-if 1.0.0",
- "indexmap",
- "lazy_static",
- "libc",
+ "hashbrown 0.17.0",
+ "id-arena",
+ "indexmap 2.14.0",
  "log",
- "mach",
- "memoffset",
- "more-asserts",
- "rand",
- "region",
- "thiserror",
- "wasmtime-environ",
- "wasmtime-fiber",
- "winapi",
+ "semver 1.0.28",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "unicode-xid",
+ "wasmparser 0.251.0",
 ]
 
 [[package]]
-name = "wast"
-version = "37.0.0"
+name = "write16"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bc7b9a76845047ded00e031754ff410afee0d50fbdf62b55bdeecd245063d68"
-dependencies = [
- "leb128",
-]
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
 
 [[package]]
-name = "wat"
-version = "1.0.39"
+name = "writeable"
+version = "0.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ab2cc8d9a69d1ab28a41d9149bb06bb927aba8fc9d56625f8b597a564c83f50"
-dependencies = [
- "wast",
-]
+checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
 
 [[package]]
-name = "web-sys"
-version = "0.3.52"
+name = "ws_stream_wasm"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01c70a82d842c9979078c772d4a1344685045f1a5628f677c2b2eab4dd7d2696"
+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 = "web3"
-version = "0.19.0-graph"
-source = "git+https://github.com/graphprotocol/rust-web3?branch=graph-patches-onto-0.18#7f8eb6dfcc13a4186f9b42f91de950646bc4a833"
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
 dependencies = [
- "arrayvec 0.7.2",
- "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",
+ "tap",
 ]
 
 [[package]]
-name = "web3-async-native-tls"
-version = "0.4.0"
+name = "xxhash-rust"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f6d8d1636b2627fe63518d5a9b38a569405d9c9bc665c43c9c341de57227ebb"
-dependencies = [
- "native-tls",
- "thiserror",
- "tokio",
- "url",
-]
+checksum = "63658493314859b4dfdf3fb8c1defd61587839def09582db50b8a4e93afca6bb"
 
 [[package]]
-name = "webpki"
-version = "0.22.0"
+name = "yansi"
+version = "1.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f095d78192e208183081cc07bc5515ef55216397af48b873e5edcd72637fa1bd"
-dependencies = [
- "ring",
- "untrusted",
-]
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
 
 [[package]]
-name = "which"
-version = "4.2.2"
+name = "yoke"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea187a8ef279bc014ec368c27a920da2024d2a711109bfbe3440585d5cf27ad9"
+checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
 dependencies = [
- "either",
- "lazy_static",
- "libc",
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
 ]
 
 [[package]]
-name = "winapi"
-version = "0.3.9"
+name = "yoke-derive"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
 dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "synstructure",
 ]
 
 [[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-util"
-version = "0.1.5"
+name = "zerocopy"
+version = "0.8.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
+checksum = "668f5168d10b9ee831de31933dc111a459c97ec93225beb307aed970d1372dfd"
 dependencies = [
- "winapi",
+ "zerocopy-derive",
 ]
 
 [[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "windows-sys"
-version = "0.32.0"
+name = "zerocopy-derive"
+version = "0.8.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3df6e476185f92a12c072be4a189a0210dcdcf512a1891d6dff9edb874deadc6"
+checksum = "2c7962b26b0a8685668b671ee4b54d007a67d4eaf05fda79ac0ecf41e32270f1"
 dependencies = [
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_msvc",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "windows_aarch64_msvc"
-version = "0.32.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8e92753b1c443191654ec532f14c199742964a061be25d77d7a96f09db20bf5"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.32.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a711c68811799e017b6038e0922cb27a5e2f43a2ddb609fe0b6f3eeda9de615"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.32.0"
+name = "zerofrom"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "146c11bb1a02615db74680b32a68e2d61f553cc24c4eb5b4ca10311740e44172"
+checksum = "50cc42e0333e05660c3587f3bf9d0478688e15d870fab3346451ce7f8c9fbea5"
+dependencies = [
+ "zerofrom-derive",
+]
 
 [[package]]
-name = "windows_x86_64_gnu"
-version = "0.32.0"
+name = "zerofrom-derive"
+version = "0.1.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c912b12f7454c6620635bbff3450962753834be2a594819bd5e945af18ec64bc"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+ "synstructure",
+]
 
 [[package]]
-name = "windows_x86_64_msvc"
-version = "0.32.0"
+name = "zeroize"
+version = "1.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "504a2476202769977a040c6364301a3f65d0cc9e3fb08600b2bda150a0488316"
+checksum = "ced3678a2879b30306d323f4542626697a464a97c0a07c9aebf7ebca65cd4dde"
+dependencies = [
+ "zeroize_derive",
+]
 
 [[package]]
-name = "winreg"
-version = "0.7.0"
+name = "zeroize_derive"
+version = "1.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0120db82e8a1e0b9fb3345a539c478767c0048d842860994d96113d5b667bd69"
+checksum = "85a5b4158499876c763cb03bc4e49185d3cccbabb15b33c627f7884f43db852e"
 dependencies = [
- "winapi",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
 ]
 
 [[package]]
-name = "wyz"
-version = "0.5.0"
+name = "zerovec"
+version = "0.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30b31594f29d27036c383b53b59ed3476874d518f0efb151b27a4c275141390e"
+checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
 dependencies = [
- "tap",
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
 ]
 
 [[package]]
-name = "xxhash-rust"
-version = "0.8.5"
+name = "zerovec-derive"
+version = "0.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "074914ea4eec286eb8d1fd745768504f420a1f7b7919185682a4a267bed7d2e7"
+checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.118",
+]
 
 [[package]]
-name = "yaml-rust"
-version = "0.4.5"
+name = "zlib-rs"
+version = "0.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
-dependencies = [
- "linked-hash-map",
-]
+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 1808e6f3f5b..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",
-    "mock",
     "node",
-    "runtime/*",
-    "server/*",
-    "store/*",
+    "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.30.0"
-edition = "2021"
+version = "0.45.0"
+edition = "2024"
 authors = ["The Graph core developers & contributors"]
 readme = "README.md"
 homepage = "https://thegraph.com"
@@ -22,14 +35,107 @@ repository = "https://github.com/graphprotocol/graph-node"
 license = "MIT OR Apache-2.0"
 
 [workspace.dependencies]
-prost = "0.11.6"
-prost-types = "0.11.6"
-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]
+opt-level = 's'
+strip = "debuginfo"
diff --git a/FUNDING.json b/FUNDING.json
new file mode 100644
index 00000000000..273d2cfb684
--- /dev/null
+++ b/FUNDING.json
@@ -0,0 +1,7 @@
+{
+  "drips": {
+    "ethereum": {
+      "ownedBy": "0x7630586acda59C53e6b1421B7e097512B74C5236"
+    }
+  }
+}
diff --git a/NEWS.md b/NEWS.md
index bec220e7112..8068ecbc9fa 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,6 +1,772 @@
 # 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
+
+- **Substreams as Source of Triggers for Subgraphs** - This update significantly enhances subgraph functionality by enabling substreams to act as a source of triggers for running subgraph mappings. Developers can now directly run subgraph mappings on the data output from substreams, facilitating a more integrated and efficient workflow.[(#4887)](https://github.com/graphprotocol/graph-node/pull/4887) [(#4916)](https://github.com/graphprotocol/graph-node/pull/4916)
+- **`indexerHints` in Manifest for Automated Pruning** - This update introduces the ability for subgraph authors to specify `indexerHints` with a field `prune` in their manifest, indicating the desired extent of historical block data retention. This feature enables graph-node to automatically prune subgraphs when the stored history exceeds the specified limit, significantly improving query performance. This automated process eliminates the need for manual action by indexers for each subgraph. Indexers can also override user-set historyBlocks with the environment variable `GRAPH_HISTORY_BLOCKS_OVERRIDE` [(#5032](https://github.com/graphprotocol/graph-node/pull/5032) [(#5117)](https://github.com/graphprotocol/graph-node/pull/5117)
+- **Initial Starknet Support** - Introducing initial Starknet support for graph-node, expanding indexing capabilities to the Starknet ecosystem. The current integration is in its early stages, with notable areas for development including the implementation of trigger filters and data source template support. Future updates will also bring substream support. [(#4895)](https://github.com/graphprotocol/graph-node/pull/4895)
+- **`endBlock` Feature in Data Sources** - This update adds the `endBlock` field for dataSources in subgraph manifest. By setting an `endBlock`, subgraph authors can define the exact block at which a data source will cease processing, ensuring no further triggers are processed beyond this point. [(#4787](https://github.com/graphprotocol/graph-node/pull/4787)
+- **Autogenerated `Int8` IDs in graph-node** - Introduced support for using `Int8` as the ID type for entities, with the added capability to auto-generate these IDs, enhancing flexibility and functionality in entity management. [(#5029)](https://github.com/graphprotocol/graph-node/pull/5029)
+- **GraphiQL V2 Update** - Updated GraphiQL query interface of graph-node to version 2. [(#4677)](https://github.com/graphprotocol/graph-node/pull/4677)
+- **Sharding Guide for Graph-Node** - A new guide has been added to graph-node documentation, explaining how to scale graph-node installations using sharding with multiple Postgres instances. [Sharding Guide](https://github.com/graphprotocol/graph-node/blob/master/docs/sharding.md)
+- Per-chain polling interval configuration for RPC Block Ingestors [(#5066)](https://github.com/graphprotocol/graph-node/pull/5066)
+- Metrics Enhancements[(#5055)](https://github.com/graphprotocol/graph-node/pull/5055) [(#4937)](https://github.com/graphprotocol/graph-node/pull/4937)
+- graph-node now avoids creating GIN indexes on array attributes to enhance database write performance, addressing the issue of expensive updates and underutilization in queries. [(#4933)](https://github.com/graphprotocol/graph-node/pull/4933)
+- The `subgraphFeatures` endpoint in graph-node has been updated to load features from subgraphs prior to their deployment. [(#4864)](https://github.com/graphprotocol/graph-node/pull/4864)
+- Improved log filtering performance in blockstream. [(#5015)](https://github.com/graphprotocol/graph-node/pull/5015)
+- Enhanced GraphQL error reporting by including `__schema` and `__type` fields in the results during indexing errors [(#4968)](https://github.com/graphprotocol/graph-node/pull/4968)
+
+### Bug fixes
+
+- 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)
+- 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)
+- Fixed a bug in graphman's index creation to ensure entire String and Bytes columns are indexed rather than just their prefixes, resulting in optimized query performance and accuracy. [(#4995)](https://github.com/graphprotocol/graph-node/pull/4995)
+- Adjusted `SubstreamsBlockIngestor` to initiate at the chain's head block instead of starting at block zero when no cursor exists. [(#4951)](https://github.com/graphprotocol/graph-node/pull/4951)
+- Fixed a bug that caused incorrect progress reporting when copying subgraphs, ensuring accurate status updates. [(#5075)](https://github.com/graphprotocol/graph-node/pull/5075)
+
+
+### Graphman
+
+- **Graphman Deploy Command** - A new `graphman deploy` command has been introduced, simplifying the process of deploying subgraphs to graph-node. [(#4930)](https://github.com/graphprotocol/graph-node/pull/4930)
+
+<!--
+- Enhanced data integrity by making it impossible to construct an `InputSchema` that does not validate. [PR#4899](https://github.com/graphprotocol/graph-node/pull/4899)
+- Enhanced efficiency by optimizing `cached_head_ptr` calls within the process block. [PR#4978](https://github.com/graphprotocol/graph-node/pull/4978)
+- Enabled rewinding past the graft block in graphman, enhancing flexibility in data handling. [PR#5107](https://github.com/graphprotocol/graph-node/pull/5107)
+- **EntityType and Entity IDs Handling** - Improved clarity and safety in handling `EntityType` and entity ids. [(#4883](https://github.com/graphprotocol/graph-node/pull/4883)
+- fix(logs): Fix for ElasticSearch 8.X by @leoyvens in https://github.com/graphprotocol/graph-node/pull/5013
+
+* Allow querying subgraphs with more than one '/' in their name by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/4926
+* Log the progress of substreams by @zorancv in https://github.com/graphprotocol/graph-node/pull/4935
+- Add more labels to `deployment_sync_secs` by @zorancv in https://github.com/graphprotocol/graph-node/pull/4965
+* Label the specific method in eth_call metrics by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/5017
+* perf(store): Avoid the BRIN index for queries that filter by id by @leoyvens in https://github.com/graphprotocol/graph-node/pull/5010
+* Make `function not found` a deterministic by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/5038
+* Make ABI errors in `eth_call` deterministic by @YaroShkvorets in https://github.com/graphprotocol/graph-node/pull/5046
+
+* fix(runtime): improve error message for timeouts by @leoyvens in https://github.com/graphprotocol/graph-node/pull/4686
+* docker: upgrade cloudbuild machineType by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/4939
+* Fix issues in runner tests by @leoyvens in https://github.com/graphprotocol/graph-node/pull/4962
+* Test more types for DataSource context in manifest by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/4897
+* Metrics for DIPS experiments by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/4940
+* Rewrite integration tests by @lutter in https://github.com/graphprotocol/graph-node/pull/4950
+* runner tests: Do not clobber api-version tests by @lutter in https://github.com/graphprotocol/graph-node/pull/4983
+* Fix graphman not accepting table names by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/4980
+* docs: fix typos by @vuittont60 in https://github.com/graphprotocol/graph-node/pull/4944
+* docs: Fix typos by @lutter in https://github.com/graphprotocol/graph-node/pull/4997
+* refactor: Modernize a few util::futures tests by @leoyvens in https://github.com/graphprotocol/graph-node/pull/5009
+* test: allow integration tests to run with different version of the `graph` cli by @dotansimha in https://github.com/graphprotocol/graph-node/pull/5037
+* Fix typo at sharding.md by @rootwarp in https://github.com/graphprotocol/graph-node/pull/5048
+* graph: Speed up some of the futures tests by @lutter in https://github.com/graphprotocol/graph-node/pull/5056
+* fix(graphql): change CDN to JS Deliver for GraphiQL by @saihaj in https://github.com/graphprotocol/graph-node/pull/4941
+* fix(tests): yarn workspace to install all subfolders by @saihaj in https://github.com/graphprotocol/graph-node/pull/4957
+* fix(graphql): add crossorigin prop by @saihaj in https://github.com/graphprotocol/graph-node/pull/4948
+* runner tests: Tag all log lines with the test name by @lutter in https://github.com/graphprotocol/graph-node/pull/4986
+* tests: Make how long runner tests wait for sync configurable by @lutter in https://github.com/graphprotocol/graph-node/pull/4993
+* Add docker instruction on main Readme by @marc-aurele-besner in https://github.com/graphprotocol/graph-node/pull/5027
+* Update initialising database command for README.MD by @Umiiii in https://github.com/graphprotocol/graph-node/pull/5073
+* Update offchain.md by @leoyvens in https://github.com/graphprotocol/graph-node/pull/5033
+* Fix: substream datasources missing in TriggerFilter by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/5001
+* Create FUNDING.json by @azf20 in https://github.com/graphprotocol/graph-node/pull/5068
+* More `InputSchema` refactorings by @lutter in https://github.com/graphprotocol/graph-node/pull/4990
+
+* store: Use the internal block cache for ChainStore.blocks() by @lutter in https://github.com/graphprotocol/graph-node/pull/5050
+* graph: Exclude Self from ObjectType.share_interfaces() by @lutter in https://github.com/graphprotocol/graph-node/pull/5049
+* Add some tests for the recent blocks cache by @lutter in https://github.com/graphprotocol/graph-node/pull/5058
+* Add blocks loaded from the database to the recent blocks cache by @lutter in https://github.com/graphprotocol/graph-node/pull/5059
+* Make the RecentBlocksCache very dumb by @lutter in https://github.com/graphprotocol/graph-node/pull/5067
+* Make the recent blocks cache more effective for concurrent lookups by @lutter in https://github.com/graphprotocol/graph-node/pull/5076
+* core, graph, store: Do not use recent blocks cache for chain head by @lutter in https://github.com/graphprotocol/graph-node/pull/5081
+
+ -->
+
+**Full Changelog**: https://github.com/graphprotocol/graph-node/compare/v0.33.0...v0.34.0
+
+## v0.33.0
+
+### What's New
+
+- **Arweave file data sources** - Arweave file data sources allow subgraph developers to access offchain data from Arweave from within the subgraph mappings.[(#4789)](https://github.com/graphprotocol/graph-node/pull/4789)
+- **Major performance boost for substreams-based subgraphs** - Significant performance improvements have been achieved for substreams-based subgraphs by moving substreams processing to the block stream.[(#4851)](https://github.com/graphprotocol/graph-node/pull/4851)
+- **Polling block handler** - A new block handler filter `polling` for `ethereum` data sources which enables subgraph developers to run a block handler at defined block intervals. This is useful for use cases such as taking periodic snapshots of the contract state.[(#4725)](https://github.com/graphprotocol/graph-node/pull/4725)
+- **Initialization handler** - A new block handler filter `once` for `ethereum` data sources which enables subgraph developers to create a handler which will be called only once before all other handlers run. This configuration allows the subgraph to use the handler as an initialization handler, performing specific tasks at the start of indexing. [(#4725)](https://github.com/graphprotocol/graph-node/pull/4725)
+- **DataSourceContext in manifest** - `DataSourceContext` in Manifest - DataSourceContext can now be defined in the subgraph manifest. It's a free-form map accessible from the mapping. This feature is useful for templating chain-specific data in subgraphs that use the same codebase across multiple chains.[(#4848)](https://github.com/graphprotocol/graph-node/pull/4848)
+- `graph-node` version in index node API - The Index Node API now features a new query, Version, which can be used to query the current graph-node version and commit. [(#4852)](https://github.com/graphprotocol/graph-node/pull/4852)
+- Added a '`paused`' field to Index Node API, a boolean indicating the subgraph’s pause status. [(#4779)](https://github.com/graphprotocol/graph-node/pull/4779)
+- Proof of Indexing logs now include block number [(#4798)](https://github.com/graphprotocol/graph-node/pull/4798)
+- `subgraph_features` table now tracks details about handlers used in a subgraph [(#4820)](https://github.com/graphprotocol/graph-node/pull/4820)
+- Configurable SSL for Postgres in Dockerfile - ssl-mode for Postgres can now be configured via the connection string when deploying through Docker, offering enhanced flexibility in database security settings.[(#4840)](https://github.com/graphprotocol/graph-node/pull/4840)
+- Introspection Schema Update - The introspection schema has been updated to align with the October 2021 GraphQL specification update.[(#4676)](https://github.com/graphprotocol/graph-node/pull/4676)
+- `trace_id` Added to Substreams Logger [(#4868)](https://github.com/graphprotocol/graph-node/pull/4868)
+- New apiVersion for Mapping Validation - The latest apiVersion 0.0.8 validates that fields set in entities from the mappings are actually defined in the schema. This fixes a source of non-deterministic PoI. Subgraphs using this new API version will fail if they try to set undefined schema fields in the mappings. Its strongly recommended updating to 0.0.8 to avoid these issues. [(#4894)](https://github.com/graphprotocol/graph-node/pull/4894)
+- Substreams Block Ingestor Support - Added the ability to run a pure substreams chain by introducing a block ingestor for substreams-only chains. This feature allows users to run a chain with just a single substreams endpoint, enhancing support beyond RPC and firehose. Prior to this, a pure substreams chain couldn’t be synced.[(#4839)](https://github.com/graphprotocol/graph-node/pull/4839)
+
+### Bug fixes
+
+- Fix for rewinding dynamic data source - Resolved an issue where a rewind would fail to properly remove dynamic data sources when using `graphman rewind`. This has been fixed to ensure correct behavior.[(#4810)](https://github.com/graphprotocol/graph-node/pull/4810)
+- Improved Deployment Reliability with Retry Mechanism - A retry feature has been added to the block_pointer_from_number function to enhance the robustness of subgraph deployments. This resolves occasional failures encountered during deployment processes.[(#4812)](https://github.com/graphprotocol/graph-node/pull/4812)
+- Fixed Cross-Shard Grafting Issue - Addressed a bug that prevented cross-shard grafting from starting, causing the copy operation to stall at 0% progress. This issue occurred when a new shard was added after the primary shard had already been configured. The fix ensures that foreign tables and schemas are correctly set up in new shards. For existing installations experiencing this issue, it can be resolved by running `graphman database remap`.[(#4845)](https://github.com/graphprotocol/graph-node/pull/4845)
+- Fixed a Full-text search regression - Reverted a previous commit (ad1c6ea) that inadvertently limited the number of populated search indexes per entity.[(#4808)](https://github.com/graphprotocol/graph-node/pull/4808)
+- Attestable Error for Nested Child Filters - Nested child filter queries now return an attestable `ChildFilterNestingNotSupportedError`, improving error reporting for users.[(#4828)](https://github.com/graphprotocol/graph-node/pull/4828)
+
+### Graphman
+
+- **Index on prefixed fields** - The graphman index create command now correctly indexes prefixed fields of type String and Bytes for more query-efficient combined indexes. Note: For fields that are references to entities, the behavior may differ. The command may create an index using left(..) when it should index the column directly.
+- **Partial Indexing for Recent Blocks** - The graphman index create command now includes a `--after $recent_block` flag for creating partial indexes focused on recent blocks. This enhances query performance similar to the effects of pruning. Queries using these partial indexes must include a specific clause for optimal performance.[(#4830)](https://github.com/graphprotocol/graph-node/pull/4830)
+
+<!--
+Not Relevant
+* Changes the spelling of History from Hostory by @vishal-sys in https://github.com/graphprotocol/graph-node/pull/4846
+* Test coverage for bundlr manifest + filename use case by @mangas in https://github.com/graphprotocol/graph-node/pull/4865
+* Revert most of PR 4827 by @lutter in https://github.com/graphprotocol/graph-node/pull/4860
+* Pass polling triggers only after start_block by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/4881
+* Remove the entry from `subgraph_features` table when a subgraph is removed by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/4811
+* Update docker-compose.yml by @computeronix in https://github.com/graphprotocol/graph-node/pull/4844
+ -->
+
+**Full Changelog**: https://github.com/graphprotocol/graph-node/compare/v0.33.0...e253ee14cda2d8456a86ae8f4e3f74a1a7979953
+
+## v0.32.0
+
+### What's New
+
+- **Derived fields getter**: Derived fields can now be accessed from within the mapping code during indexing. ([#4434](https://github.com/graphprotocol/graph-node/pull/4434))
+- **Sorting interfaces by child entity**: Interfaces can now be sorted by non-derived child entities. ([#4058](https://github.com/graphprotocol/graph-node/pull/4058))
+- **File data sources can now be spawned from handlers of other file data sources**: This enables the use of file data sources for scenarios where a file data source needs to be spawned from another one. One practical application of this feature is in handling NFT metadata. In such cases, the metadata itself is stored as a file on IPFS and contains embedded IPFS CID for the actual file for the NFT. ([#4713](https://github.com/graphprotocol/graph-node/pull/4713))
+- Allow redeployment of grafted subgraphs even when graft_base is not available: This will allow renaming of already synced grafted subgraphs even when the graft base is not available, which previously failed due to `graft-base` validation errors. ([#4695](https://github.com/graphprotocol/graph-node/pull/4695))
+- `history_blocks` is now available in the index-node API. ([#4662](https://github.com/graphprotocol/graph-node/pull/4662))
+- Added a new `subgraph features` table in `primary` to easily track information like `apiVersion`, `specVersion`, `features`, and data source kinds used by subgraphs. ([#4679](https://github.com/graphprotocol/graph-node/pull/4679))
+- `subgraphFeatures` endpoint now includes data from `subgraph_features` table.
+- `ens_name_by_hash` is now undeprecated: This reintroduces support for fetching ENS names by their hash, dependent on the availability of the underlying [Rainbow Table](https://github.com/graphprotocol/ens-rainbow) ([#4751](https://github.com/graphprotocol/graph-node/pull/4751)).
+- Deterministically failed subgraphs now return valid POIs for subsequent blocks after the block at which it failed. ([#4774](https://github.com/graphprotocol/graph-node/pull/4774))
+- `eth-call` logs now include block hash and block number: This enables easier debugging of eth-call issues. ([#4718](https://github.com/graphprotocol/graph-node/pull/4718))
+- Enabled support for substreams on already supported networks. ([#4767](https://github.com/graphprotocol/graph-node/pull/4767))
+- Add new GraphQL scalar type `Int8`. This new scalar type allows subgraph developers to represent 8-bit signed integers. ([#4511](https://github.com/graphprotocol/graph-node/pull/4511))
+- Add support for overriding module params for substreams-based subgraphs when params are provided in the subgraph manifest. ([#4759](https://github.com/graphprotocol/graph-node/pull/4759))
+
+### Breaking changes
+
+- Duplicate provider labels are not allowed in graph-node config anymore
+
+### Bug fixes
+
+- Fixed `PublicProofsOfIndexing` returning the error `Null value resolved for non-null field proofOfIndexing` when fetching POIs for blocks that are not in the cache ([#4768](https://github.com/graphprotocol/graph-node/pull/4768))
+- Fixed an issue where Block stream would fail when switching back to an RPC-based block ingestor from a Firehose ingestor. ([#4790](https://github.com/graphprotocol/graph-node/pull/4790))
+- Fixed an issue where derived loaders were not working with entities with Bytes as IDs ([#4773](https://github.com/graphprotocol/graph-node/pull/4773))
+- Firehose connection test now retries for 30 secs before setting the provider status to `Broken` ([#4754](https://github.com/graphprotocol/graph-node/pull/4754))
+- Fixed the `nonFatalErrors` field not populating in the index node API. ([#4615](https://github.com/graphprotocol/graph-node/pull/4615))
+- Fixed `graph-node` panicking on the first startup when both Firehose and RPC providers are configured together. ([#4680](https://github.com/graphprotocol/graph-node/pull/4680))
+- Fixed block ingestor failing to startup with the error `net version for chain mainnet has changed from 0 to 1` when switching from Firehose to an RPC provider. ([#4692](https://github.com/graphprotocol/graph-node/pull/4692))
+- Fixed Firehose endpoints getting rate-limited due to duplicated providers during connection pool initialization. ([#4778](https://github.com/graphprotocol/graph-node/pull/4778))
+- Fixed a determinism issue where stale entities were being returned when using `get_many` and `get_derived` ([#4801]https://github.com/graphprotocol/graph-node/pull/4801)
+
+### Graphman
+
+- Added two new `graphman` commands `pause` and `resume`: Instead of reassigning to a non-existent node these commands can now be used for pausing and resuming subgraphs. ([#4642](https://github.com/graphprotocol/graph-node/pull/4642))
+- Added a new `graphman` command `restart` to restart a subgraph. ([#4742](https://github.com/graphprotocol/graph-node/pull/4742))
+
+**Full Changelog**: https://github.com/graphprotocol/graph-node/compare/v0.31.0...c350e4f35c49bcf8a8b521851f790234ba2c0295
+
+<!--
+Not Relevant
+- Fix subgraph_features migration. ([#4717](https://github.com/graphprotocol/graph-node/pull/4717))
+- Fix(graphman): Increase default sleep after stopping sg. ([#4703](https://github.com/graphprotocol/graph-node/pull/4703))
+- Fix derived loader not working on certain fields. ([#4683](https://github.com/graphprotocol/graph-node/pull/4683))
+- Firehose/substreams: add 'bearer' in authorization field. ([#4714](https://github.com/graphprotocol/graph-node/pull/4714))
+- Reduce CI flakiness: disable TCP checksum offloading by @neysofu in https://github.com/graphprotocol/graph-node/pull/4684
+- env: Decrease default GRAPH_MAX_IPFS_FILE_BYTES by @leoyvens in https://github.com/graphprotocol/graph-node/pull/4669
+- add a retry(5) when refetch_firehose_block fails by @sduchesneau in https://github.com/graphprotocol/graph-node/pull/4681
+- Reset block stream only when there is onchain datasource created by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/4700
+- Fix nightly code coverage run by @neysofu in https://github.com/graphprotocol/graph-node/pull/4685
+- Move create_subgraph_features to build_subgraph_runner by @incrypto32 in https://github.com/graphprotocol/graph-node/pull/4699
+- Revert "delete 'shallow blocks' in block cache when not using firehose (#4691)" by @leoyvens in https://github.com/graphprotocol/graph-node/pull/4752
+- Docs: Add offchain data sources implementation guide. ([#4696](https://github.com/graphprotocol/graph-node/pull/4696))
+ -->
+
+## v0.31.0
+
+### What's new
+
+- **Fulltext searches can now be combined with `where` filtering**, further narrowing down search results. [#4442](https://github.com/graphprotocol/graph-node/pull/4442)
+- Tweaked how RPC provider limiting rules are interpreted from configurations. In particular, node IDs that don't match any rules of a provider won't have access to said provider instead of having access to it for an unlimited number of subgraphs. Read the [docs](https://github.com/graphprotocol/graph-node/pull/4353/files) for more information. [#4353](https://github.com/graphprotocol/graph-node/pull/4353)
+- Introduced WASM host function `store.get_in_block`, which is a much faster variant of `store.get` limited to entities created or updated in the current block. [#4540](https://github.com/graphprotocol/graph-node/pull/4540)
+- The entity cache that `graph-node` keeps around is much more efficient, meaning more cache entries fit in the same amount of memory resulting in a performance increase under a wide range of workloads. [#4485](https://github.com/graphprotocol/graph-node/pull/4485)
+- The `subgraph_deploy` JSON-RPC method now accepts a `history_blocks` parameter, which indexers can use to set default amounts of history to keep. [#4564](https://github.com/graphprotocol/graph-node/pull/4564)
+- IPFS requests for polling file data sources are not throttled anymore (also known as concurrency or burst limiting), only rate-limited. [#4570](https://github.com/graphprotocol/graph-node/pull/4570)
+- Exponential requests backoff when retrying failed subgraphs is now "jittered", smoothing out request spikes. [#4476](https://github.com/graphprotocol/graph-node/pull/4476)
+- RPC provider responses that decrease the chain head block number (non-monotonic) are now ignored, increasing resiliency against inconsistent provider data. [#4354](https://github.com/graphprotocol/graph-node/pull/4354)
+- It's now possible to to have a Firehose-only chain with no RPC provider at all in the configuration. [#4508](https://github.com/graphprotocol/graph-node/pull/4508), [#4553](https://github.com/graphprotocol/graph-node/pull/4553)
+- The materialized views in the `info` schema (`table_sizes`, `subgraph_sizes`, and `chain_sizes`) that provide information about the size of various database objects are now automatically refreshed every 6 hours. [#4461](https://github.com/graphprotocol/graph-node/pull/4461)
+- Adapter selection now takes error rates into account, preferring adapters with lower error rates. [#4468](https://github.com/graphprotocol/graph-node/pull/4468)
+- The substreams protocol has been updated to `sf.substreams.rpc.v2.Stream/Blocks`. [#4556](https://github.com/graphprotocol/graph-node/pull/4556)
+- Removed support for `GRAPH_ETHEREUM_IS_FIREHOSE_PREFERRED`, `REVERSIBLE_ORDER_BY_OFF`, and `GRAPH_STORE_CONNECTION_TRY_ALWAYS` env. variables. [#4375](https://github.om/graphprotocol/graph-node/pull/4375), [#4436](https://github.com/graphprotocol/graph-node/pull/4436)
+
+### Bug fixes
+
+- Fixed a bug that would cause subgraphs to fail with a `subgraph writer poisoned by previous error` message following certain database errors. [#4533](https://github.com/graphprotocol/graph-node/pull/4533)
+- Fixed a bug that would cause subgraphs to fail with a `store error: no connection to the server` message when database connection e.g. gets killed. [#4435](https://github.com/graphprotocol/graph-node/pull/4435)
+- The `subgraph_reassign` JSON-RPC method doesn't fail anymore when multiple deployment copies are found: only the active copy is reassigned, the others are ignored. [#4395](https://github.com/graphprotocol/graph-node/pull/4395)
+- Fixed a bug that would cause `on_sync` handlers on copied deployments to fail with the message `Subgraph instance failed to run: deployment not found [...]`. [#4396](https://github.com/graphprotocol/graph-node/pull/4396)
+- Fixed a bug that would cause the copying or grafting of a subgraph while pruning it to incorrectly set `earliest_block` in the destination deployment. [#4502](https://github.com/graphprotocol/graph-node/pull/4502)
+- Handler timeouts would sometimes be reported as deterministic errors with the error message `Subgraph instance failed to run: Failed to call 'asc_type_id' with [...] wasm backtrace [...]`; this error is now nondeterministic and recoverable. [#4475](https://github.com/graphprotocol/graph-node/pull/4475)
+- Fixed faulty exponential request backoff behavior after many minutes of failed requests, caused by an overflow. [#4421](https://github.com/graphprotocol/graph-node/pull/4421)
+- `json.fromBytes` and all `BigInt` operations now require more gas, protecting against malicious subgraphs. [#4594](https://github.com/graphprotocol/graph-node/pull/4594), [#4595](https://github.com/graphprotocol/graph-node/pull/4595)
+- Fixed faulty `startBlock` selection logic in substreams. [#4463](https://github.com/graphprotocol/graph-node/pull/4463)
+
+### Graphman
+
+- The behavior for `graphman prune` has changed: running just `graphman prune` will mark the subgraph for ongoing pruning in addition to performing an initial pruning. To avoid ongoing pruning, use `graphman prune --once` ([docs](./docs/implementation/pruning.md)). [#4429](https://github.com/graphprotocol/graph-node/pull/4429)
+- The env. var. `GRAPH_STORE_HISTORY_COPY_THRESHOLD` –which serves as a configuration setting for `graphman prune`– has been renamed to `GRAPH_STORE_HISTORY_REBUILD_THRESHOLD`. [#4505](https://github.com/graphprotocol/graph-node/pull/4505)
+- You can now list all existing deployments via `graphman info --all`. [#4347](https://github.com/graphprotocol/graph-node/pull/4347)
+- The command `graphman chain call-cache remove` now requires `--remove-entire-cache` as an explicit flag, protecting against accidental destructive command invocations. [#4397](https://github.com/graphprotocol/graph-node/pull/4397)
+- `graphman copy create` accepts two new flags, `--activate` and `--replace`, which make moving of subgraphs across shards much easier. [#4374](https://github.com/graphprotocol/graph-node/pull/4374)
+- The log level for `graphman` is now set via `GRAPHMAN_LOG` or command line instead of `GRAPH_LOG`. [#4462](https://github.com/graphprotocol/graph-node/pull/4462)
+- `graphman reassign` now emits a warning when it suspects a typo in node IDs. [#4377](https://github.com/graphprotocol/graph-node/pull/4377)
+
+### Metrics and logging
+
+- Subgraph syncing time metric `deployment_sync_secs` now stops updating once the subgraph has synced. [#4489](https://github.com/graphprotocol/graph-node/pull/4489)
+- New `endpoint_request` metric to track error rates of different providers. [#4490](https://github.com/graphprotocol/graph-node/pull/4490), [#4504](https://github.com/graphprotocol/graph-node/pull/4504), [#4430](https://github.com/graphprotocol/graph-node/pull/4430)
+- New metrics `chain_head_cache_num_blocks`, `chain_head_cache_oldest_block`, `chain_head_cache_latest_block`, `chain_head_cache_hits`, and `chain_head_cache_misses` to monitor the effectiveness of `graph-node`'s in-memory chain head caches. [#4440](https://github.com/graphprotocol/graph-node/pull/4440)
+- The subgraph error message `store error: Failed to remove entities` is now more detailed and contains more useful information. [#4367](https://github.com/graphprotocol/graph-node/pull/4367)
+- `eth_call` logs now include the provider string. [#4548](https://github.com/graphprotocol/graph-node/pull/4548)
+- Tweaks and small changes to log messages when resolving data sources, mappings, and manifests. [#4399](https://github.com/graphprotocol/graph-node/pull/4399)
+- `FirehoseBlockStream` and `FirehoseBlockIngestor` now log adapter names. [#4411](https://github.com/graphprotocol/graph-node/pull/4411)
+- The `deployment_count` metric has been split into `deployment_running_count` and `deployment_count`. [#4401](https://github.com/grahprotocol/graph-node/pull/4401), [#4398](https://github.com/graphprotocol/graph-node/pul/4398)
+
+<!--
+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://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
+-->
+
+**Full Changelog**: https://github.com/graphprotocol/graph-node/compare/v0.30.0...aa6677a38
 
 ## v0.30.0
 
@@ -22,7 +788,7 @@ New `graph-node` installations now **mandate** PostgreSQL to use C locale and UT
 - Lots of visual and filtering improvements to [#4232](https://github.com/graphprotocol/graph-node/pull/4232)
 - More aggressive in-memory caching of blocks close the chain head, potentially alleviating database load. [#4215](https://github.com/graphprotocol/graph-node/pull/4215)
 - New counter Prometheus metric `query_validation_error_counter`, labelled by deployment ID and error code. [#4230](https://github.com/graphprotocol/graph-node/pull/4230)
-graph_elasticsearch_logs_sent
+  graph_elasticsearch_logs_sent
 - Turned "Flushing logs to Elasticsearch" log into a Prometheus metric (`graph_elasticsearch_logs_sent`) to reduce log noise. [#4333](https://github.com/graphprotocol/graph-node/pull/4333)
 - New materialized view `info.chain_sizes`, which works the same way as the already existing `info.subgraph_sizes` and `info.table_sizes`. [#4318](https://github.com/graphprotocol/graph-node/pull/4318)
 - New `graphman stats` subcommands `set-target` and `target` to manage statistics targets for specific deployments (i.e. how much data PostgreSQL samples when analyzing a table). [#4092](https://github.com/graphprotocol/graph-node/pull/4092)
@@ -87,15 +853,15 @@ Dependency upgrades:
 
   - `Qmccst5mbV5a6vT6VvJMLPKMAA1VRgT6NGbxkLL8eDRsE7`
   - `Qmd9nZKCH8UZU1pBzk7G8ECJr3jX3a2vAf3vowuTwFvrQg`
- 
-  Here's an example [manifest](https://ipfs.io/ipfs/Qmd9nZKCH8UZU1pBzk7G8ECJr3jX3a2vAf3vowuTwFvrQg), taking a look at the data sources of name `ERC721` and `CryptoKitties`, both listen to the `Transfer(...)` event. Considering a block where there's only one occurence of this event, `graph-node` would duplicate it and call `handleTransfer` twice. Now this is fixed and it will be called only once per event/call that happened on chain.
+
+  Here's an example [manifest](https://ipfs.io/ipfs/Qmd9nZKCH8UZU1pBzk7G8ECJr3jX3a2vAf3vowuTwFvrQg), taking a look at the data sources of name `ERC721` and `CryptoKitties`, both listen to the `Transfer(...)` event. Considering a block where there's only one occurrence of this event, `graph-node` would duplicate it and call `handleTransfer` twice. Now this is fixed and it will be called only once per event/call that happened on chain.
 
   In the case you're indexing one of the impacted subgraphs, you should first upgrade the `graph-node` version, then rewind the affected subgraphs to the smallest `startBlock` of their subgraph manifest. To achieve that the `graphman rewind` CLI command can be used.
 
   See [#4055](https://github.com/graphprotocol/graph-node/pull/4055) for more information.
 
 * This release fixes another determinism bug that affects a handful of subgraphs. The bug affects all subgraphs which have an `apiVersion` **older than** 0.0.5 using call handlers. While call handlers prior to 0.0.5 should be triggered by both failed and successful transactions, in some cases failed transactions would not trigger the handlers. This resulted in nondeterministic behavior. With this version of `graph-node`, call handlers with an `apiVersion` older than 0.0.5 will always be triggered by both successful and failed transactions. Behavior for `apiVersion` 0.0.5 onward is not affected.
-  
+
   The affected subgraphs are:
 
   - `QmNY7gDNXHECV8SXoEY7hbfg4BX1aDMxTBDiFuG4huaSGA`
@@ -111,41 +877,44 @@ Dependency upgrades:
 
 ### What's new
 
-* Grafted subgraphs can now add their own data sources. [#3989](https://github.com/graphprotocol/graph-node/pull/3989), [#4027](https://github.com/graphprotocol/graph-node/pull/4027), [#4030](https://github.com/graphprotocol/graph-node/pull/4030)
-* Add support for filtering by nested interfaces. [#3677](https://github.com/graphprotocol/graph-node/pull/3677)
-* Add support for message handlers in Cosmos [#3975](https://github.com/graphprotocol/graph-node/pull/3975)
-* Dynamic data sources for Firehose-backed subgraphs. [#4075](https://github.com/graphprotocol/graph-node/pull/4075)
-* Various logging improvements. [#4078](https://github.com/graphprotocol/graph-node/pull/4078), [#4084](https://github.com/graphprotocol/graph-node/pull/4084), [#4031](https://github.com/graphprotocol/graph-node/pull/4031), [#4144](https://github.com/graphprotocol/graph-node/pull/4144), [#3990](https://github.com/graphprotocol/graph-node/pull/3990)
-* Some DB queries now have GCP Cloud Insight -compliant tags that show where the query originated from. [#4079](https://github.com/graphprotocol/graph-node/pull/4079)
-* New configuration variable `GRAPH_STATIC_FILTERS_THRESHOLD` to conditionally enable static filtering based on the number of dynamic data sources. [#4008](https://github.com/graphprotocol/graph-node/pull/4008)
-* New configuration variable `GRAPH_STORE_BATCH_TARGET_DURATION`. [#4133](https://github.com/graphprotocol/graph-node/pull/4133)
+- Grafted subgraphs can now add their own data sources. [#3989](https://github.com/graphprotocol/graph-node/pull/3989), [#4027](https://github.com/graphprotocol/graph-node/pull/4027), [#4030](https://github.com/graphprotocol/graph-node/pull/4030)
+- Add support for filtering by nested interfaces. [#3677](https://github.com/graphprotocol/graph-node/pull/3677)
+- Add support for message handlers in Cosmos [#3975](https://github.com/graphprotocol/graph-node/pull/3975)
+- Dynamic data sources for Firehose-backed subgraphs. [#4075](https://github.com/graphprotocol/graph-node/pull/4075)
+- Various logging improvements. [#4078](https://github.com/graphprotocol/graph-node/pull/4078), [#4084](https://github.com/graphprotocol/graph-node/pull/4084), [#4031](https://github.com/graphprotocol/graph-node/pull/4031), [#4144](https://github.com/graphprotocol/graph-node/pull/4144), [#3990](https://github.com/graphprotocol/graph-node/pull/3990)
+- Some DB queries now have GCP Cloud Insight -compliant tags that show where the query originated from. [#4079](https://github.com/graphprotocol/graph-node/pull/4079)
+- New configuration variable `GRAPH_STATIC_FILTERS_THRESHOLD` to conditionally enable static filtering based on the number of dynamic data sources. [#4008](https://github.com/graphprotocol/graph-node/pull/4008)
+- New configuration variable `GRAPH_STORE_BATCH_TARGET_DURATION`. [#4133](https://github.com/graphprotocol/graph-node/pull/4133)
 
 #### Docker image
-* The official Docker image now runs on Debian 11 "Bullseye". [#4081](https://github.com/graphprotocol/graph-node/pull/4081)
-* We now ship [`envsubst`](https://github.com/a8m/envsubst) with the official Docker image, allowing you to easily run templating logic on your configuration files. [#3974](https://github.com/graphprotocol/graph-node/pull/3974)
+
+- The official Docker image now runs on Debian 11 "Bullseye". [#4081](https://github.com/graphprotocol/graph-node/pull/4081)
+- We now ship [`envsubst`](https://github.com/a8m/envsubst) with the official Docker image, allowing you to easily run templating logic on your configuration files. [#3974](https://github.com/graphprotocol/graph-node/pull/3974)
 
 #### Graphman
 
 We have a new documentation page for `graphman`, check it out [here](https://github.com/graphprotocol/graph-node/blob/2da697b1af17b1c947679d1b1a124628146545a6/docs/graphman.md)!
 
-* Subgraph pruning with `graphman`! [#3898](https://github.com/graphprotocol/graph-node/pull/3898), [#4125](https://github.com/graphprotocol/graph-node/pull/4125), [#4153](https://github.com/graphprotocol/graph-node/pull/4153), [#4152](https://github.com/graphprotocol/graph-node/pull/4152), [#4156](https://github.com/graphprotocol/graph-node/pull/4156), [#4041](https://github.com/graphprotocol/graph-node/pull/4041)
-* New command `graphman drop` to hastily delete a subgraph deployment. [#4035](https://github.com/graphprotocol/graph-node/pull/4035)
-* New command `graphman chain call-cache` for clearing the call cache for a given chain. [#4066](https://github.com/graphprotocol/graph-node/pull/4066)
-* Add `--delete-duplicates` flag to `graphman check-blocks` by @tilacog in https://github.com/graphprotocol/graph-node/pull/3988
+- Subgraph pruning with `graphman`! [#3898](https://github.com/graphprotocol/graph-node/pull/3898), [#4125](https://github.com/graphprotocol/graph-node/pull/4125), [#4153](https://github.com/graphprotocol/graph-node/pull/4153), [#4152](https://github.com/graphprotocol/graph-node/pull/4152), [#4156](https://github.com/graphprotocol/graph-node/pull/4156), [#4041](https://github.com/graphprotocol/graph-node/pull/4041)
+- New command `graphman drop` to hastily delete a subgraph deployment. [#4035](https://github.com/graphprotocol/graph-node/pull/4035)
+- New command `graphman chain call-cache` for clearing the call cache for a given chain. [#4066](https://github.com/graphprotocol/graph-node/pull/4066)
+- Add `--delete-duplicates` flag to `graphman check-blocks` by @tilacog in https://github.com/graphprotocol/graph-node/pull/3988
 
 #### Performance
-* Restarting a node now takes much less time because `postgres_fdw` user mappings are only rebuilt upon schema changes. If necessary, you can also use the new commands `graphman database migrate` and `graphman database remap` to respectively apply schema migrations or run remappings manually. [#4009](https://github.com/graphprotocol/graph-node/pull/4009), [#4076](https://github.com/graphprotocol/graph-node/pull/4076)
-* Database replicas now won't fall behind as much when copying subgraph data. [#3966](https://github.com/graphprotocol/graph-node/pull/3966) [#3986](https://github.com/graphprotocol/graph-node/pull/3986)
-* Block handlers optimization with Firehose >= 1.1.0. [#3971](https://github.com/graphprotocol/graph-node/pull/3971)
-* Reduced the amount of data that a non-primary shard has to mirror from the primary shard. [#4015](https://github.com/graphprotocol/graph-node/pull/4015)
-* We now use advisory locks to lock deployments' tables against concurrent writes. [#4010](https://github.com/graphprotocol/graph-node/pull/4010)
+
+- Restarting a node now takes much less time because `postgres_fdw` user mappings are only rebuilt upon schema changes. If necessary, you can also use the new commands `graphman database migrate` and `graphman database remap` to respectively apply schema migrations or run remappings manually. [#4009](https://github.com/graphprotocol/graph-node/pull/4009), [#4076](https://github.com/graphprotocol/graph-node/pull/4076)
+- Database replicas now won't fall behind as much when copying subgraph data. [#3966](https://github.com/graphprotocol/graph-node/pull/3966) [#3986](https://github.com/graphprotocol/graph-node/pull/3986)
+- Block handlers optimization with Firehose >= 1.1.0. [#3971](https://github.com/graphprotocol/graph-node/pull/3971)
+- Reduced the amount of data that a non-primary shard has to mirror from the primary shard. [#4015](https://github.com/graphprotocol/graph-node/pull/4015)
+- We now use advisory locks to lock deployments' tables against concurrent writes. [#4010](https://github.com/graphprotocol/graph-node/pull/4010)
 
 #### Bug fixes
-* Fixed a bug that would cause some failed subgraphs to never restart. [#3959](https://github.com/graphprotocol/graph-node/pull/3959)
-* Fixed a bug that would cause bad POIs for Firehose-backed subgraphs when processing `CREATE` calls. [#4085](https://github.com/graphprotocol/graph-node/pull/4085)
-* Fixed a bug which would cause failure to redeploy a subgraph immediately after deletion. [#4044](https://github.com/graphprotocol/graph-node/pull/4044)
-* Firehose connections are now load-balanced. [#4083](https://github.com/graphprotocol/graph-node/pull/4083)
-* Determinism fixes. **See above.** [#4055](https://github.com/graphprotocol/graph-node/pull/4055), [#4149](https://github.com/graphprotocol/graph-node/pull/4149)
+
+- Fixed a bug that would cause some failed subgraphs to never restart. [#3959](https://github.com/graphprotocol/graph-node/pull/3959)
+- Fixed a bug that would cause bad POIs for Firehose-backed subgraphs when processing `CREATE` calls. [#4085](https://github.com/graphprotocol/graph-node/pull/4085)
+- Fixed a bug which would cause failure to redeploy a subgraph immediately after deletion. [#4044](https://github.com/graphprotocol/graph-node/pull/4044)
+- Firehose connections are now load-balanced. [#4083](https://github.com/graphprotocol/graph-node/pull/4083)
+- Determinism fixes. **See above.** [#4055](https://github.com/graphprotocol/graph-node/pull/4055), [#4149](https://github.com/graphprotocol/graph-node/pull/4149)
 
 #### Dependency updates
 
@@ -431,12 +1200,11 @@ These are some of the features that will probably be helpful for indexers 😊
   - A token can be set via `GRAPH_POI_ACCESS_TOKEN` to limit access to the POI route
 - The new `graphman` commands 🙂
 
-
 ### Api Version 0.0.7 and Spec Version 0.0.5
+
 This release brings API Version 0.0.7 in mappings, which allows Ethereum event handlers to require transaction receipts to be present in the `Event` object.
 Refer to [PR #3373](https://github.com/graphprotocol/graph-node/pull/3373) for instructions on how to enable that.
 
-
 ## 0.25.2
 
 This release includes two changes:
@@ -458,20 +1226,22 @@ We strongly recommend updating to this version as quickly as possible.
 ## 0.25.0
 
 ### Api Version 0.0.6
+
 This release ships support for API version 0.0.6 in mappings:
+
 - Added `nonce` field for `Transaction` objects.
 - Added `baseFeePerGas` field for `Block` objects ([EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)).
 
 #### Block Cache Invalidation and Reset
 
-All cached block data must be refetched to account for the new `Block` and `Trasaction`
+All cached block data must be refetched to account for the new `Block` and `Transaction`
 struct versions, so this release includes a `graph-node` startup check that will:
+
 1. Truncate all block cache tables.
 2. Bump the `db_version` value from `2` to `3`.
 
 _(Table truncation is a fast operation and no downtime will occur because of that.)_
 
-
 ### Ethereum
 
 - 'Out of gas' errors on contract calls are now considered deterministic errors,
@@ -483,10 +1253,12 @@ _(Table truncation is a fast operation and no downtime will occur because of tha
   is now hardcoded to 50 million.
 
 ### Multiblockchain
+
 - Initial support for NEAR subgraphs.
 - Added `FirehoseBlockStream` implementation of `BlockStream` (#2716)
 
 ### Misc
+
 - Rust docker image is now based on Debian Buster.
 - Optimizations to the PostgreSQL notification queue.
 - Improve PostgreSQL robustness in multi-sharded setups. (#2815)
@@ -501,7 +1273,6 @@ _(Table truncation is a fast operation and no downtime will occur because of tha
 - Handle revert cases from Hardhat and Ganache (#2984)
 - Fix bug on experimental prefetching optimization feature (#2899)
 
-
 ## 0.24.2
 
 This release only adds a fix for an issue where certain GraphQL queries
@@ -538,7 +1309,9 @@ For instance, the following query...
 
 ```graphql
 {
-  subgraphFeatures(subgraphId: "QmW9ajg2oTyPfdWKyUkxc7cTJejwdyCbRrSivfryTfFe5D") {
+  subgraphFeatures(
+    subgraphId: "QmW9ajg2oTyPfdWKyUkxc7cTJejwdyCbRrSivfryTfFe5D"
+  ) {
     features
     errors
   }
@@ -552,10 +1325,7 @@ For instance, the following query...
   "data": {
     "subgraphFeatures": {
       "errors": [],
-      "features": [
-        "nonFatalErrors",
-        "ipfsOnEthereumContracts"
-      ]
+      "features": ["nonFatalErrors", "ipfsOnEthereumContracts"]
     }
   }
 }
@@ -595,14 +1365,17 @@ and the long awaited AssemblyScript version upgrade!
   resolving issue [#2409](https://github.com/graphprotocol/graph-node/issues/2409). Done in [#2511](https://github.com/graphprotocol/graph-node/pull/2511).
 
 ### Logs
+
 - The log `"Skipping handler because the event parameters do not match the event signature."` was downgraded from info to trace level.
 - Some block ingestor error logs were upgrded from debug to info level [#2666](https://github.com/graphprotocol/graph-node/pull/2666).
 
 ### Metrics
+
 - `query_semaphore_wait_ms` is now by shard, and has the `pool` and `shard` labels.
 - `deployment_failed` metric added, it is `1` if the subgraph has failed and `0` otherwise.
 
 ### Other
+
 - Upgrade to tokio 1.0 and futures 0.3 [#2679](https://github.com/graphprotocol/graph-node/pull/2679), the first major contribution by StreamingFast!
 - Support Celo block reward events [#2670](https://github.com/graphprotocol/graph-node/pull/2670).
 - Reduce the maximum WASM stack size and make it configurable [#2719](https://github.com/graphprotocol/graph-node/pull/2719).
@@ -637,14 +1410,17 @@ In the meantime, here are the changes for this release:
 - Using `ethereum.call` in mappings in globals is deprecated
 
 ### Graphman
+
 Graphman is a CLI tool to manage your subgraphs. It is now included in the Docker container
 [#2289](https://github.com/graphprotocol/graph-node/pull/2289). And new commands have been added:
+
 - `graphman copy` can copy subgraphs across DB shards [#2313](https://github.com/graphprotocol/graph-node/pull/2313).
 - `graphman rewind` to rewind a deployment to a given block [#2373](https://github.com/graphprotocol/graph-node/pull/2373).
 - `graphman query` to log info about a GraphQL query [#2206](https://github.com/graphprotocol/graph-node/pull/2206).
 - `graphman create` to create a subgraph name [#2419](https://github.com/graphprotocol/graph-node/pull/2419).
 
 ### Metrics
+
 - The `deployment_blocks_behind` metric has been removed, and a
   `deployment_head` metric has been added. To see how far a deployment is
   behind, use the difference between `ethereum_chain_head_number` and
@@ -654,6 +1430,7 @@ Graphman is a CLI tool to manage your subgraphs. It is now included in the Docke
 ## 0.22.0
 
 ### Feature: Block store sharding
+
 This release makes it possible to [shard the block and call cache](./docs/config.md) for chain
 data across multiple independent Postgres databases. **This feature is considered experimental. We
 encourage users to try this out in a test environment, but do not recommend it yet for production
@@ -661,17 +1438,20 @@ use.** In particular, the details of how sharding is configured may change in ba
 ways in the future.
 
 ### Feature: Non-fatal errors update
+
 Non-fatal errors (see release 0.20 for details) is documented and can now be enabled on graph-cli.
 Various related bug fixes have been made #2121 #2136 #2149 #2160.
 
 ### Improvements
+
 - Add bitwise operations and string constructor to BigInt #2151.
 - docker: Allow custom ethereum poll interval #2139.
 - Deterministic error work in preparation for gas #2112
 
 ### Bug fixes
+
 - Fix not contains filter #2146.
-- Resolve __typename in _meta field #2118
+- Resolve \_\_typename in \_meta field #2118
 - Add CORS for all HTTP responses #2196
 
 ## 0.21.1
@@ -690,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 76cb9f6f392..667c606a045 100644
--- a/README.md
+++ b/README.md
@@ -1,189 +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
+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
 
-To build and run this project you need to have the following installed on your system:
+## Running `graph-node` from Docker images
 
-- 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/)
+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.
 
-For Ethereum network data, you can either run your own Ethereum node or use an Ethereum node provider of your choice.
+## Running `graph-node` from source
 
-**Minimum Hardware Requirements:**
+This is usually only needed for developers who want to contribute to `graph-node`.
 
-- To build graph-node with `cargo`, 8GB RAM are required.
+### Prerequisites
 
-### Running a Local Graph Node
+To build and run this project, you need to have the following installed on your system:
 
-This is a quick example to show a working Graph Node. It is a [subgraph for Gravatars](https://github.com/graphprotocol/example-subgraph).
+- 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/)
 
-1. Install IPFS and run `ipfs init` followed by `ipfs daemon`.
-2. Install PostgreSQL and run `initdb -D .postgres` 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:
+For Ethereum network data, you can either run your own Ethereum node or use an Ethereum node provider of your choice.
 
-```
-yarn
-yarn codegen
-```
+### Create a database
 
-5. In the terminal, clone https://github.com/graphprotocol/graph-node, and run `cargo build`.
+Once Postgres is running, you need to issue the following commands to create a database
+and configure it for use with `graph-node`.
 
-Once you have all the dependencies set up, you can run the following:
-
-```
-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
-```
-
-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 initalizes 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-seperated 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-seperated 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-seperated 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 c969e0a400a..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 = "1.4.13"
-graph = { path = "../../graph" }
-prost = { workspace = true }
-prost-types = { workspace = true }
-serde = "1.0"
-sha2 = "0.10.6"
-
-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 e2ede2acef2..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/type.proto"], &["proto"])
-        .expect("Failed to compile Firehose Arweave proto(s)");
-}
diff --git a/chain/arweave/proto/type.proto b/chain/arweave/proto/type.proto
deleted file mode 100644
index b3a41a4a56a..00000000000
--- a/chain/arweave/proto/type.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 fd2d962e31e..00000000000
--- a/chain/arweave/src/adapter.rs
+++ /dev/null
@@ -1,258 +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 },
-            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 86038c1110f..00000000000
--- a/chain/arweave/src/chain.rs
+++ /dev/null
@@ -1,340 +0,0 @@
-use graph::blockchain::client::ChainClient;
-use graph::blockchain::{Block, BlockchainKind, EmptyNodeCapabilities};
-use graph::cheap_clone::CheapClone;
-use graph::data::subgraph::UnifiedMappingApiVersion;
-use graph::firehose::{FirehoseEndpoint, FirehoseEndpoints};
-use graph::prelude::MetricsRegistry;
-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::runtime::RuntimeAdapter;
-use crate::trigger::{self, ArweaveTrigger};
-use crate::{
-    codec,
-    data_source::{DataSource, UnresolvedDataSource},
-};
-use graph::blockchain::block_stream::{BlockStream, FirehoseCursor};
-
-pub struct Chain {
-    logger_factory: LoggerFactory,
-    name: String,
-    client: Arc<ChainClient<Self>>,
-    chain_store: Arc<dyn ChainStore>,
-    metrics_registry: Arc<dyn MetricsRegistry>,
-}
-
-impl std::fmt::Debug for Chain {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "chain: arweave")
-    }
-}
-
-impl Chain {
-    pub fn new(
-        logger_factory: LoggerFactory,
-        name: String,
-        chain_store: Arc<dyn ChainStore>,
-        firehose_endpoints: FirehoseEndpoints,
-        metrics_registry: Arc<dyn MetricsRegistry>,
-    ) -> Self {
-        Chain {
-            logger_factory,
-            name,
-            client: Arc::new(ChainClient::<Self>::new_firehose(firehose_endpoints)),
-            chain_store,
-            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_firehose_block_stream(
-        &self,
-        deployment: DeploymentLocator,
-        block_cursor: FirehoseCursor,
-        start_blocks: Vec<BlockNumber>,
-        subgraph_current_block: Option<BlockPtr>,
-        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 firehose_endpoint = self.client.firehose_endpoint()?;
-        let logger = self
-            .logger_factory
-            .subgraph_logger(&deployment)
-            .new(o!("component" => "FirehoseBlockStream"));
-
-        let firehose_mapper = Arc::new(FirehoseMapper {});
-
-        Ok(Box::new(FirehoseBlockStream::new(
-            deployment.hash,
-            firehose_endpoint,
-            subgraph_current_block,
-            block_cursor,
-            firehose_mapper,
-            adapter,
-            filter,
-            start_blocks,
-            logger,
-            self.metrics_registry.clone(),
-        )))
-    }
-
-    async fn new_polling_block_stream(
-        &self,
-        _deployment: DeploymentLocator,
-        _start_blocks: Vec<BlockNumber>,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<Self::TriggerFilter>,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        panic!("Arweave does not support polling block stream")
-    }
-
-    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(RuntimeAdapter {})
-    }
-
-    fn chain_client(&self) -> Arc<ChainClient<Self>> {
-        self.client.clone()
-    }
-}
-
-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 {}
-
-#[async_trait]
-impl FirehoseMapperTrait<Chain> for FirehoseMapper {
-    async fn to_block_stream_event(
-        &self,
-        logger: &Logger,
-        response: &firehose::Response,
-        adapter: &Arc<dyn TriggersAdapterTrait<Chain>>,
-        filter: &TriggerFilter,
-    ) -> 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(
-                adapter.triggers_in_block(logger, block, 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")
-            }
-        }
-    }
-
-    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 09da7fee1b0..00000000000
--- a/chain/arweave/src/codec.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-#[rustfmt::skip]
-#[path = "protobuf/sf.arweave.r#type.v1.rs"]
-mod pbcodec;
-
-use graph::{blockchain::Block as BlockchainBlock, blockchain::BlockPtr, 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),
-        })
-    }
-}
-
-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 1bf6ac72caa..00000000000
--- a/chain/arweave/src/data_source.rs
+++ /dev/null
@@ -1,369 +0,0 @@
-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, info, BlockNumber, CheapClone, DataSourceTemplateInfo, Deserialize, Link,
-        LinkResolver, Logger,
-    },
-    semver,
-};
-use std::sync::Arc;
-
-use crate::chain::Chain;
-use crate::trigger::ArweaveTrigger;
-
-pub const ARWEAVE_KIND: &str = "arweave";
-
-/// 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 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(),
-        )))
-    }
-
-    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;
-
-        info!(logger, "Resolve data source"; "name" => &name, "source_address" => format_args!("{:?}", base64_url::encode(&source.owner.clone().unwrap_or_default())), "source_start_block" => source.start_block);
-
-        let mapping = mapping.resolve(resolver, logger).await?;
-
-        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;
-
-        info!(logger, "Resolve data source template"; "name" => &name);
-
-        Ok(DataSourceTemplate {
-            kind,
-            network,
-            name,
-            mapping: mapping.resolve(resolver, logger).await?,
-        })
-    }
-}
-
-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")
-    }
-}
-
-#[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)?;
-
-        info!(logger, "Resolve mapping"; "link" => &link.link);
-        let module_bytes = resolver.cat(logger, &link).await?;
-
-        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)]
-pub(crate) struct Source {
-    // A data source that does not have an owner can only have block handlers.
-    pub(crate) owner: Option<String>,
-    #[serde(rename = "startBlock", default)]
-    pub(crate) start_block: 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 ea495c6e5ff..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, DeterministicHostError, 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, DeterministicHostError> {
-        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, DeterministicHostError> {
-        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, DeterministicHostError> {
-        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, DeterministicHostError> {
-        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, DeterministicHostError> {
-        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, DeterministicHostError> {
-        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, DeterministicHostError> {
-        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 f44391caffd..00000000000
--- a/chain/arweave/src/runtime/mod.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-pub use runtime_adapter::RuntimeAdapter;
-
-pub mod abi;
-pub mod runtime_adapter;
-
-mod generated;
diff --git a/chain/arweave/src/runtime/runtime_adapter.rs b/chain/arweave/src/runtime/runtime_adapter.rs
deleted file mode 100644
index c5fa9e15059..00000000000
--- a/chain/arweave/src/runtime/runtime_adapter.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use crate::{data_source::DataSource, Chain};
-use blockchain::HostFn;
-use graph::{anyhow::Error, blockchain};
-
-pub struct RuntimeAdapter {}
-
-impl blockchain::RuntimeAdapter<Chain> for RuntimeAdapter {
-    fn host_fns(&self, _ds: &DataSource) -> Result<Vec<HostFn>, Error> {
-        Ok(vec![])
-    }
-}
diff --git a/chain/arweave/src/trigger.rs b/chain/arweave/src/trigger.rs
deleted file mode 100644
index 9d2f7ad3a4d..00000000000
--- a/chain/arweave/src/trigger.rs
+++ /dev/null
@@ -1,137 +0,0 @@
-use graph::blockchain::Block;
-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::DeterministicHostError;
-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<()>, DeterministicHostError> {
-        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(),
-        }
-    }
-}
-
-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) -> 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()
-                )
-            }
-        }
-    }
-}
-
-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 7ebb131d62e..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.2.0"
+protobuf-parse = "3.7.2"
 anyhow = "1"
-heck = "0.4"
+heck = "0.5"
+
+[lints]
+workspace = true
diff --git a/chain/common/proto/near-filter-substreams.proto b/chain/common/proto/near-filter-substreams.proto
new file mode 100644
index 00000000000..d7e4a822573
--- /dev/null
+++ b/chain/common/proto/near-filter-substreams.proto
@@ -0,0 +1,15 @@
+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/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 c932b5185ee..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.16"
-
-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 fc07b4907e0..00000000000
--- a/chain/cosmos/build.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-const PROTO_FILE: &str = "proto/type.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/type.proto"], &["proto"])
-        .expect("Failed to compile Firehose Cosmos proto(s)");
-}
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/proto/type.proto b/chain/cosmos/proto/type.proto
deleted file mode 100644
index c32502da1e9..00000000000
--- a/chain/cosmos/proto/type.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/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 f4a8b2953b1..00000000000
--- a/chain/cosmos/src/chain.rs
+++ /dev/null
@@ -1,645 +0,0 @@
-use std::sync::Arc;
-
-use graph::blockchain::block_stream::FirehoseCursor;
-use graph::blockchain::client::ChainClient;
-use graph::cheap_clone::CheapClone;
-use graph::data::subgraph::UnifiedMappingApiVersion;
-use graph::prelude::MetricsRegistry;
-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, FirehoseEndpoints, 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::RuntimeAdapter;
-use crate::{codec, TriggerFilter};
-
-pub struct Chain {
-    logger_factory: LoggerFactory,
-    name: String,
-    client: Arc<ChainClient<Self>>,
-    chain_store: Arc<dyn ChainStore>,
-    metrics_registry: Arc<dyn MetricsRegistry>,
-}
-
-impl std::fmt::Debug for Chain {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "chain: cosmos")
-    }
-}
-
-impl Chain {
-    pub fn new(
-        logger_factory: LoggerFactory,
-        name: String,
-        chain_store: Arc<dyn ChainStore>,
-        firehose_endpoints: FirehoseEndpoints,
-        metrics_registry: Arc<dyn MetricsRegistry>,
-    ) -> Self {
-        Chain {
-            logger_factory,
-            name,
-            client: Arc::new(ChainClient::new_firehose(firehose_endpoints)),
-            chain_store,
-            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_firehose_block_stream(
-        &self,
-        deployment: DeploymentLocator,
-        block_cursor: FirehoseCursor,
-        start_blocks: Vec<BlockNumber>,
-        subgraph_current_block: Option<BlockPtr>,
-        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 firehose_endpoint = self.client.firehose_endpoint()?;
-
-        let logger = self
-            .logger_factory
-            .subgraph_logger(&deployment)
-            .new(o!("component" => "FirehoseBlockStream"));
-
-        let firehose_mapper = Arc::new(FirehoseMapper {});
-
-        Ok(Box::new(FirehoseBlockStream::new(
-            deployment.hash,
-            firehose_endpoint,
-            subgraph_current_block,
-            block_cursor,
-            firehose_mapper,
-            adapter,
-            filter,
-            start_blocks,
-            logger,
-            self.metrics_registry.clone(),
-        )))
-    }
-
-    async fn new_polling_block_stream(
-        &self,
-        _deployment: DeploymentLocator,
-        _start_blocks: Vec<BlockNumber>,
-        _subgraph_start_block: Option<BlockPtr>,
-        _filter: Arc<Self::TriggerFilter>,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        panic!("Cosmos does not support polling block stream")
-    }
-
-    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(RuntimeAdapter {})
-    }
-
-    fn chain_client(&self) -> Arc<ChainClient<Self>> {
-        self.client.clone()
-    }
-}
-
-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 {}
-
-#[async_trait]
-impl FirehoseMapperTrait<Chain> for FirehoseMapper {
-    async fn to_block_stream_event(
-        &self,
-        logger: &Logger,
-        response: &firehose::Response,
-        adapter: &Arc<dyn TriggersAdapterTrait<Chain>>,
-        filter: &TriggerFilter,
-    ) -> 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.
-        let sp = codec::Block::decode(any_block.value.as_ref())?;
-
-        match step {
-            ForkStep::StepNew => Ok(BlockStreamEvent::ProcessBlock(
-                adapter.triggers_in_block(logger, sp, filter).await?,
-                FirehoseCursor::from(response.cursor.clone()),
-            )),
-
-            ForkStep::StepUndo => {
-                let parent_ptr = sp
-                    .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 fae145a449e..00000000000
--- a/chain/cosmos/src/codec.rs
+++ /dev/null
@@ -1,188 +0,0 @@
-pub(crate) use crate::protobuf::pbcodec::*;
-
-use graph::blockchain::Block as BlockchainBlock;
-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()
-    }
-}
-
-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()
-    }
-}
-
-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 3d6043b41bc..00000000000
--- a/chain/cosmos/src/data_source.rs
+++ /dev/null
@@ -1,666 +0,0 @@
-use std::collections::{HashMap, HashSet};
-use std::sync::Arc;
-
-use anyhow::{Error, Result};
-
-use graph::{
-    blockchain::{self, Block, Blockchain, TriggerWithHandler},
-    components::store::StoredDynamicDataSource,
-    data::subgraph::DataSourceContext,
-    prelude::{
-        anyhow, async_trait, info, 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 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 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(),
-        )))
-    }
-
-    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;
-
-        info!(logger, "Resolve data source"; "name" => &name, "source" => &source.start_block);
-
-        let mapping = mapping.resolve(resolver, logger).await?;
-
-        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);
-    }
-}
-
-#[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)?;
-
-        info!(logger, "Resolve mapping"; "link" => &link.link);
-        let module_bytes = resolver.cat(logger, &link).await?;
-
-        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)]
-pub struct Source {
-    #[serde(rename = "startBlock", default)]
-    pub start_block: 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 },
-                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 },
-                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 6d84b61947e..00000000000
--- a/chain/cosmos/src/lib.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-mod adapter;
-pub mod chain;
-pub mod codec;
-mod data_source;
-mod protobuf;
-pub mod runtime;
-mod trigger;
-
-pub use self::runtime::RuntimeAdapter;
-
-// 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 3c5f0dd5353..00000000000
--- a/chain/cosmos/src/runtime/abi.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use crate::protobuf::*;
-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, DeterministicHostError> {
-        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, DeterministicHostError> {
-        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, DeterministicHostError> {
-        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 77702f3ba90..00000000000
--- a/chain/cosmos/src/runtime/mod.rs
+++ /dev/null
@@ -1,351 +0,0 @@
-pub use runtime_adapter::RuntimeAdapter;
-
-pub mod abi;
-pub mod runtime_adapter;
-
-#[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/runtime/runtime_adapter.rs b/chain/cosmos/src/runtime/runtime_adapter.rs
deleted file mode 100644
index 4bced409e98..00000000000
--- a/chain/cosmos/src/runtime/runtime_adapter.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-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![])
-    }
-}
diff --git a/chain/cosmos/src/trigger.rs b/chain/cosmos/src/trigger.rs
deleted file mode 100644
index 52a64e4b0f2..00000000000
--- a/chain/cosmos/src/trigger.rs
+++ /dev/null
@@ -1,359 +0,0 @@
-use std::{cmp::Ordering, sync::Arc};
-
-use graph::blockchain::{Block, BlockHash, TriggerData};
-use graph::cheap_clone::CheapClone;
-use graph::prelude::{BlockNumber, Error};
-use graph::runtime::{asc_new, gas::GasCounter, AscHeap, AscPtr, DeterministicHostError};
-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<()>, DeterministicHostError> {
-        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 {
-    fn cheap_clone(&self) -> CosmosTrigger {
-        match self {
-            CosmosTrigger::Block(block) => CosmosTrigger::Block(block.cheap_clone()),
-            CosmosTrigger::Event { event_data, origin } => CosmosTrigger::Event {
-                event_data: event_data.cheap_clone(),
-                origin: *origin,
-            },
-            CosmosTrigger::Transaction(transaction_data) => {
-                CosmosTrigger::Transaction(transaction_data.cheap_clone())
-            }
-            CosmosTrigger::Message(message_data) => {
-                CosmosTrigger::Message(message_data.cheap_clone())
-            }
-        }
-    }
-}
-
-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()) {
-                    a_event.event_type == b_event.event_type && a_origin == b_origin
-                } 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()),
-        }
-    }
-}
-
-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) -> 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()
-                }
-            }
-        }
-    }
-}
-
-#[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 4a5a1180dcd..a9c9d42a124 100644
--- a/chain/ethereum/Cargo.toml
+++ b/chain/ethereum/Cargo.toml
@@ -4,30 +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.16"
+semver = { workspace = true }
+thiserror = { workspace = true }
+futures = { workspace = true }
+tokio = { workspace = true }
+tokio-stream = { workspace = true }
+tower = { workspace = true }
 
-itertools = "0.10.5"
+itertools = "0.15.0"
 
 graph-runtime-wasm = { path = "../../runtime/wasm" }
 graph-runtime-derive = { path = "../../runtime/derive" }
 
 [dev-dependencies]
-test-store = { path = "../../store/test-store" }
-base64 = "0.20.0"
-graph-mock = { path = "../../mock" }
+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 0efb360140d..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/codec.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 37acba642e3..3dd21859653 100644
--- a/chain/ethereum/examples/firehose.rs
+++ b/chain/ethereum/examples/firehose.rs
@@ -1,13 +1,15 @@
 use anyhow::Error;
 use graph::{
+    endpoint::EndpointMetrics,
     env::env_var,
-    firehose::SubgraphLimit,
-    prelude::{prost, tokio, tonic},
-    {firehose, firehose::FirehoseEndpoint},
+    firehose::{self, FirehoseEndpoint, SubgraphLimit},
+    log::logger,
+    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;
 
@@ -20,29 +22,42 @@ async fn main() -> Result<(), Error> {
         token = Some(token_env);
     }
 
+    let logger = logger(false);
+    let host = "https://api.streamingfast.io:443".to_string();
+    let metrics = Arc::new(EndpointMetrics::new(
+        logger,
+        slice::from_ref(&host),
+        Arc::new(MetricsRegistry::mock()),
+    ));
+
     let firehose = Arc::new(FirehoseEndpoint::new(
         "firehose",
-        "https://api.streamingfast.io:443",
+        &host,
         token,
+        None,
         false,
         false,
         SubgraphLimit::Unlimited,
+        metrics,
     ));
 
     loop {
         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/codec.proto b/chain/ethereum/proto/codec.proto
deleted file mode 100644
index 3c9f7378c7d..00000000000
--- a/chain/ethereum/proto/codec.proto
+++ /dev/null
@@ -1,508 +0,0 @@
-syntax = "proto3";
-
-package sf.ethereum.type.v2;
-
-option go_package = "github.com/streamingfast/sf-ethereum/types/pb/sf/ethereum/type/v2;pbeth";
-
-import "google/protobuf/timestamp.proto";
-
-message Block {
-  int32 ver = 1;
-  bytes hash = 2;
-  uint64 number = 3;
-  uint64 size = 4;
-  BlockHeader header = 5;
-
-  // Uncles represents block produced with a valid solution but were not actually choosen
-  // 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;
-
-  repeated TransactionTrace transaction_traces = 10;
-  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];
-}
-
-// 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 TransactionRefs {
-  repeated bytes hashes = 1;
-}
-
-message UnclesHeaders {
-  repeated BlockHeader uncles = 1;
-}
-
-message BlockRef {
-  bytes hash = 1;
-  uint64 number = 2;
-}
-
-message BlockHeader {
-  bytes parent_hash = 1;
-
-  // 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`.
-  bytes uncle_hash = 2;
-
-  bytes coinbase = 3;
-  bytes state_root = 4;
-  bytes transactions_root = 5;
-  bytes receipt_root = 6;
-  bytes logs_bloom = 7;
-
-  // Difficulty is the difficulty of the Proof of Work algorithm that was required to compute a solution.
-  //
-  // 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 `0x00`.
-  BigInt difficulty = 8;
-
-  // TotalDifficulty is 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;
-
-  uint64 number = 9;
-  uint64 gas_limit = 10;
-  uint64 gas_used = 11;
-  google.protobuf.Timestamp timestamp = 12;
-
-  // ExtraData is free-form bytes included in the block by the "miner". While on Yellow paper of
-  // Ethereum this value is maxed to 32 bytes, other consensus algorithm like Clique and some other
-  // 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.
-  bytes extra_data = 13;
-
-  // MixHash is used to prove, when combined with the `nonce` that sufficient amount of computation has been
-  // achieved and that the solution found is valid.
-  bytes mix_hash = 14;
-
-  // Nonce is used to prove, when combined with the `mix_hash` that sufficient amount of computation has been
-  // achieved and that the solution found is valid.
-  //
-  // 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 `0`.
-  uint64 nonce = 15;
-
-  // 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
-  //  ]))
-  //
-  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;
-}
-
-message BigInt {
-  bytes bytes = 1;
-}
-
-message TransactionTrace {
-  // consensus
-  bytes to = 1;
-  uint64 nonce = 2;
-  // GasPrice represents the effective price that has been paid for each gas unit of this transaction. Over time, the
-  // Ethereum rules changes regarding GasPrice field here. Before London fork, the GasPrice was always set to the
-  // fixed gas price. After London fork, this value has different meaning depending on the transaction type (see `Type` field).
-  //
-  // In cases where `TransactionTrace.Type == TRX_TYPE_LEGACY || TRX_TYPE_ACCESS_LIST`, then GasPrice has the same meaning
-  // as before the London fork.
-  //
-  // In cases where `TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE`, then GasPrice is the effective gas price paid
-  // for the transaction which is equals to `BlockHeader.BaseFeePerGas + TransactionTrace.`
-  BigInt gas_price = 3;
-
-  // GasLimit is the maximum of gas unit the sender of the transaction is willing to consume when perform the EVM
-  // execution of the whole transaction
-  uint64 gas_limit = 4;
-
-  // Value is the amount of Ether transferred as part of this transaction.
-  BigInt value = 5;
-
-  // Input data the transaction will receive for execution of EVM.
-  bytes input = 6;
-
-  // V is the recovery ID value for the signature Y point.
-  bytes v = 7;
-
-  // R is the signature's X point on the elliptic curve (32 bytes).
-  bytes r = 8;
-
-  // S is the signature's Y point on the elliptic curve (32 bytes).
-  bytes s = 9;
-
-  // GasUsed is the total amount of gas unit used for the whole execution of the transaction.
-  uint64 gas_used = 10;
-
-  // Type represents the Ethereum transaction type, available only since EIP-2718 & EIP-2930 activation which happened on Berlin fork.
-  // The value is always set even for transaction before Berlin fork because those before the fork are still legacy transactions.
-  Type type = 12;
-
-  enum Type {
-    // 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
-    // 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
-    // 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;
-  }
-
-  // AcccessList 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
-  // is possible only if Berlin (TRX_TYPE_ACCESS_LIST) nor London (TRX_TYPE_DYNAMIC_FEE) fork are active on the chain.
-  repeated AccessTuple access_list = 14;
-
-  // MaxFeePerGas is the maximum fee per gas the user is willing to pay for the transaction gas used.
-  //
-  // This will is populated only if `TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE` which is possible only
-  // if London fork is active on the chain.
-  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
-  // base fee.
-  //
-  // This will is populated only if `TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE` which is possible only
-  // if London fork is active on the chain.
-  BigInt max_priority_fee_per_gas = 13;
-
-  // meta
-  uint32 index = 20;
-  bytes hash = 21;
-  bytes from = 22;
-  bytes return_data = 23;
-  bytes public_key = 24;
-  uint64 begin_ordinal = 25;
-  uint64 end_ordinal = 26;
-
-  TransactionTraceStatus status = 30;
-  TransactionReceipt receipt = 31;
-  repeated Call calls = 32;
-}
-
-
-// AccessTuple represents a list of storage keys for a given contract's address and is used
-// for AccessList construction.
-message AccessTuple {
-  bytes address = 1;
-  repeated bytes storage_keys = 2;
-}
-
-// TransactionTraceWithBlockRef
-message TransactionTraceWithBlockRef {
-  TransactionTrace trace = 1;
-  BlockRef block_ref = 2;
-}
-
-enum TransactionTraceStatus {
-  UNKNOWN = 0;
-  SUCCEEDED = 1;
-  FAILED = 2;
-  REVERTED = 3;
-}
-
-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
-  // - 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.
-  bytes state_root = 1;
-  uint64 cumulative_gas_used = 2;
-  bytes logs_bloom = 3;
-  repeated Log logs = 4;
-}
-
-message Log {
-  bytes address = 1;
-  repeated bytes topics = 2;
-  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
-  // that emitted this log.
-  uint32 index = 4;
-
-  // BlockIndex represents the index of the log relative to the Block.
-  //
-  // An **important** notice is that this field will be 0 when the call
-  // 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[]
-  //
-  // 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
-  // position, the `blockIndex` is always populated correctly.
-  //
-  // In the case of `calls` case, for `call` where `stateReverted == true`,
-  // the `blockIndex` value will always be 0.
-  uint32 blockIndex = 6;
-
-  uint64 ordinal = 7;
-}
-
-message Call {
-  uint32 index = 1;
-  uint32 parent_index = 2;
-  uint32 depth = 3;
-  CallType call_type = 4;
-  bytes caller = 5;
-  bytes address = 6;
-  BigInt value = 7;
-  uint64 gas_limit = 8;
-  uint64 gas_consumed = 9;
-  bytes return_data = 13;
-  bytes input = 14;
-  bool executed_code = 15;
-  bool suicide = 16;
-
-  /* hex representation of the hash -> preimage */
-  map<string, string> keccak_preimages = 20;
-  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;
-
-  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
-  // - 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`
-  // and `status_reverted` are going to be set to `true`.
-  bool status_failed = 10;
-  bool status_reverted = 12;
-
-  // Populated when a call either failed or reverted, so when `status_failed == true`,
-  // see above for details about those flags.
-  string failure_reason = 11;
-
-  // This field represents wheter 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
-  // of its inner nested calls failed. This is problematic however since
-  // a call will invalidate all its state changes as well as all state
-  // changes performed by its child call. This means that even if a 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
-  // ```
-  //
-  // In the transaction above, while Call #2 and Call #3 would have the
-  // status `EXECUTED`
-  bool state_reverted = 30;
-
-  uint64 begin_ordinal = 31;
-  uint64 end_ordinal = 32;
-
-  repeated AccountCreation account_creations = 33;
-
-  reserved 50; // repeated ERC20BalanceChange erc20_balance_changes = 50 [deprecated = true];
-  reserved 51; // repeated ERC20TransferEvent erc20_transfer_events = 51 [deprecated = true];
-  reserved 60; // bool filtering_matched = 60 [deprecated = true];
-}
-
-enum CallType {
-  UNSPECIFIED = 0;
-  CALL = 1; // direct? what's the name for `Call` alone?
-  CALLCODE = 2;
-  DELEGATE = 3;
-  STATIC = 4;
-  CREATE = 5; // create2 ? any other form of calls?
-}
-
-message StorageChange {
-  bytes address = 1;
-  bytes key = 2;
-  bytes old_value = 3;
-  bytes new_value = 4;
-
-  uint64 ordinal = 5;
-}
-
-message BalanceChange {
-  bytes address = 1;
-  BigInt old_value = 2;
-  BigInt new_value = 3;
-  Reason reason = 4;
-
-  // Obtain all balanche change reasons under deep mind repository:
-  //
-  // ```shell
-  // ack -ho 'BalanceChangeReason\(".*"\)' | grep -Eo '".*"' | sort | uniq
-  // ```
-  enum Reason {
-    REASON_UNKNOWN = 0;
-    REASON_REWARD_MINE_UNCLE = 1;
-    REASON_REWARD_MINE_BLOCK = 2;
-    REASON_DAO_REFUND_CONTRACT = 3;
-    REASON_DAO_ADJUST_BALANCE = 4;
-    REASON_TRANSFER = 5;
-    REASON_GENESIS_BALANCE = 6;
-    REASON_GAS_BUY = 7;
-    REASON_REWARD_TRANSACTION_FEE = 8;
-    REASON_REWARD_FEE_RESET = 14;
-    REASON_GAS_REFUND = 9;
-    REASON_TOUCH_ACCOUNT = 10;
-    REASON_SUICIDE_REFUND = 11;
-    REASON_SUICIDE_WITHDRAW = 13;
-    REASON_CALL_BALANCE_OVERRIDE = 12;
-    // Used on chain(s) where some Ether burning happens
-    REASON_BURN = 15;
-  }
-
-  uint64 ordinal = 5;
-}
-
-message NonceChange {
-  bytes address = 1;
-  uint64 old_value = 2;
-  uint64 new_value = 3;
-  uint64 ordinal = 4;
-}
-
-message AccountCreation {
-  bytes account = 1;
-  uint64 ordinal = 2;
-}
-
-message CodeChange {
-  bytes address = 1;
-  bytes old_hash = 2;
-  bytes old_code = 3;
-  bytes new_hash = 4;
-  bytes new_code = 5;
-
-  uint64 ordinal = 6;
-}
-
-// The gas change model represents the reason why some gas cost has occurred.
-// The gas is computed per actual op codes. Doing them completely might prove
-// overwhelming in most cases.
-//
-// Hence, we only index some of them, those that are costy like all the calls
-// one, log events, return data, etc.
-message GasChange {
-  uint64 old_value = 1;
-  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 = 1;
-    REASON_CALL_CODE = 2;
-    REASON_CALL_DATA_COPY = 3;
-    REASON_CODE_COPY = 4;
-    REASON_CODE_STORAGE = 5;
-    REASON_CONTRACT_CREATION = 6;
-    REASON_CONTRACT_CREATION2 = 7;
-    REASON_DELEGATE_CALL = 8;
-    REASON_EVENT_LOG = 9;
-    REASON_EXT_CODE_COPY = 10;
-    REASON_FAILED_EXECUTION = 11;
-    REASON_INTRINSIC_GAS = 12;
-    REASON_PRECOMPILED_CONTRACT = 13;
-    REASON_REFUND_AFTER_EXECUTION = 14;
-    REASON_RETURN = 15;
-    REASON_RETURN_DATA_COPY = 16;
-    REASON_REVERT = 17;
-    REASON_SELF_DESTRUCT = 18;
-    REASON_STATIC_CALL = 19;
-
-    // Added in Berlin fork (Geth 1.10+)
-    REASON_STATE_COLD_ACCESS = 20;
-  }
-
-  uint64 ordinal = 4;
-}
\ No newline at end of file
diff --git a/chain/ethereum/proto/ethereum.proto b/chain/ethereum/proto/ethereum.proto
new file mode 100644
index 00000000000..50c10f921f0
--- /dev/null
+++ b/chain/ethereum/proto/ethereum.proto
@@ -0,0 +1,1073 @@
+syntax = "proto3";
+
+package sf.ethereum.type.v2;
+
+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 {
+  // 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 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;
+
+  enum DetailLevel{
+    DETAILLEVEL_EXTENDED = 0;
+    // DETAILLEVEL_TRACE = 1; // TBD
+    DETAILLEVEL_BASE = 2;
+  }
+
+  // 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;
+
+  // 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;
+
+  // 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;
+
+  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];
+
+  // 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 {
+  bytes parent_hash = 1;
+
+  // 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`.
+  bytes uncle_hash = 2;
+
+  bytes coinbase = 3;
+  bytes state_root = 4;
+  bytes transactions_root = 5;
+  bytes receipt_root = 6;
+  bytes logs_bloom = 7;
+
+  // Difficulty is the difficulty of the Proof of Work algorithm that was required to compute a solution.
+  //
+  // 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 `0x00`.
+  BigInt difficulty = 8;
+
+  // TotalDifficulty used to be the sum of all previous blocks difficulty including this block difficulty.
+  //
+  // 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;
+  uint64 gas_used = 11;
+  google.protobuf.Timestamp timestamp = 12;
+
+  // ExtraData is free-form bytes included in the block by the "miner". While on Yellow paper of
+  // Ethereum this value is maxed to 32 bytes, other consensus algorithm like Clique and some other
+  // 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.
+  bytes extra_data = 13;
+
+  // MixHash is used to prove, when combined with the `nonce` that sufficient amount of computation has been
+  // achieved and that the solution found is valid.
+  bytes mix_hash = 14;
+
+  // Nonce is used to prove, when combined with the `mix_hash` that sufficient amount of computation has been
+  // achieved and that the solution found is valid.
+  //
+  // 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 `0`.
+  uint64 nonce = 15;
+
+  // 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 (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;
+  uint64 nonce = 2;
+  // GasPrice represents the effective price that has been paid for each gas unit of this transaction. Over time, the
+  // Ethereum rules changes regarding GasPrice field here. Before London fork, the GasPrice was always set to the
+  // fixed gas price. After London fork, this value has different meaning depending on the transaction type (see `Type` field).
+  //
+  // In cases where `TransactionTrace.Type == TRX_TYPE_LEGACY || TRX_TYPE_ACCESS_LIST`, then GasPrice has the same meaning
+  // as before the London fork.
+  //
+  // In cases where `TransactionTrace.Type == TRX_TYPE_DYNAMIC_FEE`, then GasPrice is the effective gas price paid
+  // for the transaction which is equals to `BlockHeader.BaseFeePerGas + TransactionTrace.`
+  BigInt gas_price = 3;
+
+  // GasLimit is the maximum of gas unit the sender of the transaction is willing to consume when perform the EVM
+  // execution of the whole transaction
+  uint64 gas_limit = 4;
+
+  // Value is the amount of Ether transferred as part of this transaction.
+  BigInt value = 5;
+
+  // Input data the transaction will receive for execution of EVM.
+  bytes input = 6;
+
+  // V is the recovery ID value for the signature Y point.
+  bytes v = 7;
+
+  // R is the signature's X point on the elliptic curve (32 bytes).
+  bytes r = 8;
+
+  // S is the signature's Y point on the elliptic curve (32 bytes).
+  bytes s = 9;
+
+  // GasUsed is the total amount of gas unit used for the whole execution of the transaction.
+  uint64 gas_used = 10;
+
+  // Type represents the Ethereum transaction type, available only since EIP-2718 & EIP-2930 activation which happened on Berlin fork.
+  // The value is always set even for transaction before Berlin fork because those before the fork are still legacy transactions.
+  Type type = 12;
+
+  enum Type {
+    // All transactions that ever existed prior Berlin fork before EIP-2718 was implemented.
+    TRX_TYPE_LEGACY = 0;
+
+    // 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 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;
+
+  }
+
+  // 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
+  // is possible only if Berlin (TRX_TYPE_ACCESS_LIST) nor London (TRX_TYPE_DYNAMIC_FEE) fork are active on the chain.
+  repeated AccessTuple access_list = 14;
+
+  // MaxFeePerGas is the maximum fee per gas the user is willing to pay for the transaction gas used.
+  //
+  // 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
+  // base fee.
+  //
+  // 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.
+message AccessTuple {
+  bytes address = 1;
+  repeated bytes storage_keys = 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 {
+  UNKNOWN = 0;
+  SUCCEEDED = 1;
+  FAILED = 2;
+  REVERTED = 3;
+}
+
+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
+  // 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.
+  bytes state_root = 1;
+  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 {
+  bytes address = 1;
+  repeated bytes topics = 2;
+  bytes data = 3;
+
+  // Index is the index of the log relative to the transaction. This index
+  // 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.
+  //
+  // An **important** notice is that this field will be 0 when the call
+  // 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[]
+  //
+  // 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
+  // position, the `blockIndex` is always populated correctly.
+  //
+  // In the case of `calls` case, for `call` where `stateReverted == true`,
+  // 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;
+}
+
+message Call {
+  uint32 index = 1;
+  uint32 parent_index = 2;
+  uint32 depth = 3;
+  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:
+  // - 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`
+  // and `status_reverted` are going to be set to `true`.
+  bool status_failed = 10;
+  bool status_reverted = 12;
+
+  // Populated when a call either failed or reverted, so when `status_failed == true`,
+  // see above for details about those flags.
+  string failure_reason = 11;
+
+  // 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
+  // of its inner nested calls failed. This is problematic however since
+  // a call will invalidate all its state changes as well as all state
+  // changes performed by its child call. This means that even if a 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
+  // ```
+  //
+  // In the transaction above, while Call #2 and Call #3 would have the
+  // 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;
+
+  // 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];
+  reserved 60; // bool filtering_matched = 60 [deprecated = true];
+}
+
+enum CallType {
+  UNSPECIFIED = 0;
+  CALL = 1; // direct? what's the name for `Call` alone?
+  CALLCODE = 2;
+  DELEGATE = 3;
+  STATIC = 4;
+  CREATE = 5; // create2 ? any other form of calls?
+}
+
+message StorageChange {
+  bytes address = 1;
+  bytes key = 2;
+  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;
+
+  // 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:
+  //
+  // ```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;
+    REASON_REWARD_MINE_BLOCK = 2;
+    REASON_DAO_REFUND_CONTRACT = 3;
+    REASON_DAO_ADJUST_BALANCE = 4;
+    REASON_TRANSFER = 5;
+    REASON_GENESIS_BALANCE = 6;
+    REASON_GAS_BUY = 7;
+    REASON_REWARD_TRANSACTION_FEE = 8;
+    REASON_REWARD_FEE_RESET = 14;
+    REASON_GAS_REFUND = 9;
+    REASON_TOUCH_ACCOUNT = 10;
+    REASON_SUICIDE_REFUND = 11;
+    REASON_SUICIDE_WITHDRAW = 13;
+    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;
+}
+
+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;
+}
+
+message CodeChange {
+  bytes address = 1;
+  bytes old_hash = 2;
+  bytes old_code = 3;
+  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;
+}
+
+// The gas change model represents the reason why some gas cost has occurred.
+// The gas is computed per actual op codes. Doing them completely might prove
+// overwhelming in most cases.
+//
+// Hence, we only index some of them, those that are costy like all the calls
+// one, log events, return data, etc.
+message GasChange {
+  uint64 old_value = 1;
+  uint64 new_value = 2;
+  Reason reason = 3;
+
+  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 bf5cde3d3ce..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,41 +29,117 @@ 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>,
+/// `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 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 EthereumRpcError {
     #[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,
 }
 
+#[derive(Error, Debug)]
+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}")]
+    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)]
 enum LogFilterNode {
     Contract(Address),
@@ -68,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)
     }
 }
 
@@ -120,6 +262,21 @@ impl TriggerFilter {
     pub(crate) fn requires_traces(&self) -> bool {
         !self.call.is_empty() || self.block.requires_traces()
     }
+
+    #[cfg(debug_assertions)]
+    pub fn log(&self) -> &EthereumLogFilter {
+        &self.log
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn call(&self) -> &EthereumCallFilter {
+        &self.call
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn block(&self) -> &EthereumBlockFilter {
+        &self.block
+    }
 }
 
 impl bc::TriggerFilter<Chain> for TriggerFilter {
@@ -157,10 +314,16 @@ impl bc::TriggerFilter<Chain> for TriggerFilter {
 
     fn to_firehose_filter(self) -> Vec<prost_types::Any> {
         let EthereumBlockFilter {
+            polling_intervals,
             contract_addresses: _contract_addresses,
             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));
@@ -172,7 +335,9 @@ impl bc::TriggerFilter<Chain> for TriggerFilter {
         let combined_filter = CombinedFilter {
             log_filters,
             call_filters,
-            send_all_block_headers: trigger_every_block,
+            // 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 {
@@ -183,33 +348,135 @@ impl bc::TriggerFilter<Chain> for TriggerFilter {
 }
 
 #[derive(Clone, Debug, Default)]
-pub(crate) struct EthereumLogFilter {
+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(),
                 },
             )
@@ -221,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()))
             }
         }
     }
@@ -241,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 {
@@ -265,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,
+                        );
                     }
                 }
             }
@@ -287,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;
@@ -302,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.
@@ -315,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
@@ -363,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);
@@ -380,10 +724,20 @@ impl EthereumLogFilter {
         }
         filters.into_iter()
     }
+
+    #[cfg(debug_assertions)]
+    pub fn contract_addresses(&self) -> impl Iterator<Item = Address> + '_ {
+        self.contracts_and_events_graph
+            .nodes()
+            .filter_map(|node| match node {
+                LogFilterNode::Contract(address) => Some(address),
+                LogFilterNode::Event(_) => None,
+            })
+    }
 }
 
 #[derive(Clone, Debug, Default)]
-pub(crate) struct EthereumCallFilter {
+pub struct EthereumCallFilter {
     // Each call filter has a map of filters keyed by address, each containing a tuple with
     // start_block and the set of function signatures
     pub contract_addresses_function_signatures:
@@ -392,21 +746,21 @@ pub(crate) 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();
@@ -547,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,
@@ -581,20 +932,22 @@ impl From<&EthereumBlockFilter> for EthereumCallFilter {
 }
 
 #[derive(Clone, Debug, Default)]
-pub(crate) struct EthereumBlockFilter {
+pub struct EthereumBlockFilter {
+    /// Used for polling block handlers, a hashset of (start_block, polling_interval)
+    pub polling_intervals: HashSet<(BlockNumber, i32)>,
     pub contract_addresses: HashSet<(BlockNumber, Address)>,
     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()
@@ -608,6 +961,7 @@ impl EthereumBlockFilter {
     /// which keeps track of deployed contracts and relevant addresses.
     pub fn from_mapping(mapping: &Mapping) -> Self {
         Self {
+            polling_intervals: HashSet::new(),
             contract_addresses: HashSet::new(),
             trigger_every_block: !mapping.block_handlers.is_empty(),
         }
@@ -622,9 +976,8 @@ impl EthereumBlockFilter {
                     .block_handlers
                     .clone()
                     .into_iter()
-                    .any(|block_handler| match block_handler.filter {
-                        Some(ref filter) if *filter == BlockHandlerFilter::Call => true,
-                        _ => false,
+                    .any(|block_handler| {
+                        matches!(block_handler.filter, Some(BlockHandlerFilter::Call))
                     });
 
                 let has_block_handler_without_filter = data_source
@@ -636,6 +989,19 @@ impl EthereumBlockFilter {
 
                 filter_opt.extend(Self {
                     trigger_every_block: has_block_handler_without_filter,
+                    polling_intervals: data_source
+                        .mapping
+                        .block_handlers
+                        .clone()
+                        .into_iter()
+                        .filter_map(|block_handler| match block_handler.filter {
+                            Some(BlockHandlerFilter::Polling { every }) => {
+                                Some((data_source.start_block, every.get() as i32))
+                            }
+                            Some(BlockHandlerFilter::Once) => Some((data_source.start_block, 0)),
+                            _ => None,
+                        })
+                        .collect(),
                     contract_addresses: if has_block_handler_with_call_filter {
                         vec![(data_source.start_block, data_source.address.unwrap())]
                             .into_iter()
@@ -654,6 +1020,7 @@ impl EthereumBlockFilter {
         };
 
         let EthereumBlockFilter {
+            polling_intervals,
             contract_addresses,
             trigger_every_block,
         } = other;
@@ -678,6 +1045,11 @@ impl EthereumBlockFilter {
                 }
             }
         }
+
+        for (other_start_block, other_polling_interval) in &polling_intervals {
+            self.polling_intervals
+                .insert((*other_start_block, *other_polling_interval));
+        }
     }
 
     fn requires_traces(&self) -> bool {
@@ -686,12 +1058,13 @@ impl EthereumBlockFilter {
 
     /// An empty filter is one that never matches.
     pub fn is_empty(&self) -> bool {
+        let Self {
+            contract_addresses,
+            polling_intervals,
+            trigger_every_block,
+        } = self;
         // If we are triggering every block, we are of course not empty
-        if self.trigger_every_block {
-            return false;
-        }
-
-        self.contract_addresses.is_empty()
+        !*trigger_every_block && contract_addresses.is_empty() && polling_intervals.is_empty()
     }
 
     fn find_contract_address(&self, candidate: &Address) -> Option<(i32, Address)> {
@@ -731,7 +1104,7 @@ pub struct ProviderEthRpcMetrics {
 }
 
 impl ProviderEthRpcMetrics {
-    pub fn new(registry: Arc<dyn MetricsRegistry>) -> Self {
+    pub fn new(registry: Arc<MetricsRegistry>) -> Self {
         let request_duration = registry
             .new_histogram_vec(
                 "eth_rpc_request_duration",
@@ -787,7 +1160,7 @@ pub struct SubgraphEthRpcMetrics {
 }
 
 impl SubgraphEthRpcMetrics {
-    pub fn new(registry: Arc<dyn MetricsRegistry>, subgraph_hash: &str) -> Self {
+    pub fn new(registry: Arc<MetricsRegistry>, subgraph_hash: &str) -> Self {
         let request_duration = registry
             .global_gauge_vec(
                 "deployment_eth_rpc_request_duration",
@@ -811,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();
     }
 }
@@ -828,8 +1201,6 @@ impl SubgraphEthRpcMetrics {
 /// or a remote node over RPC.
 #[async_trait]
 pub trait EthereumAdapter: Send + Sync + 'static {
-    fn url_hostname(&self) -> &str;
-
     /// The `provider.label` from the adapter's configuration
     fn provider(&self) -> &str;
 
@@ -837,98 +1208,102 @@ 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.
-    fn load_blocks(
+    async fn load_blocks(
         &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;
@@ -954,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>()
                 )
@@ -965,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
@@ -985,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);
     }
 
@@ -1001,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()],
         };
 
@@ -1012,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]]))),
@@ -1034,6 +1401,7 @@ mod tests {
                 wildcard_signatures: HashSet::new(),
             },
             block: EthereumBlockFilter {
+                polling_intervals: HashSet::from_iter(vec![(1, 10), (3, 24)]),
                 contract_addresses: HashSet::from_iter([
                     (100, address(1000)),
                     (200, address(2000)),
@@ -1047,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,
@@ -1090,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()],
             },
         ];
 
@@ -1137,37 +1502,35 @@ mod tests {
             filter.event_signatures.sort();
         }
         assert_eq!(expected_log_filters, actual_log_filters);
-        assert_eq!(false, 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(),
             },
             block: EthereumBlockFilter {
+                polling_intervals: HashSet::default(),
                 contract_addresses: HashSet::new(),
                 trigger_every_block: true,
             },
         };
 
-        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();
@@ -1202,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]
@@ -1229,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"
         );
@@ -1307,11 +1657,13 @@ mod tests {
     #[test]
     fn extending_ethereum_block_filter_no_found() {
         let mut base = EthereumBlockFilter {
+            polling_intervals: HashSet::new(),
             contract_addresses: HashSet::new(),
             trigger_every_block: false,
         };
 
         let extension = EthereumBlockFilter {
+            polling_intervals: HashSet::from_iter(vec![(1, 3)]),
             contract_addresses: HashSet::from_iter(vec![(10, address(1))]),
             trigger_every_block: false,
         };
@@ -1322,16 +1674,20 @@ mod tests {
             HashSet::from_iter(vec![(10, address(1))]),
             base.contract_addresses,
         );
+
+        assert_eq!(HashSet::from_iter(vec![(1, 3)]), base.polling_intervals,);
     }
 
     #[test]
-    fn extending_ethereum_block_filter_conflict_picks_lowest_block_from_ext() {
+    fn extending_ethereum_block_filter_conflict_includes_one_copy() {
         let mut base = EthereumBlockFilter {
+            polling_intervals: HashSet::from_iter(vec![(3, 3)]),
             contract_addresses: HashSet::from_iter(vec![(10, address(1))]),
             trigger_every_block: false,
         };
 
         let extension = EthereumBlockFilter {
+            polling_intervals: HashSet::from_iter(vec![(2, 3), (3, 3)]),
             contract_addresses: HashSet::from_iter(vec![(2, address(1))]),
             trigger_every_block: false,
         };
@@ -1342,16 +1698,23 @@ mod tests {
             HashSet::from_iter(vec![(2, address(1))]),
             base.contract_addresses,
         );
+
+        assert_eq!(
+            HashSet::from_iter(vec![(2, 3), (3, 3)]),
+            base.polling_intervals,
+        );
     }
 
     #[test]
-    fn extending_ethereum_block_filter_conflict_picks_lowest_block_from_base() {
+    fn extending_ethereum_block_filter_conflict_doesnt_include_both_copies() {
         let mut base = EthereumBlockFilter {
+            polling_intervals: HashSet::from_iter(vec![(2, 3)]),
             contract_addresses: HashSet::from_iter(vec![(2, address(1))]),
             trigger_every_block: false,
         };
 
         let extension = EthereumBlockFilter {
+            polling_intervals: HashSet::from_iter(vec![(3, 3), (2, 3)]),
             contract_addresses: HashSet::from_iter(vec![(10, address(1))]),
             trigger_every_block: false,
         };
@@ -1362,116 +1725,118 @@ mod tests {
             HashSet::from_iter(vec![(2, address(1))]),
             base.contract_addresses,
         );
+
+        assert_eq!(
+            HashSet::from_iter(vec![(2, 3), (3, 3)]),
+            base.polling_intervals,
+        );
     }
 
     #[test]
     fn extending_ethereum_block_filter_every_block_in_ext() {
         let mut base = EthereumBlockFilter {
+            polling_intervals: HashSet::new(),
             contract_addresses: HashSet::default(),
             trigger_every_block: false,
         };
 
         let extension = EthereumBlockFilter {
+            polling_intervals: HashSet::new(),
             contract_addresses: HashSet::default(),
             trigger_every_block: true,
         };
 
         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() {
+    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))]),
             trigger_every_block: true,
         };
 
         let extension = EthereumBlockFilter {
+            polling_intervals: HashSet::new(),
             contract_addresses: HashSet::from_iter(vec![]),
             trigger_every_block: false,
         };
 
         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,
         );
+        assert_eq!(HashSet::from_iter(vec![(10, 3)]), base.polling_intervals,);
     }
 
     #[test]
     fn extending_ethereum_block_filter_every_block_in_ext_and_merge_contract_addresses() {
         let mut base = EthereumBlockFilter {
+            polling_intervals: HashSet::from_iter(vec![(10, 3)]),
             contract_addresses: HashSet::from_iter(vec![(10, address(2))]),
             trigger_every_block: false,
         };
 
         let extension = EthereumBlockFilter {
+            polling_intervals: HashSet::from_iter(vec![(10, 3)]),
             contract_addresses: HashSet::from_iter(vec![(10, address(1))]),
             trigger_every_block: true,
         };
 
         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,
         );
+        assert_eq!(
+            HashSet::from_iter(vec![(10, 3), (10, 3)]),
+            base.polling_intervals,
+        );
     }
 
     #[test]
     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 {
@@ -1487,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,
@@ -1505,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!(
@@ -1538,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);
@@ -1583,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,
+        )],
+    );
+    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!(!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)));
+    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/capabilities.rs b/chain/ethereum/src/capabilities.rs
index d1296c4f45c..a036730ad0d 100644
--- a/chain/ethereum/src/capabilities.rs
+++ b/chain/ethereum/src/capabilities.rs
@@ -1,9 +1,6 @@
-use anyhow::Error;
 use graph::impl_slog_value;
 use std::cmp::Ordering;
-use std::collections::BTreeSet;
 use std::fmt;
-use std::str::FromStr;
 
 use crate::DataSource;
 
@@ -17,7 +14,7 @@ pub struct NodeCapabilities {
 /// other. No [`Ord`] (i.e. total order) implementation is applicable.
 impl PartialOrd for NodeCapabilities {
     fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
-        product_order([
+        product_order(&[
             self.archive.cmp(&other.archive),
             self.traces.cmp(&other.traces),
         ])
@@ -26,7 +23,7 @@ impl PartialOrd for NodeCapabilities {
 
 /// Defines a [product order](https://en.wikipedia.org/wiki/Product_order) over
 /// an array of [`Ordering`].
-fn product_order<const N: usize>(cmps: [Ordering; N]) -> Option<Ordering> {
+fn product_order(cmps: &[Ordering]) -> Option<Ordering> {
     if cmps.iter().all(|c| c.is_eq()) {
         Some(Ordering::Equal)
     } else if cmps.iter().all(|c| c.is_le()) {
@@ -38,18 +35,6 @@ fn product_order<const N: usize>(cmps: [Ordering; N]) -> Option<Ordering> {
     }
 }
 
-impl FromStr for NodeCapabilities {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let capabilities: BTreeSet<&str> = s.split(',').collect();
-        Ok(NodeCapabilities {
-            archive: capabilities.contains("archive"),
-            traces: capabilities.contains("traces"),
-        })
-    }
-}
-
 impl fmt::Display for NodeCapabilities {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let NodeCapabilities { archive, traces } = self;
diff --git a/chain/ethereum/src/chain.rs b/chain/ethereum/src/chain.rs
index 9eeda321ed5..405c3123bdc 100644
--- a/chain/ethereum/src/chain.rs
+++ b/chain/ethereum/src/chain.rs
@@ -1,43 +1,58 @@
-use anyhow::{anyhow, Result};
 use anyhow::{Context, Error};
+use anyhow::{Result, anyhow, bail};
+use async_trait::async_trait;
 use graph::blockchain::client::ChainClient;
-use graph::blockchain::{BlockchainKind, TriggersAdapterSelector};
+use graph::blockchain::firehose_block_ingestor::{FirehoseBlockIngestor, Transforms};
+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, EthereumBlock, EthereumCallCache, LightEthereumBlock, LightEthereumBlockExt,
+    BlockHash, ComponentLoggerConfig, ElasticComponentLoggerConfig, EthereumBlock,
+    EthereumCallCache, LightEthereumBlock, LightEthereumBlockExt, MetricsRegistry, StoreError,
+    retry,
 };
+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, MetricsRegistry, 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;
 
 use crate::codec::HeaderOnlyBlock;
 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},
@@ -45,13 +60,53 @@ use crate::{
         blocks_with_triggers, get_calls, parse_block_triggers, parse_call_triggers,
         parse_log_triggers,
     },
-    SubgraphEthRpcMetrics, TriggerFilter, ENV_VARS,
 };
-use graph::blockchain::block_stream::{BlockStream, BlockStreamBuilder, FirehoseCursor};
-
+use crate::{EthereumAdapter, RuntimeAdapter};
+use graph::blockchain::block_stream::{
+    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]
@@ -76,39 +131,124 @@ impl BlockStreamBuilder<Chain> for EthereumStreamBuilder {
                 )
             });
 
-        let firehose_endpoint = chain.chain_client().firehose_endpoint()?;
-
         let logger = chain
             .logger_factory
             .subgraph_logger(&deployment)
             .new(o!("component" => "FirehoseBlockStream"));
 
-        let firehose_mapper = Arc::new(FirehoseMapper {});
+        let firehose_mapper = Arc::new(FirehoseMapper { adapter, filter });
 
         Ok(Box::new(FirehoseBlockStream::new(
             deployment.hash,
-            firehose_endpoint,
+            chain.chain_client(),
             subgraph_current_block,
             block_cursor,
             firehose_mapper,
-            adapter,
-            filter,
             start_blocks,
             logger,
             chain.registry.clone(),
         )))
     }
 
+    async fn build_subgraph_block_stream(
+        &self,
+        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>>> {
+        self.build_polling(
+            chain,
+            deployment,
+            start_blocks,
+            source_subgraph_stores,
+            subgraph_current_block,
+            filter,
+            unified_api_version,
+        )
+        .await
+    }
+
     async fn build_polling(
         &self,
-        _chain: Arc<Chain>,
-        _deployment: DeploymentLocator,
-        _start_blocks: Vec<BlockNumber>,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<<Chain as Blockchain>::TriggerFilter>,
-        _unified_api_version: UnifiedMappingApiVersion,
+        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>>> {
-        todo!()
+        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_head_update_stream = chain
+            .chain_head_update_listener
+            .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 reorg_threshold = match chain.chain_client().as_ref() {
+            ChainClient::Rpc(adapter) => {
+                let chain_id = adapter
+                    .cheapest()
+                    .await
+                    .ok_or(anyhow!("unable to get eth adapter for chan_id call"))?
+                    .chain_id()
+                    .await?;
+
+                if CELO_CHAIN_IDS.contains(&chain_id) {
+                    0
+                } else {
+                    chain.reorg_threshold
+                }
+            }
+            _ if is_using_subgraph_composition => chain.reorg_threshold,
+            _ => panic!(
+                "expected rpc when using polling blockstream : {}",
+                is_using_subgraph_composition
+            ),
+        };
+
+        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_head_update_stream,
+            Arc::new(adapter),
+            deployment.hash,
+            filter,
+            start_blocks,
+            reorg_threshold,
+            logger,
+            max_block_range_size,
+            chain.settings.target_triggers_per_block_range,
+            unified_api_version,
+            subgraph_current_block,
+        )))
     }
 }
 
@@ -126,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))
@@ -136,22 +276,25 @@ impl BlockRefetcher<Chain> for EthereumBlockRefetcher {
 pub struct EthereumAdapterSelector {
     logger_factory: LoggerFactory,
     client: Arc<ChainClient<Chain>>,
-    registry: Arc<dyn MetricsRegistry>,
+    registry: Arc<MetricsRegistry>,
     chain_store: Arc<dyn ChainStore>,
+    eth_adapters: Arc<EthereumNetworkAdapters>,
 }
 
 impl EthereumAdapterSelector {
     pub fn new(
         logger_factory: LoggerFactory,
         client: Arc<ChainClient<Chain>>,
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
         chain_store: Arc<dyn ChainStore>,
+        eth_adapters: Arc<EthereumNetworkAdapters>,
     ) -> Self {
         Self {
             logger_factory,
             client,
             registry,
             chain_store,
+            eth_adapters,
         }
     }
 }
@@ -177,16 +320,45 @@ 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,
-    registry: Arc<dyn MetricsRegistry>,
+    pub name: ChainName,
+    registry: Arc<MetricsRegistry>,
     client: Arc<ChainClient<Self>>,
     chain_store: Arc<dyn ChainStore>,
     call_cache: Arc<dyn EthereumCallCache>,
@@ -196,7 +368,9 @@ pub struct 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>,
+    pub settings: Arc<ChainSettings>,
 }
 
 impl std::fmt::Debug for Chain {
@@ -205,13 +379,44 @@ 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,
-        registry: Arc<dyn MetricsRegistry>,
+        name: ChainName,
+        registry: Arc<MetricsRegistry>,
         chain_store: Arc<dyn ChainStore>,
         call_cache: Arc<dyn EthereumCallCache>,
         client: Arc<ChainClient<Self>>,
@@ -219,14 +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,
         is_ingestible: bool,
+        settings: Arc<ChainSettings>,
     ) -> Self {
         Chain {
             logger_factory,
             name,
-            node_id,
             registry,
             client,
             chain_store,
@@ -235,9 +441,11 @@ impl Chain {
             block_stream_builder,
             block_refetcher,
             adapter_selector,
-            runtime_adapter,
+            runtime_adapter_builder,
+            eth_adapters,
             reorg_threshold,
             is_ingestible,
+            settings,
         }
     }
 
@@ -246,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()
     }
 }
 
@@ -282,6 +497,8 @@ impl Blockchain for Chain {
 
     type NodeCapabilities = crate::capabilities::NodeCapabilities;
 
+    type DecoderHook = crate::data_source::DecoderHook;
+
     fn triggers_adapter(
         &self,
         loc: &DeploymentLocator,
@@ -292,93 +509,64 @@ impl Blockchain for Chain {
             .triggers_adapter(loc, capabilities, unified_api_version)
     }
 
-    async fn new_firehose_block_stream(
-        &self,
-        deployment: DeploymentLocator,
-        block_cursor: FirehoseCursor,
-        start_blocks: Vec<BlockNumber>,
-        subgraph_current_block: Option<BlockPtr>,
-        filter: Arc<Self::TriggerFilter>,
-        unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        self.block_stream_builder
-            .build_firehose(
-                self,
-                deployment,
-                block_cursor,
-                start_blocks,
-                subgraph_current_block,
-                filter,
-                unified_api_version,
-            )
-            .await
-    }
-
-    async fn new_polling_block_stream(
+    async fn new_block_stream(
         &self,
         deployment: DeploymentLocator,
+        store: impl DeploymentCursorTracker,
         start_blocks: Vec<BlockNumber>,
-        subgraph_current_block: Option<BlockPtr>,
-        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 requirements = filter.node_capabilities();
-        let adapter = self
-            .triggers_adapter(&deployment, &requirements, unified_api_version.clone())
-            .unwrap_or_else(|_| {
-                panic!(
-                    "no adapter for network {} with capabilities {}",
-                    self.name, requirements
+        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,
                 )
-            });
-
-        let logger = self
-            .logger_factory
-            .subgraph_logger(&deployment)
-            .new(o!("component" => "BlockStream"));
-        let chain_store = self.chain_store().clone();
-        let chain_head_update_stream = self
-            .chain_head_update_listener
-            .subscribe(self.name.clone(), logger.clone());
+                .await;
+        }
 
-        // 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 self.client.as_ref() {
-            ChainClient::Rpc(adapter) => {
-                adapter
-                    .cheapest()
-                    .ok_or(anyhow!("unable to get eth adapter for chan_id call"))?
-                    .chain_id()
-                    .await?
+        match self.chain_client().as_ref() {
+            ChainClient::Rpc(_) => {
+                self.block_stream_builder
+                    .build_polling(
+                        self,
+                        deployment,
+                        start_blocks,
+                        source_subgraph_stores,
+                        current_ptr,
+                        filter,
+                        unified_api_version,
+                    )
+                    .await
             }
-            _ => panic!("expected rpc when using polling blockstream"),
-        };
-        let reorg_threshold = match CELO_CHAIN_IDS.contains(&chain_id) {
-            false => self.reorg_threshold,
-            true => 0,
-        };
-
-        Ok(Box::new(PollingBlockStream::new(
-            chain_store,
-            chain_head_update_stream,
-            adapter,
-            self.node_id.clone(),
-            deployment.hash,
-            filter,
-            start_blocks,
-            reorg_threshold,
-            logger,
-            ENV_VARS.max_block_range_size,
-            ENV_VARS.target_triggers_per_block_range,
-            unified_api_version,
-            subgraph_current_block,
-        )))
+            ChainClient::Firehose(_) => {
+                self.block_stream_builder
+                    .build_firehose(
+                        self,
+                        deployment,
+                        store.firehose_cursor(),
+                        start_blocks,
+                        current_ptr,
+                        filter.chain_filter.clone(),
+                        unified_api_version,
+                    )
+                    .await
+            }
+        }
     }
 
-    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(
@@ -388,20 +576,34 @@ impl Blockchain for Chain {
     ) -> Result<BlockPtr, IngestorError> {
         match self.client.as_ref() {
             ChainClient::Firehose(endpoints) => endpoints
-                .random()?
+                .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)
             }
         }
     }
@@ -418,13 +620,82 @@ 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()
     }
+
+    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().as_head_store(),
+                    self.chain_client(),
+                    self.logger_factory
+                        .component_logger("EthereumFirehoseBlockIngestor", None),
+                    self.name.clone(),
+                );
+                let ingestor = ingestor.with_transforms(vec![Transforms::EthereumHeaderOnly]);
+
+                Box::new(ingestor)
+            }
+            ChainClient::Rpc(_) => {
+                let logger = self
+                    .logger_factory
+                    .component_logger(
+                        "EthereumPollingBlockIngestor",
+                        Some(ComponentLoggerConfig {
+                            elastic: Some(ElasticComponentLoggerConfig {
+                                index: String::from("block-ingestor-logs"),
+                            }),
+                        }),
+                    )
+                    .new(o!());
+
+                if !self.is_ingestible {
+                    bail!(
+                        "Not starting block ingestor (chain is defective), network_name {}",
+                        &self.name
+                    );
+                }
+
+                // The block ingestor must be configured to keep at least REORG_THRESHOLD ancestors,
+                // because the json-rpc BlockStream expects blocks after the reorg threshold to be
+                // present in the DB.
+                Box::new(PollingBlockIngestor::new(
+                    logger,
+                    graph::env::ENV_VARS.reorg_threshold(),
+                    self.chain_client(),
+                    self.chain_store.cheap_clone(),
+                    self.settings.polling_interval,
+                    self.name.clone(),
+                )?)
+            }
+        };
+
+        Ok(ingestor)
+    }
 }
 
 /// This is used in `EthereumAdapter::triggers_in_block`, called when re-processing a block for
@@ -437,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 {
@@ -450,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"),
         }
     }
 }
@@ -468,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),
         }
     }
 
@@ -475,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))
+            }
         }
     }
 
@@ -507,6 +776,21 @@ 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 {
+        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,
         }
     }
 }
@@ -520,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]
@@ -529,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(),
@@ -543,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,
@@ -561,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(),
@@ -587,80 +1070,281 @@ 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())),
-                    )
-                    .collect()
-                    .compat()
-                    .await?;
-                assert_eq!(blocks.len(), 1);
-
-                blocks[0].parent_ptr()
+            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));
+                }
+
+                // 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)
     }
 }
 
-pub struct FirehoseMapper {}
+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>,
+}
+
+#[async_trait]
+impl BlockStreamMapper<Chain> for FirehoseMapper {
+    fn decode_block(
+        &self,
+        output: Option<&[u8]>,
+    ) -> Result<Option<BlockFinality>, BlockStreamError> {
+        let block = match output {
+            Some(block) => codec::Block::decode(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
+        // is empty
+        let ethereum_block: EthereumBlockWithCalls = (&block).try_into()?;
+
+        Ok(Some(BlockFinality::NonFinal(ethereum_block)))
+    }
+
+    async fn block_with_triggers(
+        &self,
+        logger: &Logger,
+        block: BlockFinality,
+    ) -> Result<BlockWithTriggers<Chain>, BlockStreamError> {
+        self.adapter
+            .triggers_in_block(logger, block, &self.filter)
+            .await
+            .map_err(BlockStreamError::from)
+    }
+}
 
 #[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,
-        adapter: &Arc<dyn TriggersAdapterTrait<Chain>>,
-        filter: &TriggerFilter,
     ) -> 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
@@ -683,15 +1367,9 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
         use firehose::ForkStep::*;
         match step {
             StepNew => {
-                // See comment(437a9f17-67cc-478f-80a3-804fe554b227) ethereum_block.calls is always Some even if calls
-                // is empty
-                let ethereum_block: EthereumBlockWithCalls = (&block).try_into()?;
-
-                // triggers in block never actually calls the ethereum traces api.
-                // TODO: Split the trigger parsing from call retrieving.
-                let block_with_triggers = adapter
-                    .triggers_in_block(logger, BlockFinality::NonFinal(ethereum_block), filter)
-                    .await?;
+                // unwrap: Input cannot be None so output will be error or block.
+                let block = self.decode_block(Some(any_block.value.as_ref()))?.unwrap();
+                let block_with_triggers = self.block_with_triggers(logger, block).await?;
 
                 Ok(BlockStreamEvent::ProcessBlock(
                     block_with_triggers,
@@ -711,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 => {
@@ -749,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 3f800dff0a5..b40bcd11910 100644
--- a/chain/ethereum/src/codec.rs
+++ b/chain/ethereum/src/codec.rs
@@ -1,15 +1,26 @@
 #[rustfmt::skip]
+#[allow(clippy::doc_lazy_continuation, clippy::doc_overindented_list_items)]
 #[path = "protobuf/sf.ethereum.r#type.v2.rs"]
 mod pbcodec;
 
 use anyhow::format_err;
 use graph::{
-    blockchain::{Block as BlockchainBlock, BlockPtr, ChainStoreBlock, ChainStoreData},
+    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;
@@ -32,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)
     }
 }
 
@@ -66,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")?),
@@ -77,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,
@@ -124,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,
@@ -180,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
         })
     }
 }
@@ -232,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.
@@ -391,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,
             ))),
         }
@@ -405,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))
     }
 }
 
@@ -449,6 +783,11 @@ impl BlockchainBlock for Block {
     fn data(&self) -> Result<jsonrpc_core::serde_json::Value, jsonrpc_core::serde_json::Error> {
         self.header().to_json()
     }
+
+    fn timestamp(&self) -> BlockTime {
+        let ts = self.header().timestamp.as_ref().unwrap();
+        BlockTime::since_epoch(ts.seconds, ts.nanos as u32)
+    }
 }
 
 impl HeaderOnlyBlock {
@@ -502,6 +841,38 @@ impl BlockchainBlock for HeaderOnlyBlock {
     fn data(&self) -> Result<jsonrpc_core::serde_json::Value, jsonrpc_core::serde_json::Error> {
         self.header().to_json()
     }
+
+    fn timestamp(&self) -> blockchain::BlockTime {
+        let ts = self.header().timestamp.as_ref().unwrap();
+        blockchain::BlockTime::since_epoch(ts.seconds, ts.nanos as u32)
+    }
+}
+
+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)]
@@ -516,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();
 
@@ -533,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 13c9f6fe62b..709884496e8 100644
--- a/chain/ethereum/src/data_source.rs
+++ b/chain/ethereum/src/data_source.rs
@@ -1,37 +1,68 @@
-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},
-        info, 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};
+use graph::data::subgraph::{
+    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.
 const ETHEREUM_KINDS: &[&str] = &["ethereum/contract", "ethereum"];
+const EVENT_HANDLER_KIND: &str = "event";
+const CALL_HANDLER_KIND: &str = "call";
+const BLOCK_HANDLER_KIND: &str = "block";
 
 /// Runtime representation of a data source.
 // Note: Not great for memory usage that this needs to be `Clone`, considering how there may be tens
@@ -44,6 +75,7 @@ pub struct DataSource {
     pub manifest_idx: u32,
     pub address: Option<Address>,
     pub start_block: BlockNumber,
+    pub end_block: Option<BlockNumber>,
     pub mapping: Mapping,
     pub context: Arc<Option<DataSourceContext>>,
     pub creation_block: Option<BlockNumber>,
@@ -51,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",
@@ -86,13 +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: 0,
-            mapping: template.mapping,
+            start_block: creation_block,
+            end_block: None,
+            mapping: template.mapping.clone(),
             context: Arc::new(context),
             creation_block: Some(creation_block),
             contract_abi,
@@ -100,13 +139,47 @@ 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> {
+        let mut kinds = HashSet::new();
+
+        let Mapping {
+            event_handlers,
+            call_handlers,
+            block_handlers,
+            ..
+        } = &self.mapping;
+
+        if !event_handlers.is_empty() {
+            kinds.insert(EVENT_HANDLER_KIND);
+        }
+        if !call_handlers.is_empty() {
+            kinds.insert(CALL_HANDLER_KIND);
+        }
+        for handler in block_handlers.iter() {
+            kinds.insert(handler.kind());
+        }
+
+        kinds
     }
 
     fn start_block(&self) -> BlockNumber {
         self.start_block
     }
 
+    fn end_block(&self) -> Option<BlockNumber> {
+        self.end_block
+    }
+
     fn match_and_decode(
         &self,
         trigger: &<Chain as Blockchain>::TriggerData,
@@ -146,12 +219,12 @@ impl blockchain::DataSource<Chain> for DataSource {
             address,
             mapping,
             context,
-
             // The creation block is ignored for detection duplicate data sources.
             // Contract ABI equality is implicit in `mapping.abis` equality.
             creation_block: _,
             contract_abi: _,
             start_block: _,
+            end_block: _,
         } = self;
 
         // mapping_request_sender, host_metrics, and (most of) host_exports are operational structs
@@ -170,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,
@@ -209,14 +282,15 @@ 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()),
             name: template.name.clone(),
             manifest_idx,
             address,
-            start_block: 0,
+            start_block: creation_block.unwrap_or(0),
+            end_block: None,
             mapping: template.mapping.clone(),
             context: Arc::new(context),
             creation_block,
@@ -224,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()) {
@@ -242,23 +316,50 @@ impl blockchain::DataSource<Chain> for DataSource {
             errors.push(SubgraphManifestValidationError::SourceAddressRequired.into());
         };
 
-        // Validate that there are no more than one of each type of block_handler
-        let has_too_many_block_handlers = {
-            let mut non_filtered_block_handler_count = 0;
-            let mut call_filtered_block_handler_count = 0;
-            self.mapping
-                .block_handlers
-                .iter()
-                .for_each(|block_handler| {
-                    if block_handler.filter.is_none() {
-                        non_filtered_block_handler_count += 1
-                    } else {
-                        call_filtered_block_handler_count += 1
-                    }
-                });
-            non_filtered_block_handler_count > 1 || call_filtered_block_handler_count > 1
-        };
-        if has_too_many_block_handlers {
+        // Ensure that there is at most one instance of each type of block handler
+        // and that a combination of a non-filtered block handler and a filtered block handler is not allowed.
+
+        let mut non_filtered_block_handler_count = 0;
+        let mut call_filtered_block_handler_count = 0;
+        let mut polling_filtered_block_handler_count = 0;
+        let mut initialization_handler_count = 0;
+        self.mapping
+            .block_handlers
+            .iter()
+            .for_each(|block_handler| {
+                match block_handler.filter {
+                    None => non_filtered_block_handler_count += 1,
+                    Some(ref filter) => match filter {
+                        BlockHandlerFilter::Call => call_filtered_block_handler_count += 1,
+                        BlockHandlerFilter::Once => initialization_handler_count += 1,
+                        BlockHandlerFilter::Polling { every: _ } => {
+                            polling_filtered_block_handler_count += 1
+                        }
+                    },
+                };
+            });
+
+        let has_non_filtered_block_handler = non_filtered_block_handler_count > 0;
+        // If there is a non-filtered block handler, we need to check if there are any
+        // filtered block handlers except for the ones with call filter
+        // If there are, we do not allow that combination
+        let has_restricted_filtered_and_non_filtered_combination = has_non_filtered_block_handler
+            && (polling_filtered_block_handler_count > 0 || initialization_handler_count > 0);
+
+        if has_restricted_filtered_and_non_filtered_combination {
+            errors.push(anyhow!(
+                "data source has a combination of filtered and non-filtered block handlers that is not allowed"
+            ));
+        }
+
+        // Check the number of handlers for each type
+        // If there is more than one of any type, we have too many handlers
+        let has_too_many = non_filtered_block_handler_count > 1
+            || call_filtered_block_handler_count > 1
+            || initialization_handler_count > 1
+            || polling_filtered_block_handler_count > 1;
+
+        if has_too_many {
             errors.push(anyhow!("data source has duplicated block handlers"));
         }
 
@@ -276,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
     }
 
@@ -283,11 +411,69 @@ impl blockchain::DataSource<Chain> for DataSource {
         self.mapping.api_version.clone()
     }
 
+    fn min_spec_version(&self) -> semver::Version {
+        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>>> {
         Some(self.mapping.runtime.cheap_clone())
     }
 }
 
+/// 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,
@@ -311,6 +497,7 @@ impl DataSource {
             manifest_idx,
             address: source.address,
             start_block: source.start_block,
+            end_block: source.end_block,
             mapping,
             context: Arc::new(context),
             creation_block,
@@ -318,22 +505,16 @@ impl DataSource {
         })
     }
 
-    fn handlers_for_log(&self, log: &Log) -> Result<Vec<MappingEventHandler>, Error> {
-        // Get signature from the log
-        let topic0 = log.topics.get(0).context("Ethereum event has no topics")?;
-
-        let handlers = self
-            .mapping
+    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<_>>();
-
-        Ok(handlers)
+            .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!(
@@ -343,60 +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,
-    ) -> Option<MappingBlockHandler> {
+        block: BlockNumber,
+    ) -> Option<&MappingBlockHandler> {
         match trigger_type {
-            EthereumBlockTriggerType::Every => self
-                .mapping
-                .block_handlers
-                .iter()
-                .find(move |handler| handler.filter.is_none())
-                .cloned(),
+            // 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,
+                    })
+            }
+            // 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;
+                            (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,
@@ -406,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()
@@ -478,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()
@@ -492,32 +661,25 @@ 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
             })
     }
 
     fn matches_trigger_address(&self, trigger: &EthereumTrigger) -> bool {
-        let ds_address = match self.address {
-            Some(addr) => addr,
-
+        let Some(ds_address) = self.address else {
             // 'wildcard' data sources match any trigger address.
-            None => return true,
+            return true;
         };
 
-        let trigger_address = match trigger {
-            EthereumTrigger::Block(_, EthereumBlockTriggerType::WithCallTo(address)) => address,
-            EthereumTrigger::Call(call) => &call.to,
-            EthereumTrigger::Log(log, _) => &log.address,
-
-            // Unfiltered block triggers match any data source address.
-            EthereumTrigger::Block(_, EthereumBlockTriggerType::Every) => return true,
+        let Some(trigger_address) = trigger.address() else {
+            return true;
         };
 
         ds_address == *trigger_address
@@ -541,7 +703,7 @@ impl DataSource {
 
         match trigger {
             EthereumTrigger::Block(_, trigger_type) => {
-                let handler = match self.handler_for_block(trigger_type) {
+                let handler = match self.handler_for_block(trigger_type, block.number()) {
                     Some(handler) => handler,
                     None => return Ok(None),
                 };
@@ -549,12 +711,15 @@ impl DataSource {
                     MappingTrigger::Block {
                         block: block.cheap_clone(),
                     },
-                    handler.handler,
+                    handler.handler.clone(),
                     block.block_ptr(),
+                    block.timestamp(),
                 )))
             }
-            EthereumTrigger::Log(log, receipt) => {
-                let potential_handlers = self.handlers_for_log(log)?;
+            EthereumTrigger::Log(log_ref) => {
+                let log = Arc::new(log_ref.log().clone());
+                let receipt = log_ref.receipt();
+                let potential_handlers = self.handlers_for_log(&log);
 
                 // Map event handlers to (event handler, event ABI) pairs; fail if there are
                 // handlers that don't exist in the contract ABI
@@ -586,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,
@@ -627,37 +788,49 @@ 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)
+                        .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.cheap_clone(),
+                        log,
                         params,
-                        receipt: receipt.clone(),
+                        receipt: receipt.map(|r| r.cheap_clone()),
+                        calls,
                     },
-                    event_handler.handler,
+                    handler,
                     block.block_ptr(),
+                    block.timestamp(),
                     logging_extras,
                 )))
             }
@@ -681,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) => {
@@ -704,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: {}",
@@ -734,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<_>>();
 
@@ -756,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 {
@@ -766,8 +929,9 @@ impl DataSource {
                         inputs,
                         outputs,
                     },
-                    handler.handler,
+                    handler.handler.clone(),
                     block.block_ptr(),
+                    block.timestamp(),
                     logging_extras,
                 )))
             }
@@ -775,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,
@@ -789,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,
@@ -802,15 +1218,18 @@ impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
             context,
         } = self;
 
-        info!(logger, "Resolve data source"; "name" => &name, "source_address" => format_args!("{:?}", source.address), "source_start_block" => source.start_block);
-
-        let mapping = mapping.resolve(resolver, logger).await?;
+        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
+            )
+        })?;
 
         DataSource::from_manifest(kind, network, name, source, mapping, context, manifest_idx)
     }
 }
 
-#[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>,
@@ -833,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,
@@ -845,7 +1266,10 @@ impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTem
             mapping,
         } = self;
 
-        info!(logger, "Resolve data source template"; "name" => &name);
+        let mapping = mapping
+            .resolve(deployment_hash, resolver, logger, spec_version)
+            .await
+            .with_context(|| format!("failed to resolve data source template {}", name))?;
 
         Ok(DataSourceTemplate {
             kind,
@@ -853,7 +1277,7 @@ impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTem
             name,
             manifest_idx,
             source,
-            mapping: mapping.resolve(resolver, logger).await?,
+            mapping,
         })
     }
 }
@@ -874,9 +1298,13 @@ impl blockchain::DataSourceTemplate<Chain> for DataSourceTemplate {
     fn manifest_idx(&self) -> u32 {
         self.manifest_idx
     }
+
+    fn kind(&self) -> &str {
+        &self.kind
+    }
 }
 
-#[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,
@@ -889,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,
 }
 
@@ -921,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()
@@ -935,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,
@@ -950,88 +1382,92 @@ impl UnresolvedMapping {
             file: link,
         } = self;
 
-        info!(logger, "Resolve mapping"; "link" => &link.link);
-
         let api_version = semver::Version::parse(&api_version)?;
 
         let (abis, runtime) = try_join(
             // 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?;
+        .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> {
-        info!(
-            logger,
-            "Resolve ABI";
-            "name" => &self.name,
-            "link" => &self.file.link
-        );
-
-        let contract_bytes = resolver.cat(logger, &self.file).await?;
-        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,
     pub filter: Option<BlockHandlerFilter>,
 }
 
+impl MappingBlockHandler {
+    pub fn kind(&self) -> &str {
+        match &self.filter {
+            Some(filter) => match filter {
+                BlockHandlerFilter::Call => "block_filter_call",
+                BlockHandlerFilter::Once => "block_filter_once",
+                BlockHandlerFilter::Polling { .. } => "block_filter_polling",
+            },
+            None => BLOCK_HANDLER_KIND,
+        }
+    }
+}
+
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
 #[serde(tag = "kind", rename_all = "lowercase")]
 pub enum BlockHandlerFilter {
     // Call filter will trigger on all blocks where the data source contract
     // address has been called
     Call,
+    // This filter will trigger once at the startBlock
+    Once,
+    // This filter will trigger in a recurring interval set by the `every` field.
+    Polling { every: NonZeroU32 },
 }
 
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
@@ -1040,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 46a256cd4e8..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,16 +13,13 @@ 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,
 
-    /// Set by the environment variable `ETHEREUM_REORG_THRESHOLD`. The default
-    /// value is 250 blocks.
-    pub reorg_threshold: BlockNumber,
     /// Set by the environment variable `ETHEREUM_TRACE_STREAM_STEP_SIZE`. The
     /// default value is 50 blocks.
     pub trace_stream_step_size: BlockNumber,
@@ -36,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`.
@@ -49,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
@@ -83,6 +87,14 @@ pub struct EnvVars {
     /// Set by the flag `GRAPH_ETHEREUM_GENESIS_BLOCK_NUMBER`. The default value
     /// is 0.
     pub genesis_block_number: u64,
+    /// Set by the flag `GRAPH_ETH_CALL_NO_GAS`.
+    /// 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
@@ -102,18 +114,21 @@ 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)
                 .collect(),
-            reorg_threshold: x.reorg_threshold,
             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,
@@ -124,6 +139,13 @@ impl From<Inner> for EnvVars {
             cleanup_blocks: x.cleanup_blocks.0,
             target_triggers_per_block_range: x.target_triggers_per_block_range,
             genesis_block_number: x.genesis_block_number,
+            eth_call_no_gas: x
+                .eth_call_no_gas
+                .split(',')
+                .filter(|s| !s.is_empty())
+                .map(str::to_string)
+                .collect(),
+            force_rpc_for_block_ptrs: x.force_rpc_for_block_ptrs.0,
         }
     }
 }
@@ -136,24 +158,25 @@ 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,
 
-    // JSON-RPC specific.
-    #[envconfig(from = "ETHEREUM_REORG_THRESHOLD", default = "250")]
-    reorg_threshold: BlockNumber,
     #[envconfig(from = "ETHEREUM_TRACE_STREAM_STEP_SIZE", default = "50")]
     trace_stream_step_size: BlockNumber,
     #[envconfig(from = "GRAPH_ETHEREUM_MAX_EVENT_ONLY_RANGE", default = "500")]
     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(
@@ -172,4 +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,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 384daacdb12..9c85f0ac551 100644
--- a/chain/ethereum/src/ethereum_adapter.rs
+++ b/chain/ethereum/src/ethereum_adapter.rs
@@ -1,38 +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::{
-    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};
@@ -40,180 +58,178 @@ 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::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,
-    url_hostname: Arc<String>,
-    /// The label for the provider from the configuration
     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>,
 }
 
-/// Gas limit for `eth_call`. The value of 50_000_000 is a protocol-wide parameter so this
-/// should be changed only for debugging purposes and never on an indexer in the network. This
-/// value was chosen because it is the Geth default
-/// https://github.com/ethereum/go-ethereum/blob/e4b687cf462870538743b3218906940ae590e7fd/eth/ethconfig/config.go#L91.
-/// It is not safe to set something higher because Geth will silently override the gas limit
-/// with the default. This means that we do not support indexing against a Geth node with
-/// `RPCGasCap` set below 50 million.
-// See also f0af4ab0-6b7c-4b68-9141-5b79346a5f61.
-const ETH_CALL_GAS: u32 = 50_000_000;
+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 {
     fn cheap_clone(&self) -> Self {
         Self {
             logger: self.logger.clone(),
             provider: self.provider.clone(),
-            url_hostname: self.url_hostname.cheap_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,
-        url: &str,
         transport: Transport,
         provider_metrics: Arc<ProviderEthRpcMetrics>,
         supports_eip_1898: bool,
         call_only: bool,
+        settings: Arc<ChainSettings>,
     ) -> Self {
-        // Unwrap: The transport was constructed with this url, so it is valid and has a host.
-        let hostname = graph::url::Url::parse(url)
-            .unwrap()
-            .host_str()
-            .unwrap()
-            .to_string();
-
-        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,
-            url_hostname: Arc::new(hostname),
-            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| {
@@ -229,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();
@@ -261,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);
@@ -286,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 = {}",
@@ -305,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 {
@@ -367,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
@@ -430,192 +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,
-    ) -> impl Future<Item = Bytes, Error = EthereumContractCallError> + Send {
-        let web3 = self.web3.clone();
+    ) -> 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);
 
-        // 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);
         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: Some(web3::types::U256::from(ETH_CALL_GAS)),
-                        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",
-                    ];
-
-                    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.
@@ -626,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(|| {
@@ -650,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
@@ -670,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(
@@ -686,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()
     }
@@ -714,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.
@@ -743,27 +987,81 @@ 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(),
         )
     }
 
+    // Used to get the block triggers with a `polling` or `once` filter
+    /// `polling_filter_type` is used to differentiate between `polling` and `once` filters
+    /// A `polling_filter_type` value of  `BlockPollingFilterType::Once` is the case for
+    /// intialization triggers
+    /// A `polling_filter_type` value of  `BlockPollingFilterType::Polling` is the case for
+    /// polling triggers
+    pub(crate) fn blocks_matching_polling_intervals(
+        &self,
+        logger: Logger,
+        from: i32,
+        to: i32,
+        filter: &EthereumBlockFilter,
+    ) -> Pin<
+        Box<
+            dyn std::future::Future<Output = Result<Vec<EthereumTrigger>, anyhow::Error>>
+                + std::marker::Send
+                + '_,
+        >,
+    > {
+        // Create a HashMap of block numbers to Vec<EthereumBlockTriggerType>.
+        let matching_blocks = (from..=to)
+            .filter_map(|block_number| {
+                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.keys().cloned().collect_vec(),
+        );
+
+        let block_futures = blocks_matching_polling_filter.map(move |ptrs| {
+            ptrs.into_iter()
+                .flat_map(|ptr| {
+                    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()))
+                })
+                .collect::<Vec<_>>()
+        });
+
+        block_futures.compat().boxed()
+    }
+
     pub(crate) async fn calls_in_block(
         &self,
         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(),
@@ -771,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
@@ -790,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 = `{}`",
@@ -811,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);
@@ -821,29 +1118,45 @@ impl EthereumAdapter {
         )
     }
 
+    pub(crate) fn load_ptrs_for_blocks(
+        &self,
+        logger: Logger,
+        blocks: Vec<BlockNumber>,
+    ) -> 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);
+        Box::new(self.load_block_ptrs_rpc(logger, blocks).collect())
+    }
+
     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()))
     }
 }
 
-#[async_trait]
-impl EthereumAdapterTrait for EthereumAdapter {
-    fn url_hostname(&self) -> &str {
-        &self.url_hostname
+// 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"),
     }
+}
 
+#[async_trait]
+impl EthereumAdapterTrait for EthereumAdapter {
     fn provider(&self) -> &str {
         &self.provider
     }
@@ -851,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()
                     })
@@ -875,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"))
                 }
             })
@@ -918,7 +1233,7 @@ impl EthereumAdapterTrait for EthereumAdapter {
             })?;
 
         let ident = ChainIdentifier {
-            net_version,
+            net_version: net_version.to_string(),
             genesis_block_hash,
         };
 
@@ -927,407 +1242,466 @@ 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
+                ),
+            }
+        }
+
+        let logger = self.provider_logger(logger);
+
+        if calls.is_empty() {
+            return Ok(Vec::new());
         }
 
-        // 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 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(),
+            ));
+        }
 
-        debug!(logger, "eth_call";
-            "address" => hex::encode(call.address),
-            "data" => hex::encode(&call_data)
-        );
+        let reqs: Vec<_> = calls
+            .iter()
+            .enumerate()
+            .map(|(index, call)| as_req(&logger, call, index as u32))
+            .collect::<Result<_, _>>()?;
 
-        // 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(),
-                        )
-                        .map(move |result| {
-                            // Don't block handler execution on writing to the cache.
-                            let for_cache = result.0.clone();
-                            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 (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.
-    fn load_blocks(
+    async fn load_blocks(
         &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
-            .blocks(&block_hashes.iter().map(|&b| b.into()).collect::<Vec<_>>())
+        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.
@@ -1347,22 +1721,55 @@ 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)
+            .map(move |ptrs| {
+                ptrs.into_iter()
+                    .flat_map(|ptr| {
+                        vec![
+                            EthereumTrigger::Block(ptr.clone(), EthereumBlockTriggerType::Start),
+                            EthereumTrigger::Block(ptr, EthereumBlockTriggerType::End),
+                        ]
+                    })
+                    .collect()
+            })
+            .compat()
+            .boxed();
+        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);
+        trigger_futs.push(block_futures_matching_once_filter);
+    }
+
     // Scan for Logs
     if !filter.log.is_empty() {
         let logs_future = get_logs_and_transactions(
             &eth,
-            &logger,
+            logger.clone(),
             subgraph_metrics.clone(),
             from,
             to,
@@ -1384,19 +1791,7 @@ pub(crate) async fn blocks_with_triggers(
         trigger_futs.push(calls_future)
     }
 
-    // Scan for Blocks
-    if filter.block.trigger_every_block {
-        let block_future = eth
-            .block_range_to_ptrs(logger.clone(), from, to)
-            .map(move |ptrs| {
-                ptrs.into_iter()
-                    .map(|ptr| EthereumTrigger::Block(ptr, EthereumBlockTriggerType::Every))
-                    .collect()
-            })
-            .compat()
-            .boxed();
-        trigger_futs.push(block_future)
-    } else if !filter.block.contract_addresses.is_empty() {
+    if !filter.block.contract_addresses.is_empty() {
         // To determine which blocks include a call to addresses
         // in the block filter, transform the `block_filter` into
         // a `call_filter` and run `blocks_with_calls`
@@ -1414,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.url_hostname()
-                );
-                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);
@@ -1453,10 +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)
-        .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,
@@ -1468,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| {
@@ -1499,7 +1879,7 @@ pub(crate) async fn blocks_with_triggers(
         ));
     }
 
-    Ok(blocks)
+    Ok((blocks, to))
 }
 
 pub(crate) async fn get_calls(
@@ -1528,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?
             };
@@ -1543,6 +1923,9 @@ pub(crate) async fn get_calls(
                 calls: Some(calls),
             }))
         }
+        BlockFinality::Ptr(_) => {
+            unreachable!("get_calls called with BlockFinality::Ptr")
+        }
     }
 }
 
@@ -1554,19 +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()
-                .filter(move |log| log_filter.matches(log))
-                .map(move |log| {
-                    EthereumTrigger::Log(Arc::new(log.clone()), Some(receipt.cheap_clone()))
+        .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(),
+                    )
                 })
-        })
-        .collect()
+                .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(
@@ -1594,6 +1994,39 @@ 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.
 pub(crate) fn parse_block_triggers(
     block_filter: &EthereumBlockFilter,
     block: &EthereumBlockWithCalls,
@@ -1602,10 +2035,13 @@ 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();
+    let block_ptr3 = block_ptr.cheap_clone();
+    let block_number = block_ptr.number;
+
     let mut triggers = match &block.calls {
         Some(calls) => calls
             .iter()
@@ -1620,19 +2056,32 @@ pub(crate) fn parse_block_triggers(
         None => vec![],
     };
     if trigger_every_block {
+        triggers.push(EthereumTrigger::Block(
+            block_ptr.clone(),
+            EthereumBlockTriggerType::Start,
+        ));
         triggers.push(EthereumTrigger::Block(
             block_ptr,
-            EthereumBlockTriggerType::Every,
+            EthereumBlockTriggerType::End,
         ));
+    } else if !block_filter.polling_intervals.is_empty() {
+        for trigger_type in
+            block_trigger_types_from_intervals(block_number, &block_filter.polling_intervals)
+        {
+            triggers.push(EthereumTrigger::Block(
+                block_ptr3.cheap_clone(),
+                trigger_type,
+            ));
+        }
     }
     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),
@@ -1643,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() {
@@ -1653,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"
         ))?;
@@ -1671,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"
+                )
+            }
         }
     };
 
@@ -1693,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);
         }
     }
 
@@ -1715,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))
         });
@@ -1730,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?
@@ -1748,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 {
@@ -1777,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| {
@@ -1855,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.
@@ -1912,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,
@@ -1922,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,
@@ -1932,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
             }
@@ -1952,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
@@ -1974,7 +2597,8 @@ 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(Arc::new(log), optional_receipt);
+
+        let value = EthereumTrigger::Log(LogRef::FullLog(Arc::new(log), optional_receipt));
         log_triggers.push(value);
     }
 
@@ -1984,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() {
@@ -1999,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)
         }
@@ -2066,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 {
@@ -2094,12 +2724,16 @@ mod tests {
         };
 
         assert_eq!(
-            vec![EthereumTrigger::Block(
-                BlockPtr::from((hash(2), 2)),
-                EthereumBlockTriggerType::Every
-            )],
+            vec![
+                EthereumTrigger::Block(
+                    BlockPtr::from((hash(2), 2)),
+                    EthereumBlockTriggerType::Start
+                ),
+                EthereumTrigger::Block(BlockPtr::from((hash(2), 2)), EthereumBlockTriggerType::End)
+            ],
             parse_block_triggers(
                 &EthereumBlockFilter {
+                    polling_intervals: HashSet::new(),
                     contract_addresses: HashSet::from_iter(vec![(10, address(1))]),
                     trigger_every_block: true,
                 },
@@ -2109,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 {
@@ -2131,6 +2871,7 @@ mod tests {
             Vec::<EthereumTrigger>::new(),
             parse_block_triggers(
                 &EthereumBlockFilter {
+                    polling_intervals: HashSet::new(),
                     contract_addresses: HashSet::from_iter(vec![(1, address(1))]),
                     trigger_every_block: false,
                 },
@@ -2142,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 {
@@ -2165,6 +2905,7 @@ mod tests {
             )],
             parse_block_triggers(
                 &EthereumBlockFilter {
+                    polling_intervals: HashSet::new(),
                     contract_addresses: HashSet::from_iter(vec![(1, address(4))]),
                     trigger_every_block: false,
                 },
@@ -2174,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 a0d1f9a8247..dcbcc42c6f8 100644
--- a/chain/ethereum/src/ingestor.rs
+++ b/chain/ethereum/src/ingestor.rs
@@ -1,74 +1,57 @@
-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, BlockPtr, IngestorError},
+    blockchain::{BlockHash, BlockIngestor, BlockPtr, IngestorError},
     cheap_clone::CheapClone,
     prelude::{
-        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};
 
-pub struct BlockIngestor {
+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: ChainName,
 }
 
-impl BlockIngestor {
+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,
-    ) -> Result<BlockIngestor, Error> {
-        Ok(BlockIngestor {
+        network_name: ChainName,
+    ) -> Result<PollingBlockIngestor, Error> {
+        Ok(PollingBlockIngestor {
             logger,
             ancestor_count,
-            eth_adapter,
+            chain_client,
             chain_store,
             polling_interval,
+            network_name,
         })
     }
 
-    pub async fn into_polling_stream(self) {
-        loop {
-            match self.do_poll().await {
-                // Some polls will fail due to transient issues
-                Err(err @ IngestorError::BlockUnavailable(_)) => {
-                    info!(
-                        self.logger,
-                        "Trying again after block polling failed: {}", err
-                    );
-                }
-                Err(err @ IngestorError::ReceiptUnavailable(_, _)) => {
-                    info!(
-                        self.logger,
-                        "Trying again after block polling failed: {}", err
-                    );
-                }
-                Err(IngestorError::Unknown(inner_err)) => {
-                    warn!(
-                        self.logger,
-                        "Trying again after block polling failed: {}", inner_err
-                    );
-                }
-                Ok(()) => (),
-            }
-
-            if ENV_VARS.cleanup_blocks {
-                self.cleanup_cached_blocks()
-            }
-
-            tokio::time::sleep(self.polling_interval).await;
-        }
-    }
-
-    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!(
@@ -88,8 +71,12 @@ impl BlockIngestor {
         }
     }
 
-    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?;
@@ -97,7 +84,7 @@ impl BlockIngestor {
         // 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
@@ -109,7 +96,7 @@ impl BlockIngestor {
                 // 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);
@@ -121,7 +108,7 @@ impl BlockIngestor {
         match head_block_ptr_opt {
             None => {
                 info!(
-                    self.logger,
+                    &logger,
                     "Downloading latest blocks from Ethereum, this may take a few minutes..."
                 );
             }
@@ -137,7 +124,7 @@ impl BlockIngestor {
                 };
                 if distance > 0 {
                     info!(
-                        self.logger,
+                    &logger,
                         "Syncing {} blocks from Ethereum",
                         blocks_needed;
                         "current_block_head" => head_number,
@@ -154,7 +141,9 @@ impl BlockIngestor {
         // 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
@@ -175,29 +164,25 @@ impl BlockIngestor {
         //   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
@@ -217,16 +202,428 @@ impl BlockIngestor {
             .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 {
+            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().await;
+            }
+
+            tokio::time::sleep(self.polling_interval).await;
+        }
+    }
+
+    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 eeb207bf2d7..b21eb4717ae 100644
--- a/chain/ethereum/src/lib.rs
+++ b/chain/ethereum/src/lib.rs
@@ -1,21 +1,30 @@
 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::{DataSource, DataSourceTemplate, Mapping, MappingABI, TemplateSource};
+pub use data_source::{
+    BlockHandlerFilter, DataSource, DataSourceTemplate, Mapping, MappingBlockHandler,
+    MappingCallHandler, TemplateSource, UnresolvedDataSource, UnresolvedDataSourceTemplate,
+    UnresolvedMapping, UnresolvedMappingEventHandler,
+};
 
 pub mod chain;
 
@@ -23,12 +32,11 @@ 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 ingestor::BlockIngestor;
+pub use graph::blockchain::BlockIngestor;
 
 #[cfg(test)]
 mod tests;
diff --git a/chain/ethereum/src/network.rs b/chain/ethereum/src/network.rs
index 2779f76a799..ad9cd0a83c0 100644
--- a/chain/ethereum/src/network.rs
+++ b/chain/ethereum/src/network.rs
@@ -1,20 +1,29 @@
-use anyhow::{anyhow, bail, Context};
-use graph::cheap_clone::CheapClone;
-use graph::firehose::SubgraphLimit;
-use graph::prelude::rand::{self, seq::IteratorRandom};
-use std::cmp::Ordering;
-use std::collections::HashMap;
+use anyhow::{anyhow, bail};
+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 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;
 
 #[derive(Debug, Clone)]
 pub struct EthereumNetworkAdapter {
+    endpoint_metrics: Arc<EndpointMetrics>,
     pub capabilities: NodeCapabilities,
     adapter: Arc<EthereumAdapter>,
     /// The maximum number of times this adapter can be used. We use the
@@ -24,75 +33,244 @@ 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()
     }
+
+    pub fn get_capacity(&self) -> AvailableCapacity {
+        self.limit.get_capacity(Arc::strong_count(&self.adapter))
+    }
+
+    pub fn current_error_count(&self) -> u64 {
+        self.endpoint_metrics.get_count(&self.provider().into())
+    }
+    pub fn provider(&self) -> &str {
+        self.adapter.provider()
+    }
 }
 
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone)]
 pub struct EthereumNetworkAdapters {
-    pub adapters: Vec<EthereumNetworkAdapter>,
-    pub call_only_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 EthereumNetworkAdapters {
-    pub fn push_adapter(&mut self, adapter: EthereumNetworkAdapter) {
-        if adapter.is_call_only() {
-            self.call_only_adapters.push(adapter);
-        } else {
-            self.adapters.push(adapter);
+    pub fn empty_for_testing() -> Self {
+        Self {
+            chain_id: "".into(),
+            manager: ProviderManager::default(),
+            call_only_adapters: vec![],
+            retest_percent: DEFAULT_ADAPTER_ERROR_RETEST_PERCENT,
         }
     }
-    pub fn all_cheapest_with(
-        &self,
+
+    #[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),
+        }
+    }
+
+    fn available_with_capabilities<'a>(
+        input: Vec<&'a EthereumNetworkAdapter>,
         required_capabilities: &NodeCapabilities,
-    ) -> impl Iterator<Item = Arc<EthereumAdapter>> + '_ {
-        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
-                    .limit
-                    .has_capacity(Arc::strong_count(&adapter.adapter))
-            })
-            .map(|adapter| adapter.adapter.cheap_clone())
+            .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> {
-        // Select randomly from the cheapest adapters that have sufficent capabilities.
-        self.all_cheapest_with(required_capabilities)
-            .choose(&mut rand::thread_rng())
-            .with_context(|| {
-                anyhow!(
-                    "A matching Ethereum network with {:?} was not found.",
-                    required_capabilities
-                )
-            })
+        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 < retest_percent {
+            cheapest.max_by_key(|adapter| adapter.current_error_count())
+        } else {
+            // The assumption here is that most RPC endpoints will not have limits
+            // which makes the check for low/high available capacity less relevant.
+            // So we essentially assume if it had available capacity when calling
+            // `all_cheapest_with` then it prolly maintains that state and so we
+            // just select whichever adapter is working better according to
+            // the number of errors.
+            cheapest.min_by_key(|adapter| adapter.current_error_count())
+        }
+        .map(|adapter| adapter.adapter.clone())
+        .ok_or(anyhow!(
+            "A matching Ethereum network with {:?} was not found.",
+            required_capabilities
+        ))
+    }
+
+    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)
     }
 
-    pub fn cheapest(&self) -> Option<Arc<EthereumAdapter>> {
+    /// 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>,
@@ -102,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,
+                }))
+            }
         }
     }
 
@@ -136,100 +316,33 @@ impl EthereumNetworkAdapters {
     }
 }
 
-#[derive(Clone)]
-pub struct EthereumNetworks {
-    pub networks: HashMap<String, EthereumNetworkAdapters>,
-}
-
-impl EthereumNetworks {
-    pub fn new() -> EthereumNetworks {
-        EthereumNetworks {
-            networks: HashMap::new(),
-        }
-    }
-
-    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,
-        });
-    }
-
-    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,
+        firehose::SubgraphLimit,
+        prelude::MetricsRegistry,
+        slog::{Discard, Logger, o},
+        url::Url,
+    };
     use std::sync::Arc;
 
-    use graph::{firehose::SubgraphLimit, prelude::MetricsRegistry, tokio, url::Url};
-    use graph_mock::MockMetricsRegistry;
-    use http::HeaderMap;
-
-    use crate::{EthereumAdapter, EthereumNetworks, ProviderEthRpcMetrics, Transport};
+    use crate::{
+        Compression, EthereumAdapter, EthereumAdapterTrait, ProviderEthRpcMetrics, Transport,
+        chain::ChainSettings,
+    };
 
-    use super::NodeCapabilities;
+    use super::{EthereumNetworkAdapter, EthereumNetworkAdapters, NodeCapabilities};
 
     #[test]
+    #[allow(clippy::neg_cmp_op_on_partial_ord)]
     fn ethereum_capabilities_comparison() {
         let archive = NodeCapabilities {
             archive: true,
@@ -253,55 +366,61 @@ 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 chain = "mainnet".to_string();
+        let metrics = Arc::new(EndpointMetrics::mock());
         let logger = graph::log::logger(true);
-        let mock_registry: Arc<dyn MetricsRegistry> = Arc::new(MockMetricsRegistry::new());
-        let transport =
-            Transport::new_rpc(Url::parse("http://127.0.0.1").unwrap(), HeaderMap::new());
+        let mock_registry = Arc::new(MetricsRegistry::mock());
+        let transport = Transport::new_rpc(
+            Url::parse("http://127.0.0.1").unwrap(),
+            HeaderMap::new(),
+            metrics.clone(),
+            "",
+            false,
+            Compression::None,
+        );
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
 
         let eth_call_adapter = Arc::new(
             EthereumAdapter::new(
                 logger.clone(),
                 String::new(),
-                "http://127.0.0.1",
                 transport.clone(),
                 provider_metrics.clone(),
                 true,
                 true,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
@@ -310,49 +429,51 @@ mod tests {
             EthereumAdapter::new(
                 logger.clone(),
                 String::new(),
-                "http://127.0.0.1",
                 transport.clone(),
                 provider_metrics.clone(),
                 true,
                 false,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
 
-        let mut adapters = {
-            let mut ethereum_networks = EthereumNetworks::new();
-            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
@@ -360,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
@@ -383,28 +502,34 @@ 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 chain = "mainnet".to_string();
+        let metrics = Arc::new(EndpointMetrics::mock());
         let logger = graph::log::logger(true);
-        let mock_registry: Arc<dyn MetricsRegistry> = Arc::new(MockMetricsRegistry::new());
-        let transport =
-            Transport::new_rpc(Url::parse("http://127.0.0.1").unwrap(), HeaderMap::new());
+        let mock_registry = Arc::new(MetricsRegistry::mock());
+        let transport = Transport::new_rpc(
+            Url::parse("http://127.0.0.1").unwrap(),
+            HeaderMap::new(),
+            metrics.clone(),
+            "",
+            false,
+            Compression::None,
+        );
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
 
         let eth_call_adapter = Arc::new(
             EthereumAdapter::new(
                 logger.clone(),
                 String::new(),
-                "http://127.0.0.1",
                 transport.clone(),
                 provider_metrics.clone(),
                 true,
                 true,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
@@ -413,66 +538,73 @@ mod tests {
             EthereumAdapter::new(
                 logger.clone(),
                 String::new(),
-                "http://127.0.0.1",
                 transport.clone(),
                 provider_metrics.clone(),
                 true,
                 false,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
 
-        let adapters = {
-            let mut ethereum_networks = EthereumNetworks::new();
-            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 chain = "mainnet".to_string();
+        let metrics = Arc::new(EndpointMetrics::mock());
         let logger = graph::log::logger(true);
-        let mock_registry: Arc<dyn MetricsRegistry> = Arc::new(MockMetricsRegistry::new());
-        let transport =
-            Transport::new_rpc(Url::parse("http://127.0.0.1").unwrap(), HeaderMap::new());
+        let mock_registry = Arc::new(MetricsRegistry::mock());
+        let transport = Transport::new_rpc(
+            Url::parse("http://127.0.0.1").unwrap(),
+            HeaderMap::new(),
+            metrics.clone(),
+            "",
+            false,
+            Compression::None,
+        );
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
 
         let eth_call_adapter = Arc::new(
             EthereumAdapter::new(
                 logger.clone(),
                 String::new(),
-                "http://127.0.0.1",
                 transport.clone(),
                 provider_metrics.clone(),
                 true,
                 true,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
@@ -481,86 +613,357 @@ mod tests {
             EthereumAdapter::new(
                 logger.clone(),
                 String::new(),
-                "http://127.0.0.1",
                 transport.clone(),
                 provider_metrics.clone(),
                 true,
                 false,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
 
-        let adapters = {
-            let mut ethereum_networks = EthereumNetworks::new();
-            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 chain = "mainnet".to_string();
+        let metrics = Arc::new(EndpointMetrics::mock());
         let logger = graph::log::logger(true);
-        let mock_registry: Arc<dyn MetricsRegistry> = Arc::new(MockMetricsRegistry::new());
-        let transport =
-            Transport::new_rpc(Url::parse("http://127.0.0.1").unwrap(), HeaderMap::new());
+        let mock_registry = Arc::new(MetricsRegistry::mock());
+        let transport = Transport::new_rpc(
+            Url::parse("http://127.0.0.1").unwrap(),
+            HeaderMap::new(),
+            metrics.clone(),
+            "",
+            false,
+            Compression::None,
+        );
         let provider_metrics = Arc::new(ProviderEthRpcMetrics::new(mock_registry.clone()));
 
         let eth_adapter = Arc::new(
             EthereumAdapter::new(
                 logger.clone(),
                 String::new(),
-                "http://127.0.0.1",
                 transport.clone(),
                 provider_metrics.clone(),
                 true,
                 false,
+                Arc::new(ChainSettings::from_env_defaults()),
             )
             .await,
         );
 
-        let adapters = {
-            let mut ethereum_networks = EthereumNetworks::new();
-            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!(!adapters.call_or_cheapest(None).unwrap().is_call_only());
+    }
+
+    #[graph::test]
+    async fn eth_adapter_selection_multiple_adapters() {
+        let logger = Logger::root(Discard, o!());
+        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, 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 = [
+            fake_adapter(
+                &logger,
+                unavailable_provider,
+                &provider_metrics,
+                &metrics,
+                false,
+            )
+            .await,
+            fake_adapter(&logger, error_provider, &provider_metrics, &metrics, false).await,
+            fake_adapter(
+                &logger,
+                no_error_provider,
+                &provider_metrics,
+                &metrics,
+                false,
+            )
+            .await,
+        ];
+
+        // Set errors
+        metrics.report_for_test(&ProviderName::from(error_provider), false);
+
+        let mut no_retest_adapters = vec![];
+        let mut always_retest_adapters = vec![];
+
+        adapters.iter().cloned().for_each(|adapter| {
+            let limit = if adapter.provider() == unavailable_provider {
+                SubgraphLimit::Disabled
+            } else {
+                SubgraphLimit::Unlimited
+            };
+
+            no_retest_adapters.push(EthereumNetworkAdapter {
+                endpoint_metrics: metrics.clone(),
+                capabilities: NodeCapabilities {
+                    archive: true,
+                    traces: false,
+                },
+                adapter: adapter.clone(),
+                limit: limit.clone(),
+            });
+            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
+                .cheapest_with(&NodeCapabilities {
+                    archive: true,
+                    traces: false,
+                })
+                .await
+                .unwrap()
+                .provider(),
+            no_error_provider
+        );
         assert_eq!(
-            adapters.call_or_cheapest(None).unwrap().is_call_only(),
-            false
+            always_retest_adapters
+                .cheapest_with(&NodeCapabilities {
+                    archive: true,
+                    traces: false,
+                })
+                .await
+                .unwrap()
+                .provider(),
+            error_provider
         );
     }
+
+    #[graph::test]
+    async fn eth_adapter_selection_single_adapter() {
+        let logger = Logger::root(Discard, o!());
+        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, 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(&ProviderName::from(error_provider), false);
+
+        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)
+                .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!(
+            always_retest_adapters
+                .cheapest_with(&NodeCapabilities {
+                    archive: true,
+                    traces: false,
+                })
+                .await
+                .unwrap()
+                .provider(),
+            no_error_provider
+        );
+
+        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!(
+            no_retest_adapters
+                .cheapest_with(&NodeCapabilities {
+                    archive: true,
+                    traces: false,
+                })
+                .await
+                .unwrap()
+                .provider(),
+            error_provider
+        );
+
+        let mut no_available_adapter = vec![];
+        no_available_adapter.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::Disabled,
+        });
+        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);
+    }
+
+    async fn fake_adapter(
+        logger: &Logger,
+        provider: &str,
+        provider_metrics: &Arc<ProviderEthRpcMetrics>,
+        endpoint_metrics: &Arc<EndpointMetrics>,
+        call_only: bool,
+    ) -> Arc<EthereumAdapter> {
+        let transport = Transport::new_rpc(
+            Url::parse("http://127.0.0.1").unwrap(),
+            HeaderMap::new(),
+            endpoint_metrics.clone(),
+            "",
+            false,
+            Compression::None,
+        );
+
+        Arc::new(
+            EthereumAdapter::new(
+                logger.clone(),
+                provider.to_string(),
+                transport.clone(),
+                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 daebeef2bd4..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,
+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,10 +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 {
@@ -499,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;
@@ -554,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) => {
@@ -574,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;
                     }
@@ -595,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"),
                             ))));
                         }
 
@@ -606,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 dcc9564bd7f..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, 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, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscLogParamArray(Array::new(&content, heap, gas)?))
+    ) -> Result<AscLogParamArray, HostExportError> {
+        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, DeterministicHostError> {
-        let topics = self
-            .iter()
-            .map(|topic| asc_new(heap, topic, gas))
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(AscTopicArray(Array::new(&topics, heap, gas)?))
+    ) -> Result<AscTopicArray, HostExportError> {
+        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, DeterministicHostError> {
-        let logs = self
-            .iter()
-            .map(|log| asc_new(heap, &log, gas))
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(AscLogArray(Array::new(&logs, heap, gas)?))
+    ) -> Result<AscLogArray, HostExportError> {
+        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>,
@@ -138,13 +148,14 @@ impl FromAscObj<AscUnresolvedContractCall_0_0_4> for UnresolvedContractCall {
         asc_call: AscUnresolvedContractCall_0_0_4,
         heap: &H,
         gas: &GasCounter,
+        depth: usize,
     ) -> Result<Self, DeterministicHostError> {
         Ok(UnresolvedContractCall {
-            contract_name: asc_get(heap, asc_call.contract_name, gas)?,
-            contract_address: asc_get(heap, asc_call.contract_address, gas)?,
-            function_name: asc_get(heap, asc_call.function_name, gas)?,
-            function_signature: Some(asc_get(heap, asc_call.function_signature, gas)?),
-            function_args: asc_get(heap, asc_call.function_args, gas)?,
+            contract_name: asc_get(heap, asc_call.contract_name, gas, depth)?,
+            contract_address: asc_get(heap, asc_call.contract_address, gas, depth)?,
+            function_name: asc_get(heap, asc_call.function_name, gas, depth)?,
+            function_signature: Some(asc_get(heap, asc_call.function_signature, gas, depth)?),
+            function_args: asc_get(heap, asc_call.function_args, gas, depth)?,
         })
     }
 }
@@ -163,13 +174,14 @@ impl FromAscObj<AscUnresolvedContractCall> for UnresolvedContractCall {
         asc_call: AscUnresolvedContractCall,
         heap: &H,
         gas: &GasCounter,
+        depth: usize,
     ) -> Result<Self, DeterministicHostError> {
         Ok(UnresolvedContractCall {
-            contract_name: asc_get(heap, asc_call.contract_name, gas)?,
-            contract_address: asc_get(heap, asc_call.contract_address, gas)?,
-            function_name: asc_get(heap, asc_call.function_name, gas)?,
+            contract_name: asc_get(heap, asc_call.contract_name, gas, depth)?,
+            contract_address: asc_get(heap, asc_call.contract_address, gas, depth)?,
+            function_name: asc_get(heap, asc_call.function_name, gas, depth)?,
             function_signature: None,
-            function_args: asc_get(heap, asc_call.function_args, gas)?,
+            function_args: asc_get(heap, asc_call.function_args, gas, depth)?,
         })
     }
 }
@@ -177,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>,
@@ -199,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>,
@@ -223,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>,
@@ -239,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>,
@@ -256,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>,
@@ -306,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>,
@@ -323,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>,
 }
 
@@ -344,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,
@@ -390,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,
@@ -411,185 +429,177 @@ 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> Result<AscEthereumTransaction_0_0_1, HostExportError> {
         Ok(AscEthereumTransaction_0_0_1 {
-            hash: asc_new(heap, &self.hash, gas)?,
-            index: asc_new(heap, &BigInt::from(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, DeterministicHostError> {
+    ) -> Result<AscEthereumTransaction_0_0_2, HostExportError> {
         Ok(AscEthereumTransaction_0_0_2 {
-            hash: asc_new(heap, &self.hash, gas)?,
-            index: asc_new(heap, &BigInt::from(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, DeterministicHostError> {
+    ) -> Result<AscEthereumTransaction_0_0_6, HostExportError> {
         Ok(AscEthereumTransaction_0_0_6 {
-            hash: asc_new(heap, &self.hash, gas)?,
-            index: asc_new(heap, &BigInt::from(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>, DeterministicHostError> {
+    ) -> 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,
-    ) -> Result<AscEthereumEvent_0_0_7<T, B>, DeterministicHostError> {
+    ) -> Result<AscEthereumEvent_0_0_7<T, B>, HostExportError> {
         let (event_data, optional_receipt) = self;
         let AscEthereumEvent {
             address,
@@ -599,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()
         };
@@ -618,166 +628,166 @@ 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> 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,
     ) -> Result<
         AscEthereumCall_0_0_3<AscEthereumTransaction_0_0_2, AscEthereumBlock>,
-        DeterministicHostError,
+        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,
     ) -> Result<
         AscEthereumCall_0_0_3<AscEthereumTransaction_0_0_6, AscEthereumBlock_0_0_6>,
-        DeterministicHostError,
+        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, DeterministicHostError> {
+    ) -> 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 71e20532ed3..a5d68a761a7 100644
--- a/chain/ethereum/src/runtime/runtime_adapter.rs
+++ b/chain/ethereum/src/runtime/runtime_adapter.rs
@@ -1,29 +1,47 @@
 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,
+    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};
 
+/// Gas limit for `eth_call`. The value of 50_000_000 is a protocol-wide parameter so this
+/// should be changed only for debugging purposes and never on an indexer in the network. This
+/// value was chosen because it is the Geth default
+/// https://github.com/ethereum/go-ethereum/blob/e4b687cf462870538743b3218906940ae590e7fd/eth/ethconfig/config.go#L91.
+/// It is not safe to set something higher because Geth will silently override the gas limit
+/// with the default. This means that we do not support indexing against a Geth node with
+/// `RPCGasCap` set below 50 million.
+// See also f0af4ab0-6b7c-4b68-9141-5b79346a5f61.
+const ETH_CALL_GAS: u32 = 50_000_000;
+
 // When making an ethereum call, the maximum ethereum gas is ETH_CALL_GAS which is 50 million. One
 // unit of Ethereum gas is at least 100ns according to these benchmarks [1], so 1000 of our gas. In
 // the worst case an Ethereum call could therefore consume 50 billion of our gas. However the
@@ -34,50 +52,160 @@ use super::abi::{AscUnresolvedContractCall, AscUnresolvedContractCall_0_0_4};
 // [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();
-        // Ethereum calls should prioritise call-only adapters if one is available.
-        let eth_adapter = self.eth_adapters.call_or_cheapest(Some(&NodeCapabilities {
-            archive: ds.mapping.requires_archive()?,
-            traces: false,
-        }))?;
-
-        let ethereum_call = HostFn {
-            name: "ethereum.call",
-            func: Arc::new(move |ctx, wasm_ptr| {
-                ethereum_call(&eth_adapter, call_cache.cheap_clone(), ctx, wasm_ptr, &abis)
-                    .map(|ptr| ptr.wasm_ptr())
-            }),
+    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 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<'_>,
     wasm_ptr: u32,
     abis: &[Arc<MappingABI>],
+    eth_call_gas: Option<u32>,
 ) -> Result<AscEnumArray<EthereumValueKind>, HostExportError> {
-    ctx.gas.consume_host_fn(ETHEREUM_CALL)?;
+    ctx.gas
+        .consume_host_fn_with_metrics(ETHEREUM_CALL, "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) {
-        asc_get::<_, AscUnresolvedContractCall_0_0_4, _>(ctx.heap, wasm_ptr.into(), &ctx.gas)?
+    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)?
+        asc_get::<_, AscUnresolvedContractCall, _>(ctx.heap, wasm_ptr.into(), &ctx.gas, 0)?
     };
 
     let result = eth_call(
@@ -87,26 +215,101 @@ fn ethereum_call(
         &ctx.block_ptr,
         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,
     block_ptr: &BlockPtr,
     unresolved_call: UnresolvedContractCall,
     abis: &[Arc<MappingABI>],
-) -> Result<Option<Vec<Token>>, HostExportError> {
+    eth_call_gas: Option<u32>,
+    metrics: Arc<HostMetrics>,
+) -> 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(|| {
@@ -115,97 +318,93 @@ fn eth_call(
                      of the subgraph manifest",
                 unresolved_call.contract_name
             )
-        })?
-        .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
-                )
-            })?,
-
-        // 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
-                )
-            })?
-            .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)?;
 
-    let call = EthereumContractCall {
+    let function = abi
+        .function(
+            &unresolved_call.contract_name,
+            &unresolved_call.function_name,
+            unresolved_call.function_signature.as_deref(),
+        )
+        .map_err(HostExportError::Deterministic)?;
+
+    let call = ContractCall {
+        contract_name: unresolved_call.contract_name.clone(),
         address: unresolved_call.contract_address,
         block_ptr: block_ptr.cheap_clone(),
         function: function.clone(),
         args: unresolved_call.function_args.clone(),
+        gas: eth_call_gas,
     };
 
     // 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();
+
+    if source.observe() {
+        metrics.observe_eth_call_execution_time(
+            elapsed.as_secs_f64(),
+            &unresolved_call.contract_name,
+            &unresolved_call.function_name,
+        );
+    }
+
+    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(),
+    };
 
-    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", start_time.elapsed().as_millis()));
+    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
 }
@@ -216,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 9c4a46130e5..a5f0a17bff0 100644
--- a/chain/ethereum/src/tests.rs
+++ b/chain/ethereum/src/tests.rs
@@ -1,78 +1,115 @@
 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::{
     chain::BlockFinality,
-    trigger::{EthereumBlockTriggerType, EthereumTrigger},
+    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)),
-        EthereumBlockTriggerType::Every,
+        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(create_log(1, 0), None);
+    let log1 = EthereumTrigger::Log(LogRef::FullLog(create_log(1, 0), None));
 
     // Event with transaction_index 1 and log_index 1;
     // should be the second element after sorting
-    let log2 = EthereumTrigger::Log(create_log(1, 1), None);
+    let log2 = EthereumTrigger::Log(LogRef::FullLog(create_log(1, 1), None));
 
     // Event with transaction_index 2 and log_index 5;
     // should come after call1 and before call2 after sorting
-    let log3 = EthereumTrigger::Log(create_log(2, 5), None);
+    let log3 = EthereumTrigger::Log(LogRef::FullLog(create_log(2, 5), None));
 
     let triggers = vec![
         // Call triggers; these should be in the order 1, 2, 4, 3 after sorting
@@ -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,63 +140,57 @@ 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)),
-        EthereumBlockTriggerType::Every,
+        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(create_log(1, 0), None);
-    let log2 = EthereumTrigger::Log(create_log(1, 1), None);
-    let log3 = EthereumTrigger::Log(create_log(2, 5), None);
+    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));
     // duplicate logs 2 and 3
     let log4 = log2.clone();
     let log5 = log3.clone();
@@ -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 b30fd17d84b..5b5414c4a5d 100644
--- a/chain/ethereum/src/transport.rs
+++ b/chain/ethereum/src/transport.rs
@@ -1,88 +1,305 @@
-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(http::Http),
-    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).
-    pub fn new_rpc(rpc: Url, headers: ::http::HeaderMap) -> 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(http::Http::with_client(client, rpc))
+    /// 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: graph::http::HeaderMap,
+        metrics: Arc<EndpointMetrics>,
+        provider: impl AsRef<str>,
+        no_eip2718: bool,
+        compression: Compression,
+    ) -> Self {
+        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 = Box<dyn Future<Output = Result<Value, web3::error::Error>> + Send + Unpin>;
+/// 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(http) => http.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,
         }
     }
+}
 
-    fn send(&self, id: RequestId, request: Call) -> Self::Out {
-        match self {
-            Transport::RPC(http) => Box::new(http.send(id, request)),
-            Transport::IPC(ipc) => Box::new(ipc.send(id, request)),
-            Transport::WS(ws) => Box::new(ws.send(id, request)),
-        }
+// 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 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,
+                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),
+            }
+
+            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(http) => Box::new(http.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 9b609668b1f..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::DeterministicHostError;
+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::convert::TryFrom;
-use std::ops::Deref;
 use std::{cmp::Ordering, sync::Arc};
 
 use crate::runtime::abi::AscEthereumBlock;
@@ -38,44 +35,59 @@ 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>,
     },
 }
 
+impl MappingTriggerTrait for MappingTrigger {
+    fn error_context(&self) -> String {
+        let transaction_id = match self {
+            MappingTrigger::Log { log, .. } => log.transaction_hash,
+            MappingTrigger::Call { call, .. } => call.transaction_hash,
+            MappingTrigger::Block { .. } => None,
+        };
+
+        match transaction_id {
+            Some(tx_hash) => format!("transaction {:x}", tx_hash),
+            None => String::new(),
+        }
+    }
+}
+
 // Logging the block is too verbose, so this strips the block from the trigger for Debug.
 impl std::fmt::Debug for MappingTrigger {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         #[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,
         }
@@ -87,6 +99,7 @@ impl std::fmt::Debug for MappingTrigger {
                 log,
                 params,
                 receipt: _,
+                calls: _,
             } => MappingTriggerWithoutBlock::Log {
                 _transaction: transaction.cheap_clone(),
                 _log: log.cheap_clone(),
@@ -111,12 +124,13 @@ 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,
-    ) -> Result<AscPtr<()>, DeterministicHostError> {
+    ) -> Result<AscPtr<()>, HostExportError> {
         Ok(match self {
             MappingTrigger::Log {
                 block,
@@ -124,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,
@@ -143,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()
                 }
             }
@@ -175,49 +190,115 @@ 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<AlloyTransactionReceipt>>),
+    LogPosition(LogPosition),
+}
+
+impl LogRef {
+    pub fn log(&self) -> &Log {
+        match self {
+            LogRef::FullLog(log, _) => log.as_ref(),
+            LogRef::LogPosition(pos) => pos.receipt.logs().get(pos.index).unwrap(),
+        }
+    }
+
+    /// 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(pos) => {
+                if pos.requires_transaction_receipt {
+                    Some(&pos.receipt)
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    pub fn log_index(&self) -> Option<u64> {
+        self.log().log_index
+    }
+
+    pub fn transaction_index(&self) -> Option<u64> {
+        self.log().transaction_index
+    }
+
+    fn transaction_hash(&self) -> Option<B256> {
+        self.log().transaction_hash
+    }
+
+    pub fn block_hash(&self) -> Option<B256> {
+        self.log().block_hash
+    }
+
+    pub fn block_number(&self) -> Option<u64> {
+        self.log().block_number
+    }
+
+    pub fn address(&self) -> &Address {
+        &self.log().inner.address
+    }
+}
+
 #[derive(Clone, Debug)]
 pub enum EthereumTrigger {
     Block(BlockPtr, EthereumBlockTriggerType),
     Call(Arc<EthereumCall>),
-    Log(Arc<Log>, Option<Arc<TransactionReceipt>>),
+    Log(LogRef),
 }
 
 impl PartialEq for EthereumTrigger {
@@ -229,12 +310,9 @@ impl PartialEq for EthereumTrigger {
 
             (Self::Call(a), Self::Call(b)) => a == b,
 
-            (Self::Log(a, a_receipt), Self::Log(b, b_receipt)) => {
-                a.transaction_hash == b.transaction_hash
-                    && a.log_index == b.log_index
-                    && a_receipt == b_receipt
+            (Self::Log(a), Self::Log(b)) => {
+                a.transaction_hash() == b.transaction_hash() && a.log_index() == b.log_index()
             }
-
             _ => false,
         }
     }
@@ -244,7 +322,8 @@ impl Eq for EthereumTrigger {}
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum EthereumBlockTriggerType {
-    Every,
+    Start,
+    End,
     WithCallTo(Address),
 }
 
@@ -253,17 +332,31 @@ impl EthereumTrigger {
         match self {
             EthereumTrigger::Block(block_ptr, _) => block_ptr.number,
             EthereumTrigger::Call(call) => call.block_number,
-            EthereumTrigger::Log(log, _) => {
-                i32::try_from(log.block_number.unwrap().as_u64()).unwrap()
+            EthereumTrigger::Log(log_ref) => {
+                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, _) => log.block_hash.unwrap(),
+            EthereumTrigger::Log(log_ref) => log_ref.block_hash().unwrap(),
+        }
+    }
+
+    /// `None` means the trigger matches any address.
+    pub fn address(&self) -> Option<&Address> {
+        match self {
+            EthereumTrigger::Block(_, EthereumBlockTriggerType::WithCallTo(address)) => {
+                Some(address)
+            }
+            EthereumTrigger::Call(call) => Some(&call.to),
+            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,
         }
     }
 }
@@ -271,10 +364,14 @@ impl EthereumTrigger {
 impl Ord for EthereumTrigger {
     fn cmp(&self, other: &Self) -> Ordering {
         match (self, other) {
+            // Block triggers with `EthereumBlockTriggerType::Start` always come
+            (Self::Block(_, EthereumBlockTriggerType::Start), _) => Ordering::Less,
+            (_, Self::Block(_, EthereumBlockTriggerType::Start)) => Ordering::Greater,
+
             // Keep the order when comparing two block triggers
             (Self::Block(..), Self::Block(..)) => Ordering::Equal,
 
-            // Block triggers always come last
+            // Block triggers with `EthereumBlockTriggerType::End` always come last
             (Self::Block(..), _) => Ordering::Greater,
             (_, Self::Block(..)) => Ordering::Less,
 
@@ -282,28 +379,26 @@ impl Ord for EthereumTrigger {
             (Self::Call(a), Self::Call(b)) => a.transaction_index.cmp(&b.transaction_index),
 
             // Events are ordered by their log index
-            (Self::Log(a, _), Self::Log(b, _)) => a.log_index.cmp(&b.log_index),
+            (Self::Log(a), Self::Log(b)) => a.log_index().cmp(&b.log_index()),
 
             // 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() =>
+            (Self::Call(a), Self::Log(b))
+                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 =>
+            (Self::Log(a), Self::Call(b))
+                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)
+            }
         }
     }
 }
@@ -317,7 +412,7 @@ impl PartialOrd for EthereumTrigger {
 impl TriggerData for EthereumTrigger {
     fn error_context(&self) -> std::string::String {
         let transaction_id = match self {
-            EthereumTrigger::Log(log, _) => log.transaction_hash,
+            EthereumTrigger::Log(log) => log.transaction_hash(),
             EthereumTrigger::Call(call) => call.transaction_hash,
             EthereumTrigger::Block(..) => None,
         };
@@ -332,102 +427,225 @@ impl TriggerData for EthereumTrigger {
             None => String::new(),
         }
     }
+
+    fn address_match(&self) -> Option<&[u8]> {
+        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/ethereum/tests/README.md b/chain/ethereum/tests/README.md
new file mode 100644
index 00000000000..e0444bc179f
--- /dev/null
+++ b/chain/ethereum/tests/README.md
@@ -0,0 +1,5 @@
+Put integration tests for this crate into
+`store/test-store/tests/chain/ethereum`. This avoids cyclic dev-dependencies
+which make rust-analyzer nearly unusable. Once [this
+issue](https://github.com/rust-lang/rust-analyzer/issues/14167) has been
+fixed, we can move tests back here
diff --git a/chain/ethereum/tests/manifest.rs b/chain/ethereum/tests/manifest.rs
deleted file mode 100644
index 5d1c7bb3a84..00000000000
--- a/chain/ethereum/tests/manifest.rs
+++ /dev/null
@@ -1,793 +0,0 @@
-use std::collections::HashMap;
-use std::sync::Arc;
-use std::time::Duration;
-
-use graph::data::subgraph::schema::SubgraphError;
-use graph::data::subgraph::{SPEC_VERSION_0_0_4, SPEC_VERSION_0_0_7};
-use graph::data_source::DataSourceTemplate;
-use graph::prelude::{
-    anyhow, async_trait, serde_yaml, tokio, DeploymentHash, Entity, Link, Logger, SubgraphManifest,
-    SubgraphManifestValidationError, UnvalidatedSubgraphManifest,
-};
-use graph::{
-    blockchain::NodeCapabilities as _,
-    components::{
-        link_resolver::{JsonValueStream, LinkResolver as LinkResolverTrait},
-        store::EntityType,
-    },
-    data::subgraph::SubgraphFeature,
-};
-
-use graph_chain_ethereum::{Chain, NodeCapabilities};
-use semver::Version;
-use test_store::LOGGER;
-
-const GQL_SCHEMA: &str = "type Thing @entity { id: ID! }";
-const GQL_SCHEMA_FULLTEXT: &str = include_str!("full-text.graphql");
-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 = "{}";
-const FILE_CID: &str = "bafkreigkhuldxkyfkoaye4rgcqcwr45667vkygd45plwq6hawy7j4rbdky";
-
-#[derive(Default, Debug, Clone)]
-struct TextResolver {
-    texts: HashMap<String, Vec<u8>>,
-}
-
-impl TextResolver {
-    fn add(&mut self, link: &str, text: &impl AsRef<[u8]>) {
-        self.texts.insert(link.to_owned(), text.as_ref().to_vec());
-    }
-}
-
-#[async_trait]
-impl LinkResolverTrait for TextResolver {
-    fn with_timeout(&self, _timeout: Duration) -> Box<dyn LinkResolverTrait> {
-        Box::new(self.clone())
-    }
-
-    fn with_retries(&self) -> Box<dyn LinkResolverTrait> {
-        Box::new(self.clone())
-    }
-
-    async fn cat(&self, _logger: &Logger, link: &Link) -> Result<Vec<u8>, anyhow::Error> {
-        self.texts
-            .get(&link.link)
-            .ok_or(anyhow!("No text for {}", &link.link))
-            .map(Clone::clone)
-    }
-
-    async fn get_block(&self, _logger: &Logger, _link: &Link) -> Result<Vec<u8>, anyhow::Error> {
-        unimplemented!()
-    }
-
-    async fn json_stream(
-        &self,
-        _logger: &Logger,
-        _link: &Link,
-    ) -> Result<JsonValueStream, anyhow::Error> {
-        unimplemented!()
-    }
-}
-
-async fn resolve_manifest(
-    text: &str,
-    max_spec_version: Version,
-) -> SubgraphManifest<graph_chain_ethereum::Chain> {
-    let mut resolver = TextResolver::default();
-    let id = DeploymentHash::new("Qmmanifest").unwrap();
-
-    resolver.add(id.as_str(), &text);
-    resolver.add("/ipfs/Qmschema", &GQL_SCHEMA);
-    resolver.add("/ipfs/Qmabi", &ABI);
-    resolver.add("/ipfs/Qmmapping", &MAPPING_WITH_IPFS_FUNC_WASM);
-    resolver.add(FILE_CID, &FILE);
-
-    let resolver: Arc<dyn LinkResolverTrait> = Arc::new(resolver);
-
-    let raw = serde_yaml::from_str(text).unwrap();
-    SubgraphManifest::resolve_from_raw(id, raw, &resolver, &LOGGER, max_spec_version)
-        .await
-        .expect("Parsing simple manifest works")
-}
-
-async fn resolve_unvalidated(text: &str) -> UnvalidatedSubgraphManifest<Chain> {
-    let mut resolver = TextResolver::default();
-    let id = DeploymentHash::new("Qmmanifest").unwrap();
-
-    resolver.add(id.as_str(), &text);
-    resolver.add("/ipfs/Qmschema", &GQL_SCHEMA);
-
-    let resolver: Arc<dyn LinkResolverTrait> = 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")
-}
-
-// Some of these manifest tests should be made chain-independent, but for
-// now we just run them for the ethereum `Chain`
-
-#[tokio::test]
-async fn simple_manifest() {
-    const YAML: &str = "
-dataSources: []
-schema:
-  file:
-    /: /ipfs/Qmschema
-specVersion: 0.0.2
-";
-
-    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
-
-    assert_eq!("Qmmanifest", manifest.id.as_str());
-    assert!(manifest.graft.is_none());
-}
-
-#[tokio::test]
-async fn ipfs_manifest() {
-    let yaml = "
-schema:
-  file:
-    /: /ipfs/Qmschema
-dataSources: []
-templates:
-  - name: IpfsSource
-    kind: file/ipfs
-    mapping:
-      apiVersion: 0.0.6
-      language: wasm/assemblyscript
-      entities:
-        - TestEntity
-      file:
-        /: /ipfs/Qmmapping
-      handler: handleFile
-specVersion: 0.0.7
-";
-
-    let manifest = resolve_manifest(yaml, SPEC_VERSION_0_0_7).await;
-
-    assert_eq!("Qmmanifest", manifest.id.as_str());
-    assert_eq!(manifest.data_sources.len(), 0);
-    let data_source = match &manifest.templates[0] {
-        DataSourceTemplate::Offchain(ds) => ds,
-        DataSourceTemplate::Onchain(_) => unreachable!(),
-    };
-    assert_eq!(data_source.kind, "file/ipfs");
-}
-
-#[tokio::test]
-async fn graft_manifest() {
-    const YAML: &str = "
-dataSources: []
-schema:
-  file:
-    /: /ipfs/Qmschema
-graft:
-  base: Qmbase
-  block: 12345
-specVersion: 0.0.2
-";
-
-    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
-
-    assert_eq!("Qmmanifest", manifest.id.as_str());
-    let graft = manifest.graft.expect("The manifest has a graft base");
-    assert_eq!("Qmbase", graft.base.as_str());
-    assert_eq!(12345, graft.block);
-}
-
-#[test]
-fn graft_failed_subgraph() {
-    const YAML: &str = "
-dataSources: []
-schema:
-  file:
-    /: /ipfs/Qmschema
-graft:
-  base: Qmbase
-  block: 0
-specVersion: 0.0.2
-";
-
-    test_store::run_test_sequentially(|store| async move {
-        let subgraph_store = store.subgraph_store();
-
-        let unvalidated = resolve_unvalidated(YAML).await;
-        let subgraph = DeploymentHash::new("Qmbase").unwrap();
-
-        // Creates base subgraph at block 0 (genesis).
-        let deployment = test_store::create_test_subgraph(&subgraph, GQL_SCHEMA).await;
-
-        // Adds an example entity.
-        let mut thing = Entity::new();
-        thing.set("id", "datthing");
-        test_store::insert_entities(&deployment, vec![(EntityType::from("Thing"), thing)])
-            .await
-            .unwrap();
-
-        let error = SubgraphError {
-            subgraph_id: deployment.hash.clone(),
-            message: "deterministic error".to_string(),
-            block_ptr: Some(test_store::BLOCKS[1].clone()),
-            handler: None,
-            deterministic: true,
-        };
-
-        // Fails the base subgraph at block 1 (and advances the pointer).
-        test_store::transact_errors(
-            &store,
-            &deployment,
-            test_store::BLOCKS[1].clone(),
-            vec![error],
-        )
-        .await
-        .unwrap();
-
-        // Make sure there are no GraftBaseInvalid errors.
-        //
-        // This is allowed because:
-        // - base:  failed at block 1
-        // - graft: starts at block 0
-        //
-        // Meaning that the graft will fail just like it's parent
-        // but it started at a valid previous block.
-        assert!(
-            !unvalidated
-                .validate(subgraph_store.clone(), true)
-                .await
-                .expect_err("Validation must fail")
-                .into_iter()
-                .any(|e| matches!(&e, SubgraphManifestValidationError::GraftBaseInvalid(_))),
-            "There shouldn't be a GraftBaseInvalid error"
-        );
-
-        // Resolve the graft normally.
-        let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
-
-        assert_eq!("Qmmanifest", manifest.id.as_str());
-        let graft = manifest.graft.expect("The manifest has a graft base");
-        assert_eq!("Qmbase", graft.base.as_str());
-        assert_eq!(0, graft.block);
-    })
-}
-
-#[test]
-fn graft_invalid_manifest() {
-    const YAML: &str = "
-dataSources: []
-schema:
-  file:
-    /: /ipfs/Qmschema
-graft:
-  base: Qmbase
-  block: 1
-specVersion: 0.0.2
-";
-
-    test_store::run_test_sequentially(|store| async move {
-        let subgraph_store = store.subgraph_store();
-
-        let unvalidated = resolve_unvalidated(YAML).await;
-        let subgraph = DeploymentHash::new("Qmbase").unwrap();
-
-        //
-        // Validation against subgraph that hasn't synced anything fails
-        //
-        let deployment = test_store::create_test_subgraph(&subgraph, GQL_SCHEMA).await;
-        // This check is awkward since the test manifest has other problems
-        // that the validation complains about as setting up a valid manifest
-        // would be a bit more work; we just want to make sure that
-        // graft-related checks work
-        let msg = unvalidated
-            .validate(subgraph_store.clone(), true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| matches!(e, SubgraphManifestValidationError::GraftBaseInvalid(_)))
-            .expect("There must be a GraftBaseInvalid error")
-            .to_string();
-        assert_eq!(
-            "the graft base is invalid: failed to graft onto `Qmbase` since \
-            it has not processed any blocks",
-            msg
-        );
-
-        let mut thing = Entity::new();
-        thing.set("id", "datthing");
-        test_store::insert_entities(&deployment, vec![(EntityType::from("Thing"), thing)])
-            .await
-            .unwrap();
-
-        // Validation against subgraph that has not reached the graft point fails
-        let unvalidated = resolve_unvalidated(YAML).await;
-        let msg = unvalidated
-            .validate(subgraph_store.clone(), true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| matches!(e, SubgraphManifestValidationError::GraftBaseInvalid(_)))
-            .expect("There must be a GraftBaseInvalid error")
-            .to_string();
-        assert_eq!(
-            "the graft base is invalid: failed to graft onto `Qmbase` \
-            at block 1 since it has only processed block 0",
-            msg
-        );
-
-        let error = SubgraphError {
-            subgraph_id: deployment.hash.clone(),
-            message: "deterministic error".to_string(),
-            block_ptr: Some(test_store::BLOCKS[1].clone()),
-            handler: None,
-            deterministic: true,
-        };
-
-        test_store::transact_errors(
-            &store,
-            &deployment,
-            test_store::BLOCKS[1].clone(),
-            vec![error],
-        )
-        .await
-        .unwrap();
-
-        // This check is bit awkward, but we just want to be sure there is a
-        // GraftBaseInvalid error.
-        //
-        // The validation error happens because:
-        // - base:  failed at block 1
-        // - graft: starts at block 1
-        //
-        // Since we start grafts at N + 1, we can't allow a graft to be created
-        // at the failed block. They (developers) should choose a previous valid
-        // block.
-        let unvalidated = resolve_unvalidated(YAML).await;
-        let msg = unvalidated
-            .validate(subgraph_store, true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| matches!(e, SubgraphManifestValidationError::GraftBaseInvalid(_)))
-            .expect("There must be a GraftBaseInvalid error")
-            .to_string();
-        assert_eq!(
-            "the graft base is invalid: failed to graft onto `Qmbase` \
-            at block 1 since it's not healthy. You can graft it starting at block 0 backwards",
-            msg
-        );
-    })
-}
-
-#[tokio::test]
-async fn parse_call_handlers() {
-    const YAML: &str = "
-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
-      callHandlers:
-        - function: get(address)
-          handler: handleget
-schema:
-  file:
-    /: /ipfs/Qmschema
-specVersion: 0.0.2
-";
-
-    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
-    let onchain_data_sources = manifest
-        .data_sources
-        .iter()
-        .filter_map(|ds| ds.as_onchain().cloned())
-        .collect::<Vec<_>>();
-    let required_capabilities = NodeCapabilities::from_data_sources(&onchain_data_sources);
-
-    assert_eq!("Qmmanifest", manifest.id.as_str());
-    assert_eq!(true, required_capabilities.traces);
-}
-
-#[test]
-fn undeclared_grafting_feature_causes_feature_validation_error() {
-    const YAML: &str = "
-specVersion: 0.0.4
-dataSources: []
-schema:
-  file:
-    /: /ipfs/Qmschema
-graft:
-  base: Qmbase
-  block: 1
-";
-    test_store::run_test_sequentially(|store| async move {
-        let store = store.subgraph_store();
-        let unvalidated = resolve_unvalidated(YAML).await;
-        let error_msg = unvalidated
-            .validate(store.clone(), true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| {
-                matches!(
-                    e,
-                    SubgraphManifestValidationError::FeatureValidationError(_)
-                )
-            })
-            .expect("There must be a FeatureValidation error")
-            .to_string();
-        assert_eq!(
-            "The feature `grafting` is used by the subgraph but it is not declared in the manifest.",
-            error_msg
-        )
-    })
-}
-
-#[test]
-fn declared_grafting_feature_causes_no_feature_validation_errors() {
-    const YAML: &str = "
-specVersion: 0.0.4
-features:
-  - grafting
-dataSources: []
-schema:
-  file:
-    /: /ipfs/Qmschema
-graft:
-  base: Qmbase
-  block: 1
-";
-    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 manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
-        assert!(manifest.features.contains(&SubgraphFeature::Grafting))
-    })
-}
-
-#[test]
-fn declared_non_fatal_errors_feature_causes_no_feature_validation_errors() {
-    const YAML: &str = "
-specVersion: 0.0.4
-features:
-  - nonFatalErrors
-dataSources: []
-schema:
-  file:
-    /: /ipfs/Qmschema
-";
-    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 manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
-        assert!(manifest.features.contains(&SubgraphFeature::NonFatalErrors))
-    });
-}
-
-#[test]
-fn declared_full_text_search_feature_causes_no_feature_validation_errors() {
-    const YAML: &str = "
-specVersion: 0.0.4
-features:
-  - fullTextSearch
-dataSources: []
-schema:
-  file:
-    /: /ipfs/Qmschema
-";
-
-    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_FULLTEXT);
-
-            let resolver: Arc<dyn LinkResolverTrait> = Arc::new(resolver);
-
-            let raw = serde_yaml::from_str(YAML).unwrap();
-            UnvalidatedSubgraphManifest::resolve(
-                id,
-                raw,
-                &resolver,
-                &LOGGER,
-                SPEC_VERSION_0_0_4.clone(),
-            )
-            .await
-            .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 manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
-        assert!(manifest.features.contains(&SubgraphFeature::FullTextSearch))
-    });
-}
-
-#[test]
-fn undeclared_full_text_search_feature_causes_no_feature_validation_errors() {
-    const YAML: &str = "
-specVersion: 0.0.4
-
-dataSources: []
-schema:
-  file:
-    /: /ipfs/Qmschema
-";
-
-    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_FULLTEXT);
-
-            let resolver: Arc<dyn LinkResolverTrait> = Arc::new(resolver);
-
-            let raw = serde_yaml::from_str(YAML).unwrap();
-            UnvalidatedSubgraphManifest::resolve(
-                id,
-                raw,
-                &resolver,
-                &LOGGER,
-                SPEC_VERSION_0_0_4.clone(),
-            )
-            .await
-            .expect("Parsing simple manifest works")
-        };
-
-        let error_msg = unvalidated
-            .validate(store.clone(), true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| {
-                matches!(
-                    e,
-                    SubgraphManifestValidationError::FeatureValidationError(_)
-                )
-            })
-            .expect("There must be a FeatureValidationError")
-            .to_string();
-
-        assert_eq!(
-            "The feature `fullTextSearch` is used by the subgraph but it is not declared in the manifest.",
-            error_msg
-        );
-    });
-}
-
-#[test]
-fn undeclared_ipfs_on_ethereum_contracts_feature_causes_feature_validation_error() {
-    const YAML: &str = "
-specVersion: 0.0.4
-schema:
-  file:
-    /: /ipfs/Qmschema
-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
-      callHandlers:
-        - function: get(address)
-          handler: handleget
-";
-
-    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 LinkResolverTrait> = Arc::new(resolver);
-
-            let raw = serde_yaml::from_str(YAML).unwrap();
-            UnvalidatedSubgraphManifest::resolve(
-                id,
-                raw,
-                &resolver,
-                &LOGGER,
-                SPEC_VERSION_0_0_4.clone(),
-            )
-            .await
-            .expect("Parsing simple manifest works")
-        };
-
-        let error_msg = unvalidated
-            .validate(store.clone(), true)
-            .await
-            .expect_err("Validation must fail")
-            .into_iter()
-            .find(|e| {
-                matches!(
-                    e,
-                    SubgraphManifestValidationError::FeatureValidationError(_)
-                )
-            })
-            .expect("There must be a FeatureValidationError")
-            .to_string();
-
-        assert_eq!(
-            "The feature `ipfsOnEthereumContracts` is used by the subgraph but it is not declared in the manifest.",
-            error_msg
-        );
-    });
-}
-
-#[test]
-fn declared_ipfs_on_ethereum_contracts_feature_causes_no_errors() {
-    const YAML: &str = "
-specVersion: 0.0.4
-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
-      callHandlers:
-        - function: get(address)
-          handler: handleget
-";
-
-    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 LinkResolverTrait> = Arc::new(resolver);
-
-            let raw = serde_yaml::from_str(YAML).unwrap();
-            UnvalidatedSubgraphManifest::resolve(
-                id,
-                raw,
-                &resolver,
-                &LOGGER,
-                SPEC_VERSION_0_0_4.clone(),
-            )
-            .await
-            .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());
-    });
-}
-
-#[test]
-fn can_detect_features_in_subgraphs_with_spec_version_lesser_than_0_0_4() {
-    const YAML: &str = "
-specVersion: 0.0.2
-features:
-  - nonFatalErrors
-dataSources: []
-schema:
-  file:
-    /: /ipfs/Qmschema
-";
-    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 manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
-        assert!(manifest.features.contains(&SubgraphFeature::NonFatalErrors))
-    });
-}
diff --git a/chain/near/Cargo.toml b/chain/near/Cargo.toml
index d41b901159e..d21f3755d0e 100644
--- a/chain/near/Cargo.toml
+++ b/chain/near/Cargo.toml
@@ -4,17 +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"] }
+diesel = { workspace = true }
+tokio = { workspace = true }
diff --git a/chain/near/build.rs b/chain/near/build.rs
index 73c33efb26f..feafe4718f9 100644
--- a/chain/near/build.rs
+++ b/chain/near/build.rs
@@ -1,7 +1,8 @@
 fn main() {
     println!("cargo:rerun-if-changed=proto");
-    tonic_build::configure()
+    tonic_prost_build::configure()
         .out_dir("src/protobuf")
-        .compile(&["proto/codec.proto"], &["proto"])
+        .extern_path(".sf.near.codec.v1", "crate::codec::pbcodec")
+        .compile_protos(&["proto/near.proto"], &["proto"])
         .expect("Failed to compile Firehose NEAR proto(s)");
 }
diff --git a/chain/near/proto/codec.proto b/chain/near/proto/near.proto
similarity index 100%
rename from chain/near/proto/codec.proto
rename to chain/near/proto/near.proto
diff --git a/chain/near/src/adapter.rs b/chain/near/src/adapter.rs
index 89c95b20c28..31c7dca7c97 100644
--- a/chain/near/src/adapter.rs
+++ b/chain/near/src/adapter.rs
@@ -1,9 +1,10 @@
 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;
 use graph::prelude::*;
 use prost::Message;
 use prost_types::Any;
@@ -17,6 +18,31 @@ pub struct TriggerFilter {
     pub(crate) receipt_filter: NearReceiptFilter,
 }
 
+impl TriggerFilter {
+    pub fn to_module_params(&self) -> String {
+        let matches = self.receipt_filter.accounts.iter().join(",");
+        let partial_matches = self
+            .receipt_filter
+            .partial_accounts
+            .iter()
+            .map(|(starts_with, ends_with)| match (starts_with, ends_with) {
+                (None, None) => unreachable!(),
+                (None, Some(e)) => format!(",{}", e),
+                (Some(s), None) => format!("{},", s),
+                (Some(s), Some(e)) => format!("{},{}", s, e),
+            })
+            .join("\n");
+
+        format!(
+            "{},{}\n{}\n{}",
+            self.receipt_filter.accounts.len(),
+            self.receipt_filter.partial_accounts.len(),
+            matches,
+            partial_matches
+        )
+    }
+}
+
 impl bc::TriggerFilter<Chain> for TriggerFilter {
     fn extend<'a>(&mut self, data_sources: impl Iterator<Item = &'a DataSource> + Clone) {
         let TriggerFilter {
@@ -225,7 +251,7 @@ mod test {
     use std::collections::HashSet;
 
     use super::NearBlockFilter;
-    use crate::adapter::{TriggerFilter, BASIC_RECEIPT_FILTER_TYPE_URL};
+    use crate::adapter::{BASIC_RECEIPT_FILTER_TYPE_URL, TriggerFilter};
     use graph::{
         blockchain::TriggerFilter as _,
         firehose::{BasicReceiptFilter, PrefixSuffixPair},
@@ -244,6 +270,7 @@ mod test {
                 partial_accounts: HashSet::new(),
             },
         };
+        assert_eq!(filter.to_module_params(), "0,0\n\n");
         assert_eq!(filter.to_firehose_filter(), vec![]);
     }
 
@@ -312,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(),
@@ -329,8 +356,7 @@ 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
diff --git a/chain/near/src/chain.rs b/chain/near/src/chain.rs
index 59e838a9322..5698301b5e8 100644
--- a/chain/near/src/chain.rs
+++ b/chain/near/src/chain.rs
@@ -1,36 +1,46 @@
+use async_trait::async_trait;
 use graph::blockchain::client::ChainClient;
-use graph::blockchain::BlockchainKind;
+use graph::blockchain::firehose_block_ingestor::FirehoseBlockIngestor;
+use graph::blockchain::{
+    BlockIngestor, BlockchainKind, NoopDecoderHook, NoopRuntimeAdapter, TriggerFilterWrapper,
+};
 use graph::cheap_clone::CheapClone;
+use graph::components::network_provider::ChainName;
+use graph::components::store::{ChainHeadStore, DeploymentCursorTracker, SourceableStore};
 use graph::data::subgraph::UnifiedMappingApiVersion;
 use graph::firehose::{FirehoseEndpoint, FirehoseEndpoints};
-use graph::prelude::{MetricsRegistry, TryFutureExt};
+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::Block;
 use crate::data_source::{DataSourceTemplate, UnresolvedDataSourceTemplate};
-use crate::runtime::RuntimeAdapter;
 use crate::trigger::{self, NearTrigger};
 use crate::{
     codec,
     data_source::{DataSource, UnresolvedDataSource},
 };
-use graph::blockchain::block_stream::{BlockStream, BlockStreamBuilder, FirehoseCursor};
+use graph::blockchain::block_stream::{
+    BlockStream, BlockStreamBuilder, BlockStreamError, BlockStreamMapper, FirehoseCursor,
+};
 
 pub struct NearStreamBuilder {}
 
@@ -54,23 +64,19 @@ impl BlockStreamBuilder<Chain> for NearStreamBuilder {
             )
             .unwrap_or_else(|_| panic!("no adapter for network {}", chain.name));
 
-        let firehose_endpoint = chain.chain_client().firehose_endpoint()?;
-
         let logger = chain
             .logger_factory
             .subgraph_logger(&deployment)
             .new(o!("component" => "FirehoseBlockStream"));
 
-        let firehose_mapper = Arc::new(FirehoseMapper {});
+        let firehose_mapper = Arc::new(FirehoseMapper { adapter, filter });
 
         Ok(Box::new(FirehoseBlockStream::new(
             deployment.hash,
-            firehose_endpoint,
+            chain.chain_client(),
             subgraph_current_block,
             block_cursor,
             firehose_mapper,
-            adapter,
-            filter,
             start_blocks,
             logger,
             chain.metrics_registry.clone(),
@@ -79,11 +85,12 @@ impl BlockStreamBuilder<Chain> for NearStreamBuilder {
 
     async fn build_polling(
         &self,
-        _chain: Arc<Chain>,
+        _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!()
@@ -92,10 +99,10 @@ impl BlockStreamBuilder<Chain> for NearStreamBuilder {
 
 pub struct Chain {
     logger_factory: LoggerFactory,
-    name: String,
+    name: ChainName,
     client: Arc<ChainClient<Self>>,
-    chain_store: Arc<dyn ChainStore>,
-    metrics_registry: Arc<dyn MetricsRegistry>,
+    chain_head_store: Arc<dyn ChainHeadStore>,
+    metrics_registry: Arc<MetricsRegistry>,
     block_stream_builder: Arc<dyn BlockStreamBuilder<Self>>,
 }
 
@@ -108,19 +115,18 @@ impl std::fmt::Debug for Chain {
 impl Chain {
     pub fn new(
         logger_factory: LoggerFactory,
-        name: String,
-        chain_store: Arc<dyn ChainStore>,
+        name: ChainName,
+        chain_head_store: Arc<dyn ChainHeadStore>,
         firehose_endpoints: FirehoseEndpoints,
-        metrics_registry: Arc<dyn MetricsRegistry>,
-        block_stream_builder: Arc<dyn BlockStreamBuilder<Self>>,
+        metrics_registry: Arc<MetricsRegistry>,
     ) -> Self {
         Chain {
             logger_factory,
             name,
+            chain_head_store,
             client: Arc::new(ChainClient::new_firehose(firehose_endpoints)),
-            chain_store,
             metrics_registry,
-            block_stream_builder,
+            block_stream_builder: Arc::new(NearStreamBuilder {}),
         }
     }
 }
@@ -148,6 +154,8 @@ impl Blockchain for Chain {
 
     type NodeCapabilities = EmptyNodeCapabilities<Chain>;
 
+    type DecoderHook = NoopDecoderHook;
+
     fn triggers_adapter(
         &self,
         _loc: &DeploymentLocator,
@@ -158,23 +166,23 @@ impl Blockchain for Chain {
         Ok(Arc::new(adapter))
     }
 
-    async fn new_firehose_block_stream(
+    async fn new_block_stream(
         &self,
         deployment: DeploymentLocator,
-        block_cursor: FirehoseCursor,
+        store: impl DeploymentCursorTracker,
         start_blocks: Vec<BlockNumber>,
-        subgraph_current_block: Option<BlockPtr>,
-        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> {
         self.block_stream_builder
             .build_firehose(
                 self,
                 deployment,
-                block_cursor,
+                store.firehose_cursor(),
                 start_blocks,
-                subgraph_current_block,
-                filter,
+                store.block_ptr(),
+                filter.chain_filter.clone(),
                 unified_api_version,
             )
             .await
@@ -189,22 +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."
+        )
     }
 
-    async fn new_polling_block_stream(
-        &self,
-        _deployment: DeploymentLocator,
-        _start_blocks: Vec<BlockNumber>,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<Self::TriggerFilter>,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        panic!("NEAR does not support polling block stream")
-    }
-
-    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(
@@ -212,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)
@@ -220,13 +219,26 @@ impl Blockchain for Chain {
             .await
     }
 
-    fn runtime_adapter(&self) -> Arc<dyn RuntimeAdapterTrait<Self>> {
-        Arc::new(RuntimeAdapter {})
+    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()
     }
+
+    async fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>> {
+        let ingestor = FirehoseBlockIngestor::<crate::HeaderOnlyBlock, Self>::new(
+            self.chain_head_store.cheap_clone(),
+            self.chain_client(),
+            self.logger_factory
+                .component_logger("NearFirehoseBlockIngestor", None),
+            self.name.clone(),
+        );
+        Ok(Box::new(ingestor))
+    }
 }
 
 pub struct TriggersAdapter {}
@@ -238,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,
@@ -312,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")
     }
@@ -327,18 +352,54 @@ impl TriggersAdapterTrait<Chain> for TriggersAdapter {
     }
 }
 
-pub struct FirehoseMapper {}
+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>, BlockStreamError> {
+        let block = match output {
+            Some(block) => codec::Block::decode(block)?,
+            None => {
+                return Err(anyhow::anyhow!(
+                    "near mapper is expected to always have a block"
+                ))
+                .map_err(BlockStreamError::from);
+            }
+        };
+
+        Ok(Some(block))
+    }
+
+    async fn block_with_triggers(
+        &self,
+        logger: &Logger,
+        block: codec::Block,
+    ) -> Result<BlockWithTriggers<Chain>, BlockStreamError> {
+        self.adapter
+            .triggers_in_block(logger, block, self.filter.as_ref())
+            .await
+            .map_err(BlockStreamError::from)
+    }
+}
 
 #[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,
-        adapter: &Arc<dyn TriggersAdapterTrait<Chain>>,
-        filter: &TriggerFilter,
     ) -> 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
@@ -357,12 +418,13 @@ impl FirehoseMapperTrait<Chain> for FirehoseMapper {
         //
         // 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())?;
+        // 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(
-                adapter.triggers_in_block(logger, block, filter).await?,
+                self.block_with_triggers(logger, block).await?,
                 FirehoseCursor::from(response.cursor.clone()),
             )),
 
@@ -379,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 => {
@@ -417,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;
@@ -440,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");
     }
@@ -448,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");
     }
@@ -462,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);
     }
 
@@ -476,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
@@ -497,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);
     }
 
@@ -573,8 +637,7 @@ mod test {
                 case.name,
                 receipt.partial_accounts,
             );
-            assert_eq!(
-                true,
+            assert!(
                 case.expected
                     .iter()
                     .all(|x| receipt.partial_accounts.contains(x)),
@@ -742,7 +805,7 @@ mod test {
         }
     }
 
-    #[tokio::test]
+    #[graph::test]
     async fn test_trigger_filter_empty() {
         let account1: String = "account1".into();
 
@@ -760,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();
 
@@ -786,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();
 
@@ -818,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,
@@ -837,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 {
@@ -873,6 +936,7 @@ mod test {
             source: crate::data_source::Source {
                 account,
                 start_block: 10,
+                end_block: None,
                 accounts: partial_accounts,
             },
             mapping: Mapping {
@@ -891,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 {
@@ -906,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 854e9dc1341..569e8cf5243 100644
--- a/chain/near/src/codec.rs
+++ b/chain/near/src/codec.rs
@@ -3,18 +3,17 @@
 pub mod pbcodec;
 
 use graph::{
-    blockchain::Block as BlockchainBlock,
-    blockchain::BlockPtr,
-    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)
     }
 }
 
@@ -27,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,
         }
     }
@@ -35,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))
     }
 }
 
@@ -71,6 +70,10 @@ impl BlockchainBlock for Block {
     fn parent_ptr(&self) -> Option<BlockPtr> {
         self.parent_ptr()
     }
+
+    fn timestamp(&self) -> BlockTime {
+        block_time_from_header(self.header())
+    }
 }
 
 impl HeaderOnlyBlock {
@@ -97,6 +100,10 @@ impl BlockchainBlock for HeaderOnlyBlock {
     fn parent_ptr(&self) -> Option<BlockPtr> {
         self.header().parent_ptr()
     }
+
+    fn timestamp(&self) -> BlockTime {
+        block_time_from_header(self.header())
+    }
 }
 
 impl execution_outcome::Status {
@@ -108,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 0742b05e8c8..01484905a58 100644
--- a/chain/near/src/data_source.rs
+++ b/chain/near/src/data_source.rs
@@ -1,22 +1,26 @@
+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, info, BlockNumber, CheapClone, DataSourceTemplateInfo, Deserialize, Link,
-        LinkResolver, Logger,
-    },
+    prelude::{BlockNumber, CheapClone, Deserialize, Link, LinkResolver, Logger},
     semver,
 };
+use std::collections::HashSet;
 use std::sync::Arc;
 
 use crate::chain::Chain;
 use crate::trigger::{NearTrigger, ReceiptWithOutcome};
 
 pub const NEAR_KIND: &str = "near";
+const BLOCK_HANDLER_KIND: &str = "block";
+const RECEIPT_HANDLER_KIND: &str = "receipt";
 
 /// Runtime representation of a data source.
 #[derive(Clone, Debug)]
@@ -31,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:
@@ -74,6 +81,24 @@ impl blockchain::DataSource<Chain> for DataSource {
         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_receipt().is_some() {
+            kinds.insert(RECEIPT_HANDLER_KIND);
+        }
+
+        kinds
+    }
+
+    fn end_block(&self) -> Option<BlockNumber> {
+        self.source.end_block
+    }
+
     fn match_and_decode(
         &self,
         trigger: &<Chain as Blockchain>::TriggerData,
@@ -141,6 +166,7 @@ impl blockchain::DataSource<Chain> for DataSource {
             trigger.cheap_clone(),
             handler.clone(),
             block.ptr(),
+            block.timestamp(),
         )))
     }
 
@@ -202,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 {
@@ -306,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,
@@ -319,9 +347,12 @@ impl blockchain::UnresolvedDataSource<Chain> for UnresolvedDataSource {
             context,
         } = self;
 
-        info!(logger, "Resolve data source"; "name" => &name, "source_account" => format_args!("{:?}", source.account), "source_start_block" => source.start_block);
-
-        let mapping = mapping.resolve(resolver, logger).await?;
+        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
+            )
+        })?;
 
         DataSource::from_manifest(kind, network, name, source, mapping, context)
     }
@@ -342,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,
@@ -353,13 +386,16 @@ impl blockchain::UnresolvedDataSourceTemplate<Chain> for UnresolvedDataSourceTem
             mapping,
         } = self;
 
-        info!(logger, "Resolve data source template"; "name" => &name);
+        let mapping = mapping
+            .resolve(deployment_hash, resolver, logger)
+            .await
+            .with_context(|| format!("failed to resolve data source template {}", name))?;
 
         Ok(DataSourceTemplate {
             kind,
             network,
             name,
-            mapping: mapping.resolve(resolver, logger).await?,
+            mapping,
         })
     }
 }
@@ -380,6 +416,10 @@ impl blockchain::DataSourceTemplate<Chain> for DataSourceTemplate {
     fn manifest_idx(&self) -> u32 {
         unreachable!("near does not support dynamic data sources")
     }
+
+    fn kind(&self) -> &str {
+        &self.kind
+    }
 }
 
 #[derive(Clone, Debug, Default, Hash, Eq, PartialEq, Deserialize)]
@@ -398,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> {
@@ -412,8 +453,10 @@ impl UnresolvedMapping {
 
         let api_version = semver::Version::parse(&api_version)?;
 
-        info!(logger, "Resolve mapping"; "link" => &link.link);
-        let module_bytes = resolver.cat(logger, &link).await?;
+        let module_bytes = resolver
+            .cat(&LinkResolverContext::new(deployment_hash, logger), &link)
+            .await
+            .with_context(|| format!("failed to resolve mapping {}", link.link))?;
 
         Ok(Mapping {
             api_version,
@@ -463,10 +506,12 @@ impl PartialAccounts {
 }
 
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub(crate) struct Source {
     // A data source that does not have an account or accounts can only have block handlers.
     pub(crate) account: Option<String>,
-    #[serde(rename = "startBlock", default)]
+    #[serde(default)]
     pub(crate) start_block: BlockNumber,
+    pub(crate) end_block: Option<BlockNumber>,
     pub(crate) accounts: Option<PartialAccounts>,
 }
diff --git a/chain/near/src/runtime/abi.rs b/chain/near/src/runtime/abi.rs
index f9142fa16c7..b74d8f5f7ff 100644
--- a/chain/near/src/runtime/abi.rs
+++ b/chain/near/src/runtime/abi.rs
@@ -1,189 +1,204 @@
 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, 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
-        let chunk_mask = Array::new(self.chunk_mask.as_ref(), heap, gas)?;
+    ) -> Result<AscBlockHeader, HostExportError> {
+        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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscChunkHeaderArray(Array::new(&content, heap, gas)?))
+    ) -> Result<AscChunkHeaderArray, HostExportError> {
+        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, DeterministicHostError> {
+    ) -> 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,
-    ) -> Result<AscActionReceipt, DeterministicHostError> {
+    ) -> Result<AscActionReceipt, HostExportError> {
         let action = match self.receipt.as_ref().unwrap() {
             codec::receipt::Receipt::Action(action) => action,
             codec::receipt::Receipt::Data(_) => {
-                return Err(DeterministicHostError::from(anyhow!(
-                    "Data receipt are now allowed"
-                )));
+                return Err(
+                    DeterministicHostError::from(anyhow!("Data receipt are now allowed")).into(),
+                );
             }
         };
 
         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,
-    ) -> Result<AscActionEnum, DeterministicHostError> {
+    ) -> Result<AscActionEnum, HostExportError> {
         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,122 +210,133 @@ 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, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscActionEnumArray(Array::new(&content, heap, gas)?))
+    ) -> Result<AscActionEnumArray, HostExportError> {
+        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,
-    ) -> Result<AscCreateAccountAction, DeterministicHostError> {
+    ) -> Result<AscCreateAccountAction, HostExportError> {
         Ok(AscCreateAccountAction {})
     }
 }
 
+#[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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> 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,
-    ) -> Result<AscAccessKeyPermissionEnum, DeterministicHostError> {
+    ) -> Result<AscAccessKeyPermissionEnum, HostExportError> {
         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,133 +348,147 @@ 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,
-    ) -> Result<AscFunctionCallPermission, DeterministicHostError> {
+    ) -> Result<AscFunctionCallPermission, HostExportError> {
         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,
-    ) -> Result<AscFullAccessPermission, DeterministicHostError> {
+    ) -> Result<AscFullAccessPermission, HostExportError> {
         Ok(AscFullAccessPermission {})
     }
 }
 
+#[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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscDataReceiverArray(Array::new(&content, heap, gas)?))
+    ) -> Result<AscDataReceiverArray, HostExportError> {
+        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,
-    ) -> Result<AscExecutionOutcome, DeterministicHostError> {
+    ) -> Result<AscExecutionOutcome, HostExportError> {
         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,
-    ) -> Result<AscSuccessStatusEnum, DeterministicHostError> {
+    ) -> Result<AscSuccessStatusEnum, HostExportError> {
         let (kind, payload) = match self {
             codec::execution_outcome::Status::SuccessValue(value) => {
                 let bytes = &value.value;
 
                 (
                     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!(
                     "Failure execution status are not allowed"
-                )));
+                ))
+                .into());
             }
             codec::execution_outcome::Status::Unknown(_) => {
                 return Err(DeterministicHostError::from(anyhow!(
                     "Unknown execution status are not allowed"
-                )));
+                ))
+                .into());
             }
         };
 
@@ -460,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, DeterministicHostError> {
+    ) -> 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,
@@ -475,31 +516,38 @@ impl ToAscObj<AscMerklePathItem> for codec::MerklePathItem {
                     return Err(DeterministicHostError::from(anyhow!(
                         "Invalid direction value {}",
                         x
-                    )))
+                    ))
+                    .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, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscMerklePathItemArray(Array::new(&content, heap, gas)?))
+    ) -> Result<AscMerklePathItemArray, HostExportError> {
+        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,
-    ) -> Result<AscSignature, DeterministicHostError> {
+    ) -> Result<AscSignature, HostExportError> {
         Ok(AscSignature {
             kind: match self.r#type {
                 0 => 0,
@@ -508,32 +556,37 @@ impl ToAscObj<AscSignature> for codec::Signature {
                     return Err(DeterministicHostError::from(anyhow!(
                         "Invalid signature type {}",
                         value,
-                    )))
+                    ))
+                    .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, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscSignatureArray(Array::new(&content, heap, gas)?))
+    ) -> Result<AscSignatureArray, HostExportError> {
+        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,
-    ) -> Result<AscPublicKey, DeterministicHostError> {
+    ) -> Result<AscPublicKey, HostExportError> {
         Ok(AscPublicKey {
             kind: match self.r#type {
                 0 => 0,
@@ -542,96 +595,114 @@ impl ToAscObj<AscPublicKey> for codec::PublicKey {
                     return Err(DeterministicHostError::from(anyhow!(
                         "Invalid public key type {}",
                         value,
-                    )))
+                    ))
+                    .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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscValidatorStakeArray(Array::new(&content, heap, gas)?))
+    ) -> Result<AscValidatorStakeArray, HostExportError> {
+        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, DeterministicHostError> {
+    ) -> 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, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscSlashedValidatorArray(Array::new(&content, heap, gas)?))
+    ) -> Result<AscSlashedValidatorArray, HostExportError> {
+        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, DeterministicHostError> {
-        self.bytes.to_asc_obj(heap, gas)
+    ) -> Result<AscCryptoHash, HostExportError> {
+        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, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Ok(AscCryptoHashArray(Array::new(&content, heap, gas)?))
+    ) -> Result<AscCryptoHashArray, HostExportError> {
+        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,
-    ) -> Result<Uint8Array, DeterministicHostError> {
+    ) -> Result<Uint8Array, HostExportError> {
         // 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/runtime/mod.rs b/chain/near/src/runtime/mod.rs
index f44391caffd..31e18de7dd8 100644
--- a/chain/near/src/runtime/mod.rs
+++ b/chain/near/src/runtime/mod.rs
@@ -1,6 +1,3 @@
-pub use runtime_adapter::RuntimeAdapter;
-
 pub mod abi;
-pub mod runtime_adapter;
 
 mod generated;
diff --git a/chain/near/src/runtime/runtime_adapter.rs b/chain/near/src/runtime/runtime_adapter.rs
deleted file mode 100644
index c5fa9e15059..00000000000
--- a/chain/near/src/runtime/runtime_adapter.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use crate::{data_source::DataSource, Chain};
-use blockchain::HostFn;
-use graph::{anyhow::Error, blockchain};
-
-pub struct RuntimeAdapter {}
-
-impl blockchain::RuntimeAdapter<Chain> for RuntimeAdapter {
-    fn host_fns(&self, _ds: &DataSource) -> Result<Vec<HostFn>, Error> {
-        Ok(vec![])
-    }
-}
diff --git a/chain/near/src/trigger.rs b/chain/near/src/trigger.rs
index 6fc31e8aefe..bf9794d2b20 100644
--- a/chain/near/src/trigger.rs
+++ b/chain/near/src/trigger.rs
@@ -1,10 +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::runtime::{asc_new, gas::GasCounter, AscHeap, AscPtr, DeterministicHostError};
+use graph::prelude::alloy::primitives::B256;
+use graph::prelude::hex;
+use graph::runtime::HostExportError;
+use graph::runtime::{AscHeap, AscPtr, asc_new, gas::GasCounter};
 use graph_runtime_wasm::module::ToAscPtr;
 use std::{cmp::Ordering, sync::Arc};
 
@@ -13,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,
@@ -35,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<()>, DeterministicHostError> {
+    ) -> 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) {
@@ -84,10 +80,26 @@ impl NearTrigger {
         }
     }
 
-    pub fn block_hash(&self) -> H256 {
+    pub fn block_hash(&self) -> B256 {
+        match self {
+            NearTrigger::Block(block) => block.ptr().hash.as_b256(),
+            NearTrigger::Receipt(receipt) => receipt.block.ptr().hash.as_b256(),
+        }
+    }
+
+    fn error_context(&self) -> std::string::String {
         match self {
-            NearTrigger::Block(block) => block.ptr().hash_as_h256(),
-            NearTrigger::Receipt(receipt) => receipt.block.ptr().hash_as_h256(),
+            NearTrigger::Block(..) => {
+                format!("Block #{} ({})", self.block_number(), self.block_hash())
+            }
+            NearTrigger::Receipt(receipt) => {
+                format!(
+                    "receipt id {}, block #{} ({})",
+                    hex::encode(&receipt.receipt.receipt_id.as_ref().unwrap().bytes),
+                    self.block_number(),
+                    self.block_hash()
+                )
+            }
         }
     }
 }
@@ -116,20 +128,18 @@ impl PartialOrd for NearTrigger {
 }
 
 impl TriggerData for NearTrigger {
-    fn error_context(&self) -> std::string::String {
-        match self {
-            NearTrigger::Block(..) => {
-                format!("Block #{} ({})", self.block_number(), self.block_hash())
-            }
-            NearTrigger::Receipt(receipt) => {
-                format!(
-                    "receipt id {}, block #{} ({})",
-                    hex::encode(&receipt.receipt.receipt_id.as_ref().unwrap().bytes),
-                    self.block_number(),
-                    self.block_hash()
-                )
-            }
-        }
+    fn error_context(&self) -> String {
+        self.error_context()
+    }
+
+    fn address_match(&self) -> Option<&[u8]> {
+        None
+    }
+}
+
+impl MappingTriggerTrait for NearTrigger {
+    fn error_context(&self) -> String {
+        self.error_context()
     }
 }
 
@@ -142,29 +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,
+        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::default());
+        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()),
@@ -172,7 +183,9 @@ mod tests {
             receipt: receipt().unwrap(),
         }));
 
-        let result = trigger.to_asc_ptr(&mut heap, &GasCounter::default());
+        let result = trigger
+            .to_asc_ptr(&mut heap, &GasCounter::new(GasMetrics::mock()))
+            .await;
         assert!(result.is_ok());
     }
 
@@ -392,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 })
@@ -435,8 +447,9 @@ mod tests {
         }
     }
 
+    #[async_trait]
     impl AscHeap for BytesHeap {
-        fn raw_new(
+        async fn raw_new(
             &mut self,
             bytes: &[u8],
             _gas: &GasCounter,
@@ -488,14 +501,14 @@ 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, DeterministicHostError> {
+        ) -> Result<u32, HostExportError> {
             // Not totally clear what is the purpose of this method, why not a default implementation here?
             Ok(type_id_index as u32)
         }
diff --git a/chain/substreams/Cargo.toml b/chain/substreams/Cargo.toml
deleted file mode 100644
index ad557e27c4f..00000000000
--- a/chain/substreams/Cargo.toml
+++ /dev/null
@@ -1,32 +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.16"
-base64 = "0.20.0"
-
-itertools = "0.10.5"
-
-[dev-dependencies]
-graph-core = { path = "../../core" }
-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 a6f74692f52..00000000000
--- a/chain/substreams/examples/substreams.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use anyhow::{format_err, Context, Error};
-use graph::blockchain::block_stream::BlockStreamEvent;
-use graph::blockchain::substreams_block_stream::SubstreamsBlockStream;
-use graph::firehose::SubgraphLimit;
-use graph::prelude::{info, tokio, DeploymentHash, Registry};
-use graph::tokio_stream::StreamExt;
-use graph::{env::env_var, firehose::FirehoseEndpoint, log::logger, substreams};
-use graph_chain_substreams::mapper::Mapper;
-use graph_core::MetricsRegistry;
-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 firehose = Arc::new(FirehoseEndpoint::new(
-        "substreams",
-        &endpoint,
-        token,
-        false,
-        false,
-        SubgraphLimit::Unlimited,
-    ));
-
-    let mut stream: SubstreamsBlockStream<graph_chain_substreams::Chain> =
-        SubstreamsBlockStream::new(
-            DeploymentHash::new("substreams".to_string()).unwrap(),
-            firehose.clone(),
-            None,
-            None,
-            Arc::new(Mapper {}),
-            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::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 a24dcb97310..00000000000
--- a/chain/substreams/proto/codec.proto
+++ /dev/null
@@ -1,46 +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_stream.rs b/chain/substreams/src/block_stream.rs
deleted file mode 100644
index 441d28dc1d1..00000000000
--- a/chain/substreams/src/block_stream.rs
+++ /dev/null
@@ -1,78 +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},
-    slog::o,
-};
-
-use crate::{mapper::Mapper, 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_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 firehose_endpoint = chain.chain_client().firehose_endpoint()?;
-
-        let mapper = Arc::new(Mapper {});
-
-        let logger = chain
-            .logger_factory
-            .subgraph_logger(&deployment)
-            .new(o!("component" => "SubstreamsBlockStream"));
-
-        Ok(Box::new(SubstreamsBlockStream::new(
-            deployment.hash,
-            firehose_endpoint,
-            subgraph_current_block,
-            block_cursor.as_ref().clone(),
-            mapper,
-            filter.modules.clone(),
-            filter.module_name.clone(),
-            filter.start_block.map(|x| vec![x]).unwrap_or_default(),
-            vec![],
-            logger,
-            chain.metrics_registry.clone(),
-        )))
-    }
-
-    async fn build_polling(
-        &self,
-        _chain: Arc<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 b42eecc6118..00000000000
--- a/chain/substreams/src/chain.rs
+++ /dev/null
@@ -1,185 +0,0 @@
-use crate::{data_source::*, EntityChanges, TriggerData, TriggerFilter, TriggersAdapter};
-use anyhow::Error;
-use graph::blockchain::client::ChainClient;
-use graph::blockchain::EmptyNodeCapabilities;
-use graph::firehose::FirehoseEndpoints;
-use graph::prelude::{BlockHash, LoggerFactory, MetricsRegistry};
-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;
-
-#[derive(Default, Debug, Clone)]
-pub struct Block {
-    pub hash: BlockHash,
-    pub number: BlockNumber,
-    pub changes: EntityChanges,
-}
-
-impl blockchain::Block for Block {
-    fn ptr(&self) -> BlockPtr {
-        BlockPtr {
-            hash: self.hash.clone(),
-            number: self.number,
-        }
-    }
-
-    fn parent_ptr(&self) -> Option<BlockPtr> {
-        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<dyn MetricsRegistry>,
-}
-
-impl Chain {
-    pub fn new(
-        logger_factory: LoggerFactory,
-        firehose_endpoints: FirehoseEndpoints,
-        metrics_registry: Arc<dyn 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_firehose_block_stream(
-        &self,
-        deployment: DeploymentLocator,
-        block_cursor: FirehoseCursor,
-        start_blocks: Vec<BlockNumber>,
-        subgraph_current_block: Option<BlockPtr>,
-        filter: Arc<Self::TriggerFilter>,
-        unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        self.block_stream_builder
-            .build_firehose(
-                self,
-                deployment,
-                block_cursor,
-                start_blocks,
-                subgraph_current_block,
-                filter,
-                unified_api_version,
-            )
-            .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.")
-    }
-
-    async fn new_polling_block_stream(
-        &self,
-        _deployment: DeploymentLocator,
-        _start_blocks: Vec<BlockNumber>,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: Arc<Self::TriggerFilter>,
-        _unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
-        unimplemented!("this should never be called for substreams")
-    }
-
-    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(RuntimeAdapter {})
-    }
-
-    fn chain_client(&self) -> Arc<ChainClient<Self>> {
-        self.client.clone()
-    }
-}
-
-pub struct RuntimeAdapter {}
-impl RuntimeAdapterTrait<crate::Chain> for RuntimeAdapter {
-    fn host_fns(
-        &self,
-        _ds: &<crate::Chain as Blockchain>::DataSource,
-    ) -> Result<Vec<blockchain::HostFn>, Error> {
-        todo!()
-    }
-}
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 9e3389189ef..00000000000
--- a/chain/substreams/src/data_source.rs
+++ /dev/null
@@ -1,405 +0,0 @@
-use std::sync::Arc;
-
-use anyhow::{anyhow, 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"];
-
-#[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 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()
-    }
-
-    // runtime is not needed for substreams, it will cause the host creation to be skipped.
-    fn runtime(&self) -> Option<Arc<Vec<u8>>> {
-        None
-    }
-
-    // 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,
-}
-
-#[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,
-}
-
-#[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 package = graph::substreams::Package::decode(content.as_ref())?;
-
-        let initial_block: Option<u64> = match package.modules {
-            Some(ref modules) => modules.modules.iter().map(|x| x.initial_block).min(),
-            None => None,
-        };
-
-        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)?;
-
-        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,
-            },
-            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 {
-    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,
-}
-
-#[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!()
-    }
-}
-
-#[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},
-    };
-
-    use crate::{DataSource, Mapping, UnresolvedDataSource, UnresolvedMapping, SUBSTREAMS_KIND};
-
-    const EMPTY_PACKAGE: graph::substreams::Package = graph::substreams::Package {
-        proto_files: vec![],
-        version: 0,
-        modules: None,
-        module_meta: vec![],
-        package_meta: vec![],
-    };
-
-    #[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(),
-                    },
-                },
-            },
-            mapping: UnresolvedMapping {
-                api_version: "0.0.7".into(),
-                kind: "substreams/graph-entities".into(),
-            },
-        };
-        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: EMPTY_PACKAGE,
-            },
-            mapping: Mapping {
-                api_version: semver::Version::from_str("0.0.7").unwrap(),
-                kind: "substreams/graph-entities".into(),
-            },
-            context: Arc::new(None),
-            initial_block: None,
-        };
-        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"
-            ]
-        );
-    }
-
-    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: EMPTY_PACKAGE,
-            },
-            mapping: Mapping {
-                api_version: semver::Version::from_str("0.0.7").unwrap(),
-                kind: "substreams/graph-entities".into(),
-            },
-            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
-    "#;
-
-    #[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(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 60215c453cc..00000000000
--- a/chain/substreams/src/lib.rs
+++ /dev/null
@@ -1,15 +0,0 @@
-mod block_stream;
-mod chain;
-mod codec;
-mod data_source;
-mod trigger;
-
-pub mod mapper;
-
-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 e9d5ba06862..00000000000
--- a/chain/substreams/src/mapper.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use crate::{Block, Chain, EntityChanges, TriggerData};
-use graph::blockchain::block_stream::SubstreamsError::{
-    MultipleModuleOutputError, UnexpectedStoreDeltaOutput,
-};
-use graph::blockchain::block_stream::{
-    BlockStreamEvent, BlockWithTriggers, FirehoseCursor, SubstreamsError, SubstreamsMapper,
-};
-use graph::prelude::{async_trait, BlockHash, BlockNumber, BlockPtr, Logger};
-use graph::substreams::module_output::Data;
-use graph::substreams::{BlockScopedData, Clock, ForkStep};
-use prost::Message;
-
-pub struct Mapper {}
-
-#[async_trait]
-impl SubstreamsMapper<Chain> for Mapper {
-    async fn to_block_stream_event(
-        &self,
-        logger: &Logger,
-        block_scoped_data: &BlockScopedData,
-    ) -> Result<Option<BlockStreamEvent<Chain>>, SubstreamsError> {
-        let BlockScopedData {
-            outputs,
-            clock,
-            step,
-            cursor: _,
-        } = block_scoped_data;
-
-        let step = ForkStep::from_i32(*step).unwrap_or_else(|| {
-            panic!(
-                "unknown step i32 value {}, maybe you forgot update & re-regenerate the protobuf definitions?",
-                step
-            )
-        });
-
-        if outputs.is_empty() {
-            return Ok(None);
-        }
-
-        if outputs.len() > 1 {
-            return Err(MultipleModuleOutputError);
-        }
-
-        //todo: handle step
-        let module_output = &block_scoped_data.outputs[0];
-        let cursor = &block_scoped_data.cursor;
-
-        let clock = match clock {
-            Some(clock) => clock,
-            None => return Err(SubstreamsError::MissingClockError),
-        };
-
-        let Clock {
-            id: hash,
-            number,
-            timestamp: _,
-        } = clock;
-
-        let hash: BlockHash = hash.as_str().try_into()?;
-        let number: BlockNumber = *number as BlockNumber;
-
-        match module_output.data.as_ref() {
-            Some(Data::MapOutput(msg)) => {
-                let changes: EntityChanges = Message::decode(msg.value.as_slice())
-                    .map_err(SubstreamsError::DecodingError)?;
-
-                use ForkStep::*;
-                match step {
-                    StepIrreversible | StepNew => Ok(Some(BlockStreamEvent::ProcessBlock(
-                        // Even though the trigger processor for substreams doesn't care about TriggerData
-                        // there are a bunch of places in the runner that check if trigger data
-                        // empty and skip processing if so. This will prolly breakdown
-                        // close to head so we will need to improve things.
-
-                        // TODO(filipe): Fix once either trigger data can be empty
-                        // or we move the changes into trigger data.
-                        BlockWithTriggers::new(
-                            Block {
-                                hash,
-                                number,
-                                changes,
-                            },
-                            vec![TriggerData {}],
-                            logger,
-                        ),
-                        FirehoseCursor::from(cursor.clone()),
-                    ))),
-                    StepUndo => {
-                        let parent_ptr = BlockPtr { hash, number };
-
-                        Ok(Some(BlockStreamEvent::Revert(
-                            parent_ptr,
-                            FirehoseCursor::from(cursor.clone()),
-                        )))
-                    }
-                    StepUnknown => {
-                        panic!("unknown step should not happen in the Firehose response")
-                    }
-                }
-            }
-            Some(Data::DebugStoreDeltas(_)) => Err(UnexpectedStoreDeltaOutput),
-            _ => Err(SubstreamsError::ModuleOutputNotPresentOrUnexpected),
-        }
-    }
-}
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 f4a7729c78c..00000000000
--- a/chain/substreams/src/trigger.rs
+++ /dev/null
@@ -1,411 +0,0 @@
-use std::{collections::HashMap, str::FromStr, sync::Arc};
-
-use anyhow::Error;
-use graph::{
-    blockchain::{self, block_stream::BlockWithTriggers, BlockPtr, EmptyNodeCapabilities},
-    components::{
-        store::{DeploymentLocator, EntityKey, EntityType, SubgraphFork},
-        subgraph::{MappingError, ProofOfIndexingEvent, SharedProofOfIndexing},
-    },
-    data::store::scalar::Bytes,
-    data_source::{self, CausalityRegion},
-    prelude::{
-        anyhow, async_trait, BigDecimal, BigInt, BlockHash, BlockNumber, BlockState, Entity,
-        RuntimeHostBuilder, Value,
-    },
-    slog::Logger,
-    substreams::Modules,
-};
-use graph_runtime_wasm::module::ToAscPtr;
-use lazy_static::__Deref;
-
-use crate::codec;
-use crate::{codec::entity_change::Operation, Block, Chain, NoopDataSourceTemplate};
-
-#[derive(Eq, PartialEq, PartialOrd, Ord, Debug)]
-pub struct TriggerData {}
-
-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()
-    }
-}
-
-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::DeterministicHostError> {
-        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,
-}
-
-// 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,
-        } = 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;
-        }
-    }
-
-    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,
-        _hosts: &[Arc<T::Host>],
-        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>,
-    ) -> Result<BlockState<Chain>, MappingError> {
-        for entity_change in block.changes.entity_changes.iter() {
-            match entity_change.operation() {
-                Operation::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")));
-                }
-                Operation::Create | Operation::Update => {
-                    let entity_type: &str = &entity_change.entity;
-                    let entity_id: String = entity_change.id.clone();
-                    let key = EntityKey {
-                        entity_type: EntityType::new(entity_type.to_string()),
-                        entity_id: entity_id.clone().into(),
-                        causality_region: CausalityRegion::ONCHAIN, // Substreams don't currently support offchain data
-                    };
-                    let mut data: HashMap<String, Value> = HashMap::from_iter(vec![]);
-
-                    for field in entity_change.fields.iter() {
-                        let new_value: &codec::value::Typed = match &field.new_value {
-                            Some(codec::Value {
-                                typed: Some(new_value),
-                            }) => new_value,
-                            _ => continue,
-                        };
-
-                        let value: Value = decode_value(new_value)?;
-                        *data.entry(field.name.clone()).or_insert(Value::Null) = value;
-                    }
-
-                    write_poi_event(
-                        proof_of_indexing,
-                        &ProofOfIndexingEvent::SetEntity {
-                            entity_type,
-                            id: &entity_id,
-                            data: &data,
-                        },
-                        causality_region,
-                        logger,
-                    );
-
-                    state.entity_cache.set(key, Entity::from(data))?;
-                }
-                Operation::Delete => {
-                    let entity_type: &str = &entity_change.entity;
-                    let entity_id: String = entity_change.id.clone();
-                    let key = EntityKey {
-                        entity_type: EntityType::new(entity_type.to_string()),
-                        entity_id: entity_id.clone().into(),
-                        causality_region: CausalityRegion::ONCHAIN, // Substreams don't currently support offchain data
-                    };
-
-                    state.entity_cache.remove(key);
-
-                    write_poi_event(
-                        proof_of_indexing,
-                        &ProofOfIndexingEvent::RemoveEntity {
-                            entity_type,
-                            id: &entity_id,
-                        },
-                        causality_region,
-                        logger,
-                    )
-                }
-            }
-        }
-
-        Ok(state)
-    }
-}
-
-fn decode_value(value: &crate::codec::value::Typed) -> Result<Value, MappingError> {
-    use 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| MappingError::Unknown(anyhow::Error::from(err))),
-
-        Typed::Bigint(new_value) => BigInt::from_str(new_value)
-            .map(Value::BigInt)
-            .map_err(|err| MappingError::Unknown(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.as_ref())))
-            .map_err(|err| MappingError::Unknown(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::<Result<Vec<Value>, MappingError>>()
-            .map(Value::List),
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use std::{ops::Add, str::FromStr};
-
-    use crate::codec::value::Typed;
-    use crate::codec::{Array, Value};
-    use crate::trigger::decode_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/core/Cargo.toml b/core/Cargo.toml
index 8700190cab5..a4b38367213 100644
--- a/core/Cargo.toml
+++ b/core/Cargo.toml
@@ -4,40 +4,36 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-async-trait = "0.1.50"
-atomic_refcell = "0.1.9"
-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" }
-lazy_static = "1.2.0"
-lru_time_cache = "0.11"
-semver = "1.0.16"
-serde = "1.0"
-serde_json = "1.0"
-serde_yaml = "0.8"
+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.10.1"
+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" }
-graph-mock = { path = "../mock" }
-test-store = { path = "../store/test-store" }
-hex = "0.4.3"
-graphql-parser = "0.4.0"
-pretty_assertions = "1.3.0"
-anyhow = "1.0"
-ipfs-api-backend-hyper = "0.6"
-ipfs-api = { version = "0.17.0", features = ["with-hyper-rustls"], default-features = false }
-uuid = { version = "1.3.0", 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 972a45e508f..118ce3ebaae 100644
--- a/core/src/lib.rs
+++ b/core/src/lib.rs
@@ -1,12 +1,6 @@
-pub mod polling_monitor;
-
-mod link_resolver;
-mod metrics;
-mod subgraph;
+mod subgraph_manifest;
 
-pub use crate::link_resolver::LinkResolver;
-pub use crate::metrics::MetricsRegistry;
-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 cebc39d5d6a..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<Arc<IpfsClient>>>,
-    logger: Logger,
-    api: StatApi,
-    path: String,
-    timeout: Duration,
-    do_retry: bool,
-) -> Result<(u64, Arc<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<Arc<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().map(Arc::new).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/metrics/mod.rs b/core/src/metrics/mod.rs
deleted file mode 100644
index 047d6b24132..00000000000
--- a/core/src/metrics/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod registry;
-
-pub use registry::MetricsRegistry;
diff --git a/core/src/metrics/registry.rs b/core/src/metrics/registry.rs
deleted file mode 100644
index 067cf4d9faf..00000000000
--- a/core/src/metrics/registry.rs
+++ /dev/null
@@ -1,331 +0,0 @@
-use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
-
-use graph::components::metrics::{counter_with_labels, gauge_with_labels};
-use graph::prelude::{MetricsRegistry as MetricsRegistryTrait, *};
-
-#[derive(Clone)]
-pub struct MetricsRegistry {
-    logger: Logger,
-    registry: Arc<Registry>,
-    register_errors: Box<Counter>,
-    unregister_errors: Box<Counter>,
-    registered_metrics: Box<Gauge>,
-
-    /// Global metrics are lazily initialized and identified by
-    /// the `Desc.id` that hashes the name and const label values
-    global_counters: Arc<RwLock<HashMap<u64, Counter>>>,
-    global_counter_vecs: Arc<RwLock<HashMap<u64, CounterVec>>>,
-    global_gauges: Arc<RwLock<HashMap<u64, Gauge>>>,
-    global_gauge_vecs: Arc<RwLock<HashMap<u64, GaugeVec>>>,
-    global_histogram_vecs: Arc<RwLock<HashMap<u64, HistogramVec>>>,
-}
-
-impl MetricsRegistry {
-    pub fn new(logger: Logger, registry: Arc<Registry>) -> Self {
-        // Generate internal metrics
-        let register_errors = Self::gen_register_errors_counter(registry.clone());
-        let unregister_errors = Self::gen_unregister_errors_counter(registry.clone());
-        let registered_metrics = Self::gen_registered_metrics_gauge(registry.clone());
-
-        MetricsRegistry {
-            logger: logger.new(o!("component" => String::from("MetricsRegistry"))),
-            registry,
-            register_errors,
-            unregister_errors,
-            registered_metrics,
-            global_counters: Arc::new(RwLock::new(HashMap::new())),
-            global_counter_vecs: Arc::new(RwLock::new(HashMap::new())),
-            global_gauges: Arc::new(RwLock::new(HashMap::new())),
-            global_gauge_vecs: Arc::new(RwLock::new(HashMap::new())),
-            global_histogram_vecs: Arc::new(RwLock::new(HashMap::new())),
-        }
-    }
-
-    fn gen_register_errors_counter(registry: Arc<Registry>) -> Box<Counter> {
-        let opts = Opts::new(
-            String::from("metrics_register_errors"),
-            String::from("Counts Prometheus metrics register errors"),
-        );
-        let counter = Box::new(
-            Counter::with_opts(opts).expect("failed to create `metrics_register_errors` counter"),
-        );
-        registry
-            .register(counter.clone())
-            .expect("failed to register `metrics_register_errors` counter");
-        counter
-    }
-
-    fn gen_unregister_errors_counter(registry: Arc<Registry>) -> Box<Counter> {
-        let opts = Opts::new(
-            String::from("metrics_unregister_errors"),
-            String::from("Counts Prometheus metrics unregister errors"),
-        );
-        let counter = Box::new(
-            Counter::with_opts(opts).expect("failed to create `metrics_unregister_errors` counter"),
-        );
-        registry
-            .register(counter.clone())
-            .expect("failed to register `metrics_unregister_errors` counter");
-        counter
-    }
-
-    fn gen_registered_metrics_gauge(registry: Arc<Registry>) -> Box<Gauge> {
-        let opts = Opts::new(
-            String::from("registered_metrics"),
-            String::from("Tracks the number of registered metrics on the node"),
-        );
-        let gauge =
-            Box::new(Gauge::with_opts(opts).expect("failed to create `registered_metrics` gauge"));
-        registry
-            .register(gauge.clone())
-            .expect("failed to register `registered_metrics` gauge");
-        gauge
-    }
-
-    fn global_counter_vec_internal(
-        &self,
-        name: &str,
-        help: &str,
-        deployment: Option<&str>,
-        variable_labels: &[&str],
-    ) -> Result<CounterVec, PrometheusError> {
-        let opts = Opts::new(name, help);
-        let opts = match deployment {
-            None => opts,
-            Some(deployment) => opts.const_label("deployment", deployment),
-        };
-        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();
-        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)
-        }
-    }
-}
-
-impl MetricsRegistryTrait for MetricsRegistry {
-    fn register(&self, name: &str, c: Box<dyn Collector>) {
-        let err = match self.registry.register(c).err() {
-            None => {
-                self.registered_metrics.inc();
-                return;
-            }
-            Some(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
-                );
-            }
-        };
-    }
-
-    fn global_counter(
-        &self,
-        name: &str,
-        help: &str,
-        const_labels: HashMap<String, String>,
-    ) -> 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();
-        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());
-            Ok(counter)
-        }
-    }
-
-    fn global_counter_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: &[&str],
-    ) -> Result<CounterVec, PrometheusError> {
-        self.global_counter_vec_internal(name, help, None, variable_labels)
-    }
-
-    fn global_deployment_counter_vec(
-        &self,
-        name: &str,
-        help: &str,
-        subgraph: &str,
-        variable_labels: &[&str],
-    ) -> Result<CounterVec, PrometheusError> {
-        self.global_counter_vec_internal(name, help, Some(subgraph), variable_labels)
-    }
-
-    fn global_gauge(
-        &self,
-        name: &str,
-        help: &str,
-        const_labels: HashMap<String, String>,
-    ) -> 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();
-        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());
-            Ok(gauge)
-        }
-    }
-
-    fn global_gauge_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: &[&str],
-    ) -> Result<GaugeVec, PrometheusError> {
-        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();
-        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());
-            Ok(gauges)
-        }
-    }
-
-    fn global_histogram_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: &[&str],
-    ) -> Result<HistogramVec, PrometheusError> {
-        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();
-        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)
-        }
-    }
-
-    fn unregister(&self, metric: Box<dyn Collector>) {
-        match self.registry.unregister(metric) {
-            Ok(_) => {
-                self.registered_metrics.dec();
-            }
-            Err(e) => {
-                self.unregister_errors.inc();
-                error!(self.logger, "Unregistering metric failed = {:?}", e,);
-            }
-        };
-    }
-}
-
-#[test]
-fn global_counters_are_shared() {
-    use graph::log;
-
-    let logger = log::logger(false);
-    let prom_reg = Arc::new(Registry::new());
-    let registry = MetricsRegistry::new(logger, prom_reg);
-
-    fn check_counters(
-        registry: &MetricsRegistry,
-        name: &str,
-        const_labels: HashMap<String, String>,
-    ) {
-        let c1 = registry
-            .global_counter(name, "help me", const_labels.clone())
-            .expect("first test counter");
-        let c2 = registry
-            .global_counter(name, "help me", const_labels)
-            .expect("second test counter");
-        let desc1 = c1.desc();
-        let desc2 = c2.desc();
-        let d1 = desc1.first().unwrap();
-        let d2 = desc2.first().unwrap();
-
-        // Registering the same metric with the same name and
-        // const labels twice works and returns the same metric (logically)
-        assert_eq!(d1.id, d2.id, "counters: {}", name);
-
-        // They share the reported values
-        c1.inc_by(7.0);
-        c2.inc_by(2.0);
-        assert_eq!(9.0, c1.get(), "counters: {}", name);
-        assert_eq!(9.0, c2.get(), "counters: {}", name);
-    }
-
-    check_counters(&registry, "nolabels", HashMap::new());
-
-    let const_labels = {
-        let mut map = HashMap::new();
-        map.insert("pool".to_owned(), "main".to_owned());
-        map
-    };
-    check_counters(&registry, "pool", const_labels);
-
-    let const_labels = {
-        let mut map = HashMap::new();
-        map.insert("pool".to_owned(), "replica0".to_owned());
-        map
-    };
-    check_counters(&registry, "pool", const_labels);
-}
diff --git a/core/src/polling_monitor/arweave_service.rs b/core/src/polling_monitor/arweave_service.rs
new file mode 100644
index 00000000000..cc42f7af5ea
--- /dev/null
+++ b/core/src/polling_monitor/arweave_service.rs
@@ -0,0 +1,50 @@
+use anyhow::Error;
+use bytes::Bytes;
+use graph::futures03::future::BoxFuture;
+use graph::{
+    components::link_resolver::{ArweaveResolver, FileSizeLimit},
+    data_source::offchain::Base64,
+    derive::CheapClone,
+    prelude::CheapClone,
+};
+use std::{sync::Arc, time::Duration};
+use tower::{ServiceBuilder, ServiceExt, buffer::Buffer};
+
+pub type ArweaveService = Buffer<Base64, BoxFuture<'static, Result<Option<Bytes>, Error>>>;
+
+pub fn arweave_service(
+    client: Arc<dyn ArweaveResolver>,
+    rate_limit: u16,
+    max_file_size: FileSizeLimit,
+) -> ArweaveService {
+    let arweave = ArweaveServiceInner {
+        client,
+        max_file_size,
+    };
+
+    let svc = ServiceBuilder::new()
+        .rate_limit(rate_limit.into(), Duration::from_secs(1))
+        .service_fn(move |req| arweave.cheap_clone().call_inner(req))
+        .boxed();
+
+    // The `Buffer` makes it so the rate limit is shared among clones.
+    // Make it unbounded to avoid any risk of starvation.
+    Buffer::new(svc, u32::MAX as usize)
+}
+
+#[derive(Clone, CheapClone)]
+struct ArweaveServiceInner {
+    client: Arc<dyn ArweaveResolver>,
+    max_file_size: FileSizeLimit,
+}
+
+impl ArweaveServiceInner {
+    async fn call_inner(self, req: Base64) -> Result<Option<Bytes>, Error> {
+        self.client
+            .get_with_limit(&req, &self.max_file_size)
+            .await
+            .map(Bytes::from)
+            .map(Some)
+            .map_err(Error::from)
+    }
+}
diff --git a/core/src/polling_monitor/ipfs_service.rs b/core/src/polling_monitor/ipfs_service.rs
index 284d25063db..6847bb82acd 100644
--- a/core/src/polling_monitor/ipfs_service.rs
+++ b/core/src/polling_monitor/ipfs_service.rs
@@ -1,97 +1,80 @@
-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<CidFile, BoxFuture<'static, Result<Option<Bytes>, Error>>>;
+pub type IpfsService = Buffer<IpfsRequest, 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,
-    concurrency_and_rate_limit: u16,
+    rate_limit: u16,
 ) -> IpfsService {
     let ipfs = IpfsServiceInner {
         client,
-        max_file_size,
         timeout,
+        max_file_size,
     };
 
     let svc = ServiceBuilder::new()
-        .rate_limit(concurrency_and_rate_limit.into(), Duration::from_secs(1))
-        .concurrency_limit(concurrency_and_rate_limit as usize)
+        .rate_limit(rate_limit.into(), Duration::from_secs(1))
         .service_fn(move |req| ipfs.cheap_clone().call_inner(req))
         .boxed();
 
-    // The `Buffer` makes it so the rate and concurrency limit are shared among clones.
-    Buffer::new(svc, 1)
+    // The `Buffer` makes it so the rate limit is shared among clones.
+    // Make it unbounded to avoid any risk of starvation.
+    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,42 +101,109 @@ 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::{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);
+    }
+
+    // Ignored because arweave.net is unreliable right now
+    #[graph::test]
+    #[ignore]
+    async fn arweave_get() {
+        const ID: &str = "8APeQ5lW0-csTcBaGdPBDLAL2ci2AT9pTn2tppGPU_8";
+
+        let Some(body) = ArweaveClient::get_test(&Word::from(ID)).await else {
+            return;
+        };
+        let body = String::from_utf8(body).unwrap();
+
+        let expected = r#"
+            {"name":"Arloader NFT #1","description":"Super dope, one of a kind NFT","collection":{"name":"Arloader NFT","family":"We AR"},"attributes":[{"trait_type":"cx","value":-0.4042198883730073},{"trait_type":"cy","value":0.5641681708263335},{"trait_type":"iters","value":44}],"properties":{"category":"image","files":[{"uri":"https://arweave.net/7gWCr96zc0QQCXOsn5Vk9ROVGFbMaA9-cYpzZI8ZMDs","type":"image/png"},{"uri":"https://arweave.net/URwQtoqrbYlc5183STNy3ZPwSCRY4o8goaF7MJay3xY/1.png","type":"image/png"}]},"image":"https://arweave.net/URwQtoqrbYlc5183STNy3ZPwSCRY4o8goaF7MJay3xY/1.png"}
+        "#.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/metrics.rs b/core/src/polling_monitor/metrics.rs
index 86d65790a7b..e296ddb8e00 100644
--- a/core/src/polling_monitor/metrics.rs
+++ b/core/src/polling_monitor/metrics.rs
@@ -5,6 +5,7 @@ use graph::{
     prometheus::{Counter, Gauge},
 };
 
+#[derive(Clone)]
 pub struct PollingMonitorMetrics {
     pub requests: Counter,
     pub errors: Counter,
@@ -13,7 +14,7 @@ pub struct PollingMonitorMetrics {
 }
 
 impl PollingMonitorMetrics {
-    pub fn new(registry: Arc<dyn MetricsRegistry>, subgraph_hash: &DeploymentHash) -> Self {
+    pub fn new(registry: Arc<MetricsRegistry>, subgraph_hash: &DeploymentHash) -> Self {
         let requests = registry
             .new_deployment_counter(
                 "polling_monitor_requests",
diff --git a/core/src/polling_monitor/mod.rs b/core/src/polling_monitor/mod.rs
index e50979d39f2..f8a24db97d7 100644
--- a/core/src/polling_monitor/mod.rs
+++ b/core/src/polling_monitor/mod.rs
@@ -1,5 +1,7 @@
+mod arweave_service;
 mod ipfs_service;
 mod metrics;
+mod request;
 
 use std::collections::HashMap;
 use std::fmt::Display;
@@ -8,27 +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 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>,
@@ -40,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(),
             )
@@ -49,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())
@@ -96,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::Sender<(ID, Res)>,
+    response_sender: mpsc::UnboundedSender<(Req, Res)>,
     logger: Logger,
-    metrics: PollingMonitorMetrics,
-) -> PollingMonitor<ID>
+    metrics: Arc<PollingMonitorMetrics>,
+) -> 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,
 {
@@ -124,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(),
@@ -149,38 +153,43 @@ where
             let mut backoffs = Backoffs::new();
             let mut responses = service.call_all(queue_to_stream).unordered().boxed();
             while let Some(response) = responses.next().await {
+                // Note: Be careful not to `await` within this loop, as that could block requests in
+                // 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)).await;
+                    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)) => {
+                    // 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();
                     }
                 }
             }
@@ -190,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);
     }
 }
 
@@ -210,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 {
@@ -228,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()
     }
 }
@@ -248,21 +268,26 @@ mod tests {
     fn setup() -> (
         mock::Handle<&'static str, Option<&'static str>>,
         PollingMonitor<&'static str>,
-        mpsc::Receiver<(&'static str, &'static str)>,
+        mpsc::UnboundedReceiver<(&'static str, &'static str)>,
     ) {
         let (svc, handle) = mock::pair();
-        let (tx, rx) = mpsc::channel(10);
-        let monitor = spawn_monitor(svc, tx, log::discard(), PollingMonitorMetrics::mock());
+        let (tx, rx) = mpsc::unbounded_channel();
+        let monitor = spawn_monitor(
+            svc,
+            tx,
+            log::discard(),
+            Arc::new(PollingMonitorMetrics::mock()),
+        );
         (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);
         let make_monitor = |svc| {
-            let (tx, rx) = mpsc::channel(10);
-            let metrics = PollingMonitorMetrics::mock();
+            let (tx, rx) = mpsc::unbounded_channel();
+            let metrics = Arc::new(PollingMonitorMetrics::mock());
             let monitor = spawn_monitor(svc, tx, log::discard(), metrics);
             (monitor, rx)
         };
@@ -278,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();
 
@@ -288,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();
 
@@ -305,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();
 
@@ -329,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);
@@ -338,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.rs b/core/src/subgraph/context.rs
deleted file mode 100644
index 121dfd637b5..00000000000
--- a/core/src/subgraph/context.rs
+++ /dev/null
@@ -1,236 +0,0 @@
-pub mod instance;
-
-use crate::polling_monitor::{spawn_monitor, IpfsService, PollingMonitor, PollingMonitorMetrics};
-use anyhow::{self, Error};
-use bytes::Bytes;
-use graph::{
-    blockchain::Blockchain,
-    components::{
-        store::{DeploymentId, SubgraphFork},
-        subgraph::{MappingError, SharedProofOfIndexing},
-    },
-    data_source::{offchain, CausalityRegion, DataSource, TriggerData},
-    ipfs_client::CidFile,
-    prelude::{
-        BlockNumber, BlockState, CancelGuard, CheapClone, DeploymentHash, MetricsRegistry,
-        RuntimeHostBuilder, SubgraphCountMetric, SubgraphInstanceMetrics, TriggerProcessor,
-    },
-    slog::Logger,
-    tokio::sync::mpsc,
-};
-use std::collections::HashMap;
-use std::sync::{Arc, RwLock};
-
-use self::instance::SubgraphInstance;
-
-#[derive(Clone, Debug)]
-pub struct SubgraphKeepAlive {
-    alive_map: Arc<RwLock<HashMap<DeploymentId, CancelGuard>>>,
-    manager_metrics: Arc<SubgraphCountMetric>,
-}
-
-impl CheapClone for SubgraphKeepAlive {
-    fn cheap_clone(&self) -> Self {
-        self.clone()
-    }
-}
-
-impl SubgraphKeepAlive {
-    pub fn new(metrics_registry: Arc<dyn MetricsRegistry>) -> Self {
-        Self {
-            manager_metrics: Arc::new(SubgraphCountMetric::new(metrics_registry)),
-            alive_map: Arc::new(RwLock::new(HashMap::default())),
-        }
-    }
-
-    pub fn remove(&self, deployment_id: &DeploymentId) {
-        self.alive_map.write().unwrap().remove(deployment_id);
-        self.manager_metrics.subgraph_count.dec();
-    }
-    pub fn insert(&self, deployment_id: DeploymentId, guard: CancelGuard) {
-        self.alive_map.write().unwrap().insert(deployment_id, guard);
-        self.manager_metrics.subgraph_count.inc();
-    }
-}
-
-// The context keeps track of mutable in-memory state that is retained across blocks.
-//
-// Currently most of the changes are applied in `runner.rs`, but ideally more of that would be
-// refactored into the context so it wouldn't need `pub` fields. The entity cache should probably
-// also be moved here.
-pub struct IndexingContext<C, T>
-where
-    T: RuntimeHostBuilder<C>,
-    C: Blockchain,
-{
-    instance: SubgraphInstance<C, T>,
-    pub instances: SubgraphKeepAlive,
-    pub filter: C::TriggerFilter,
-    pub offchain_monitor: OffchainMonitor,
-    trigger_processor: Box<dyn TriggerProcessor<C, T>>,
-}
-
-impl<C: Blockchain, T: RuntimeHostBuilder<C>> IndexingContext<C, T> {
-    pub fn new(
-        instance: SubgraphInstance<C, T>,
-        instances: SubgraphKeepAlive,
-        filter: C::TriggerFilter,
-        offchain_monitor: OffchainMonitor,
-        trigger_processor: Box<dyn TriggerProcessor<C, T>>,
-    ) -> Self {
-        Self {
-            instance,
-            instances,
-            filter,
-            offchain_monitor,
-            trigger_processor,
-        }
-    }
-
-    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>,
-    ) -> Result<BlockState<C>, MappingError> {
-        self.process_trigger_in_hosts(
-            logger,
-            self.instance.hosts(),
-            block,
-            trigger,
-            state,
-            proof_of_indexing,
-            causality_region,
-            debug_fork,
-            subgraph_metrics,
-        )
-        .await
-    }
-
-    pub async fn process_trigger_in_hosts(
-        &self,
-        logger: &Logger,
-        hosts: &[Arc<T::Host>],
-        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>,
-    ) -> Result<BlockState<C>, MappingError> {
-        self.trigger_processor
-            .process_trigger(
-                logger,
-                hosts,
-                block,
-                trigger,
-                state,
-                proof_of_indexing,
-                causality_region,
-                debug_fork,
-                subgraph_metrics,
-            )
-            .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`.
-    ///
-    /// This does not currently affect the `offchain_monitor` or the `filter`, so they will continue
-    /// to include data sources that have been reverted. This is not ideal for performance, but it
-    /// does not affect correctness since triggers that have no matching host will be ignored by
-    /// `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> {
-        let removed = self.instance.revert_data_sources(reverted_block);
-
-        removed
-            .into_iter()
-            .try_for_each(|source| self.offchain_monitor.add_source(source))
-    }
-
-    pub fn add_dynamic_data_source(
-        &mut self,
-        logger: &Logger,
-        data_source: DataSource<C>,
-    ) -> Result<Option<Arc<T::Host>>, Error> {
-        let source = data_source.as_offchain().map(|ds| ds.source.clone());
-        let host = self.instance.add_dynamic_data_source(logger, data_source)?;
-
-        if host.is_some() {
-            if let Some(source) = source {
-                self.offchain_monitor.add_source(source)?;
-            }
-        }
-
-        Ok(host)
-    }
-
-    pub fn causality_region_next_value(&mut self) -> CausalityRegion {
-        self.instance.causality_region_next_value()
-    }
-
-    #[cfg(debug_assertions)]
-    pub fn instance(&self) -> &SubgraphInstance<C, T> {
-        &self.instance
-    }
-}
-
-pub struct OffchainMonitor {
-    ipfs_monitor: PollingMonitor<CidFile>,
-    ipfs_monitor_rx: mpsc::Receiver<(CidFile, Bytes)>,
-}
-
-impl OffchainMonitor {
-    pub fn new(
-        logger: Logger,
-        registry: Arc<dyn MetricsRegistry>,
-        subgraph_hash: &DeploymentHash,
-        ipfs_service: IpfsService,
-    ) -> Self {
-        let (ipfs_monitor_tx, ipfs_monitor_rx) = mpsc::channel(10);
-        let ipfs_monitor = spawn_monitor(
-            ipfs_service,
-            ipfs_monitor_tx,
-            logger,
-            PollingMonitorMetrics::new(registry, subgraph_hash),
-        );
-        Self {
-            ipfs_monitor,
-            ipfs_monitor_rx,
-        }
-    }
-
-    fn add_source(&mut self, source: offchain::Source) -> Result<(), Error> {
-        match source {
-            offchain::Source::Ipfs(cid_file) => self.ipfs_monitor.monitor(cid_file),
-        };
-        Ok(())
-    }
-
-    pub fn ready_offchain_events(&mut self) -> Result<Vec<offchain::TriggerData>, Error> {
-        use graph::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),
-                    data: Arc::new(data),
-                }),
-                Err(TryRecvError::Disconnected) => {
-                    anyhow::bail!("ipfs monitor unexpectedly terminated")
-                }
-                Err(TryRecvError::Empty) => break,
-            }
-        }
-        Ok(triggers)
-    }
-}
diff --git a/core/src/subgraph/context/instance.rs b/core/src/subgraph/context/instance.rs
deleted file mode 100644
index d760dad1386..00000000000
--- a/core/src/subgraph/context/instance.rs
+++ /dev/null
@@ -1,214 +0,0 @@
-use futures01::sync::mpsc::Sender;
-use graph::{
-    blockchain::Blockchain,
-    data_source::{
-        causality_region::CausalityRegionSeq, offchain, CausalityRegion, DataSource,
-        DataSourceTemplate,
-    },
-    prelude::*,
-};
-use std::collections::HashMap;
-
-use super::OffchainMonitor;
-
-pub struct SubgraphInstance<C: Blockchain, T: RuntimeHostBuilder<C>> {
-    subgraph_id: DeploymentHash,
-    network: String,
-    host_builder: T,
-    templates: Arc<Vec<DataSourceTemplate<C>>>,
-    host_metrics: Arc<HostMetrics>,
-
-    /// Runtime hosts, one for each data source mapping.
-    ///
-    /// The runtime hosts are created and added in the same order the
-    /// data sources appear in the subgraph manifest. Incoming block
-    /// stream events are processed by the mappings in this same order.
-    hosts: Vec<Arc<T::Host>>,
-
-    /// Maps the hash of a module to a channel to the thread in which the module is instantiated.
-    module_cache: HashMap<[u8; 32], Sender<T::Req>>,
-
-    /// This manages the sequence of causality regions for the subgraph.
-    causality_region_seq: CausalityRegionSeq,
-}
-
-impl<T, C> SubgraphInstance<C, T>
-where
-    C: Blockchain,
-    T: RuntimeHostBuilder<C>,
-{
-    pub fn from_manifest(
-        logger: &Logger,
-        manifest: SubgraphManifest<C>,
-        host_builder: T,
-        host_metrics: Arc<HostMetrics>,
-        offchain_monitor: &mut OffchainMonitor,
-        causality_region_seq: CausalityRegionSeq,
-    ) -> Result<Self, Error> {
-        let subgraph_id = manifest.id.clone();
-        let network = manifest.network_name();
-        let templates = Arc::new(manifest.templates);
-
-        let mut this = SubgraphInstance {
-            host_builder,
-            subgraph_id,
-            network,
-            hosts: Vec::new(),
-            module_cache: HashMap::new(),
-            templates,
-            host_metrics,
-            causality_region_seq,
-        };
-
-        // Create a new runtime host for each data source in the subgraph manifest;
-        // we use the same order here as in the subgraph manifest to make the
-        // event processing behavior predictable
-        for ds in manifest.data_sources {
-            // TODO: This is duplicating code from `IndexingContext::add_dynamic_data_source` and
-            // `SubgraphInstance::add_dynamic_data_source`. Ideally this should be refactored into
-            // `IndexingContext`.
-
-            let runtime = ds.runtime();
-            let module_bytes = match runtime {
-                None => continue,
-                Some(ref module_bytes) => module_bytes,
-            };
-
-            if let DataSource::Offchain(ds) = &ds {
-                // monitor data source only if it's not processed.
-                if !ds.is_processed() {
-                    offchain_monitor.add_source(ds.source.clone())?;
-                }
-            }
-
-            let host = this.new_host(logger.cheap_clone(), ds, module_bytes)?;
-            this.hosts.push(Arc::new(host));
-        }
-
-        Ok(this)
-    }
-
-    // module_bytes is the same as data_source.runtime().unwrap(), this is to ensure that this
-    // function is only called for data_sources for which data_source.runtime().is_some() is true.
-    fn new_host(
-        &mut self,
-        logger: Logger,
-        data_source: DataSource<C>,
-        module_bytes: &Arc<Vec<u8>>,
-    ) -> Result<T::Host, Error> {
-        let mapping_request_sender = {
-            let module_hash = tiny_keccak::keccak256(module_bytes.as_ref());
-            if let Some(sender) = self.module_cache.get(&module_hash) {
-                sender.clone()
-            } else {
-                let sender = T::spawn_mapping(
-                    module_bytes.as_ref(),
-                    logger,
-                    self.subgraph_id.clone(),
-                    self.host_metrics.cheap_clone(),
-                )?;
-                self.module_cache.insert(module_hash, sender.clone());
-                sender
-            }
-        };
-        self.host_builder.build(
-            self.network.clone(),
-            self.subgraph_id.clone(),
-            data_source,
-            self.templates.cheap_clone(),
-            mapping_request_sender,
-            self.host_metrics.cheap_clone(),
-        )
-    }
-
-    pub(super) fn add_dynamic_data_source(
-        &mut self,
-        logger: &Logger,
-        data_source: DataSource<C>,
-    ) -> Result<Option<Arc<T::Host>>, Error> {
-        // Protect against creating more than the allowed maximum number of data sources
-        if self.hosts.len() >= ENV_VARS.subgraph_max_data_sources {
-            anyhow::bail!(
-                "Limit of {} data sources per subgraph exceeded",
-                ENV_VARS.subgraph_max_data_sources,
-            );
-        }
-
-        // `hosts` will remain ordered by the creation block.
-        // See also 8f1bca33-d3b7-4035-affc-fd6161a12448.
-        assert!(
-            self.hosts.last().and_then(|h| h.creation_block_number())
-                <= data_source.creation_block()
-        );
-
-        let module_bytes = match &data_source.runtime() {
-            None => return Ok(None),
-            Some(ref module_bytes) => module_bytes.cheap_clone(),
-        };
-
-        let host = Arc::new(self.new_host(logger.clone(), data_source, &module_bytes)?);
-
-        Ok(if self.hosts.contains(&host) {
-            None
-        } else {
-            self.hosts.push(host.clone());
-            Some(host)
-        })
-    }
-
-    /// Reverts any DataSources that have been added from the block forwards (inclusively)
-    /// This function also reverts the done_at status if it was 'done' on this block or later.
-    /// It only returns the offchain::Source because we don't currently need to know which
-    /// DataSources were removed, the source is used so that the offchain DDS can be found again.
-    pub(super) fn revert_data_sources(
-        &mut self,
-        reverted_block: BlockNumber,
-    ) -> Vec<offchain::Source> {
-        self.revert_hosts_cheap(reverted_block);
-
-        // The following code handles resetting offchain datasources so in most
-        // cases this is enough processing.
-        // At some point we prolly need to improve the linear search but for now this
-        // should be fine. *IT'S FINE*
-        //
-        // Any File DataSources (Dynamic Data Sources), will have their own causality region
-        // which currently is the next number of the sequence but that should be an internal detail.
-        // Regardless of the sequence logic, if the current causality region is ONCHAIN then there are
-        // no others and therefore the remaining code is a noop and we can just stop here.
-        if self.causality_region_seq.0 == CausalityRegion::ONCHAIN {
-            return vec![];
-        }
-
-        self.hosts
-            .iter()
-            .filter(|host| matches!(host.done_at(), Some(done_at) if done_at >= reverted_block))
-            .map(|host| {
-                host.set_done_at(None);
-                // Safe to call unwrap() because only offchain DataSources have done_at = Some
-                host.data_source().as_offchain().unwrap().source.clone()
-            })
-            .collect()
-    }
-
-    /// Because hosts are ordered, removing them based on creation block is cheap and simple.
-    fn revert_hosts_cheap(&mut self, reverted_block: BlockNumber) {
-        // `hosts` is ordered by the creation block.
-        // See also 8f1bca33-d3b7-4035-affc-fd6161a12448.
-        while self
-            .hosts
-            .last()
-            .filter(|h| h.creation_block_number() >= Some(reverted_block))
-            .is_some()
-        {
-            self.hosts.pop();
-        }
-    }
-
-    pub fn hosts(&self) -> &[Arc<T::Host>] {
-        &self.hosts
-    }
-
-    pub(super) fn causality_region_next_value(&mut self) -> CausalityRegion {
-        self.causality_region_seq.next_val()
-    }
-}
diff --git a/core/src/subgraph/context/instance/hosts.rs b/core/src/subgraph/context/instance/hosts.rs
new file mode 100644
index 00000000000..9c18e12ce1e
--- /dev/null
+++ b/core/src/subgraph/context/instance/hosts.rs
@@ -0,0 +1,211 @@
+use std::{
+    collections::{BTreeMap, HashMap},
+    sync::Arc,
+};
+
+use graph::{
+    blockchain::Blockchain,
+    cheap_clone::CheapClone,
+    components::{
+        store::BlockNumber,
+        subgraph::{RuntimeHost, RuntimeHostBuilder},
+    },
+};
+
+/// This structure maintains a partition of the hosts by address, for faster trigger matching. This
+/// partition uses the host's index in the main vec, to maintain the correct ordering.
+pub(super) struct OnchainHosts<C: Blockchain, T: RuntimeHostBuilder<C>> {
+    hosts: Vec<Arc<T::Host>>,
+
+    // The `usize` is the index of the host in `hosts`.
+    hosts_by_address: HashMap<Box<[u8]>, Vec<usize>>,
+    hosts_without_address: Vec<usize>,
+}
+
+impl<C: Blockchain, T: RuntimeHostBuilder<C>> OnchainHosts<C, T> {
+    pub fn new() -> Self {
+        Self {
+            hosts: Vec::new(),
+            hosts_by_address: HashMap::new(),
+            hosts_without_address: Vec::new(),
+        }
+    }
+
+    pub fn hosts(&self) -> &[Arc<T::Host>] {
+        &self.hosts
+    }
+
+    pub fn contains(&self, other: &Arc<T::Host>) -> bool {
+        // Narrow down the host list by address, as an optimization.
+        let hosts = match other.data_source().address() {
+            Some(address) => self.hosts_by_address.get(address.as_slice()),
+            None => Some(&self.hosts_without_address),
+        };
+
+        hosts
+            .into_iter()
+            .flatten()
+            .any(|idx| &self.hosts[*idx] == other)
+    }
+
+    pub fn last(&self) -> Option<&Arc<T::Host>> {
+        self.hosts.last()
+    }
+
+    pub fn len(&self) -> usize {
+        self.hosts.len()
+    }
+
+    pub fn push(&mut self, host: Arc<T::Host>) {
+        assert!(host.data_source().is_chain_based());
+
+        self.hosts.push(host.cheap_clone());
+        let idx = self.hosts.len() - 1;
+        let address = host.data_source().address();
+        match address {
+            Some(address) => {
+                self.hosts_by_address
+                    .entry(address.into())
+                    .or_default()
+                    .push(idx);
+            }
+            None => {
+                self.hosts_without_address.push(idx);
+            }
+        }
+    }
+
+    pub fn pop(&mut self) {
+        let Some(host) = self.hosts.pop() else { return };
+        let address = host.data_source().address();
+        match address {
+            Some(address) => {
+                // Unwrap and assert: The same host we just popped must be the last one in `hosts_by_address`.
+                let hosts = self.hosts_by_address.get_mut(address.as_slice()).unwrap();
+                let idx = hosts.pop().unwrap();
+                assert_eq!(idx, self.hosts.len());
+            }
+            None => {
+                // Unwrap and assert: The same host we just popped must be the last one in `hosts_without_address`.
+                let idx = self.hosts_without_address.pop().unwrap();
+                assert_eq!(idx, self.hosts.len());
+            }
+        }
+    }
+
+    /// Returns an iterator over all hosts that match the given address, in the order they were inserted in `hosts`.
+    /// Note that this always includes the hosts without an address, since they match all addresses.
+    /// If no address is provided, returns an iterator over all hosts.
+    pub fn matches_by_address(
+        &self,
+        address: Option<&[u8]>,
+    ) -> Box<dyn Iterator<Item = &T::Host> + Send + '_> {
+        let Some(address) = address else {
+            return Box::new(self.hosts.iter().map(|host| host.as_ref()));
+        };
+
+        let mut matching_hosts: Vec<usize> = self
+            .hosts_by_address
+            .get(address)
+            .into_iter()
+            .flatten() // Flatten non-existing `address` into empty.
+            .copied()
+            .chain(self.hosts_without_address.iter().copied())
+            .collect();
+        matching_hosts.sort();
+        Box::new(
+            matching_hosts
+                .into_iter()
+                .map(move |idx| self.hosts[idx].as_ref()),
+        )
+    }
+}
+
+/// Note that unlike `OnchainHosts`, this does not maintain the order of insertion. Ultimately, the
+/// processing order should not matter because each offchain ds has its own causality region.
+pub(super) struct OffchainHosts<C: Blockchain, T: RuntimeHostBuilder<C>> {
+    // Indexed by creation block
+    by_block: BTreeMap<Option<BlockNumber>, Vec<Arc<T::Host>>>,
+    // Indexed by `offchain::Source::address`
+    by_address: BTreeMap<Vec<u8>, Vec<Arc<T::Host>>>,
+    wildcard_address: Vec<Arc<T::Host>>,
+}
+
+impl<C: Blockchain, T: RuntimeHostBuilder<C>> OffchainHosts<C, T> {
+    pub fn new() -> Self {
+        Self {
+            by_block: BTreeMap::new(),
+            by_address: BTreeMap::new(),
+            wildcard_address: Vec::new(),
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.by_block.values().map(Vec::len).sum()
+    }
+
+    pub fn all(&self) -> impl Iterator<Item = &Arc<T::Host>> + Send + '_ {
+        self.by_block.values().flatten()
+    }
+
+    pub fn contains(&self, other: &Arc<T::Host>) -> bool {
+        // Narrow down the host list by address, as an optimization.
+        let hosts = match other.data_source().address() {
+            Some(address) => self.by_address.get(address.as_slice()),
+            None => Some(&self.wildcard_address),
+        };
+
+        hosts.into_iter().flatten().any(|host| host == other)
+    }
+
+    pub fn push(&mut self, host: Arc<T::Host>) {
+        assert!(host.data_source().as_offchain().is_some());
+
+        let block = host.creation_block_number();
+        self.by_block
+            .entry(block)
+            .or_default()
+            .push(host.cheap_clone());
+
+        match host.data_source().address() {
+            Some(address) => self.by_address.entry(address).or_default().push(host),
+            None => self.wildcard_address.push(host),
+        }
+    }
+
+    /// Removes all entries with block number >= block.
+    pub fn remove_ge_block(&mut self, block: BlockNumber) {
+        let removed = self.by_block.split_off(&Some(block));
+        for (_, hosts) in removed {
+            for host in hosts {
+                match host.data_source().address() {
+                    Some(address) => {
+                        let hosts = self.by_address.get_mut(&address).unwrap();
+                        hosts.retain(|h| !Arc::ptr_eq(h, &host));
+                    }
+                    None => {
+                        self.wildcard_address.retain(|h| !Arc::ptr_eq(h, &host));
+                    }
+                }
+            }
+        }
+    }
+
+    pub fn matches_by_address<'a>(
+        &'a self,
+        address: Option<&[u8]>,
+    ) -> 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()));
+        };
+
+        Box::new(
+            self.by_address
+                .get(address)
+                .into_iter()
+                .flatten() // Flatten non-existing `address` into empty.
+                .map(|host| host.as_ref())
+                .chain(self.wildcard_address.iter().map(|host| host.as_ref())),
+        )
+    }
+}
diff --git a/core/src/subgraph/context/instance/mod.rs b/core/src/subgraph/context/instance/mod.rs
new file mode 100644
index 00000000000..494ae227e97
--- /dev/null
+++ b/core/src/subgraph/context/instance/mod.rs
@@ -0,0 +1,258 @@
+mod hosts;
+
+use anyhow::ensure;
+use graph::futures01::sync::mpsc::Sender;
+use graph::{
+    blockchain::{Blockchain, TriggerData as _},
+    data_source::{
+        CausalityRegion, DataSource, DataSourceTemplate, TriggerData,
+        causality_region::CausalityRegionSeq, offchain,
+    },
+    prelude::*,
+};
+use hosts::{OffchainHosts, OnchainHosts};
+use std::collections::HashMap;
+
+pub(crate) struct SubgraphInstance<C: Blockchain, T: RuntimeHostBuilder<C>> {
+    subgraph_id: DeploymentHash,
+    network: String,
+    host_builder: T,
+    pub templates: Arc<Vec<DataSourceTemplate<C>>>,
+    /// The data sources declared in the subgraph manifest. This does not include dynamic data sources.
+    pub(super) static_data_sources: Arc<Vec<DataSource<C>>>,
+    host_metrics: Arc<HostMetrics>,
+
+    /// 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.
+    module_cache: HashMap<[u8; 32], Sender<T::Req>>,
+
+    /// This manages the sequence of causality regions for the subgraph.
+    causality_region_seq: CausalityRegionSeq,
+}
+
+impl<T, C> SubgraphInstance<C, T>
+where
+    C: Blockchain,
+    T: RuntimeHostBuilder<C>,
+{
+    /// All onchain data sources that are part of this subgraph. This includes data sources
+    /// that are included in the subgraph manifest and dynamic data sources.
+    pub fn onchain_data_sources(&self) -> impl Iterator<Item = &C::DataSource> + Clone {
+        let host_data_sources = self
+            .onchain_hosts
+            .hosts()
+            .iter()
+            .map(|h| h.data_source().as_onchain().unwrap());
+
+        // Datasources that are defined in the subgraph manifest but does not correspond to any host
+        // in the subgraph. Currently these are only substreams data sources.
+        let substreams_data_sources = self
+            .static_data_sources
+            .iter()
+            .filter(|ds| ds.runtime().is_none())
+            .filter_map(|ds| ds.as_onchain());
+
+        host_data_sources.chain(substreams_data_sources)
+    }
+
+    pub fn new(
+        manifest: SubgraphManifest<C>,
+        host_builder: T,
+        host_metrics: Arc<HostMetrics>,
+        causality_region_seq: CausalityRegionSeq,
+    ) -> Self {
+        let subgraph_id = manifest.id.clone();
+        let network = manifest.network_name();
+        let templates = Arc::new(manifest.templates);
+
+        SubgraphInstance {
+            host_builder,
+            subgraph_id,
+            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,
+            host_metrics,
+            causality_region_seq,
+        }
+    }
+
+    // If `data_source.runtime()` is `None`, returns `Ok(None)`.
+    fn new_host(
+        &mut self,
+        logger: Logger,
+        data_source: DataSource<C>,
+    ) -> Result<Option<Arc<T::Host>>, Error> {
+        let module_bytes = match &data_source.runtime() {
+            None => return Ok(None),
+            Some(module_bytes) => module_bytes.cheap_clone(),
+        };
+
+        let mapping_request_sender = {
+            let module_hash = alloy::primitives::keccak256(module_bytes.as_ref()).0;
+            if let Some(sender) = self.module_cache.get(&module_hash) {
+                sender.clone()
+            } else {
+                let sender = T::spawn_mapping(
+                    module_bytes.as_ref(),
+                    logger,
+                    self.subgraph_id.clone(),
+                    self.host_metrics.cheap_clone(),
+                )?;
+                self.module_cache.insert(module_hash, sender.clone());
+                sender
+            }
+        };
+
+        let host = self.host_builder.build(
+            self.network.clone(),
+            self.subgraph_id.clone(),
+            data_source,
+            self.templates.cheap_clone(),
+            mapping_request_sender,
+            self.host_metrics.cheap_clone(),
+        )?;
+        Ok(Some(Arc::new(host)))
+    }
+
+    pub(super) fn add_dynamic_data_source(
+        &mut self,
+        logger: &Logger,
+        data_source: DataSource<C>,
+    ) -> Result<Option<Arc<T::Host>>, Error> {
+        // Protect against creating more than the allowed maximum number of data sources
+        if self.hosts_len() >= ENV_VARS.subgraph_max_data_sources {
+            anyhow::bail!(
+                "Limit of {} data sources per subgraph exceeded",
+                ENV_VARS.subgraph_max_data_sources,
+            );
+        }
+
+        let Some(host) = self.new_host(logger.clone(), data_source)? else {
+            return Ok(None);
+        };
+
+        // Check for duplicates and add the host.
+        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))
+                }
+            }
+            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!(),
+        }
+    }
+
+    /// Reverts any DataSources that have been added from the block forwards (inclusively)
+    /// This function also reverts the done_at status if it was 'done' on this block or later.
+    /// It only returns the offchain::Source because we don't currently need to know which
+    /// DataSources were removed, the source is used so that the offchain DDS can be found again.
+    pub(super) fn revert_data_sources(
+        &mut self,
+        reverted_block: BlockNumber,
+    ) -> Vec<offchain::Source> {
+        self.revert_onchain_hosts(reverted_block);
+        self.offchain_hosts.remove_ge_block(reverted_block);
+
+        // Any File DataSources (Dynamic Data Sources), will have their own causality region
+        // which currently is the next number of the sequence but that should be an internal detail.
+        // Regardless of the sequence logic, if the current causality region is ONCHAIN then there are
+        // no others and therefore the remaining code is a noop and we can just stop here.
+        if self.causality_region_seq.0 == CausalityRegion::ONCHAIN {
+            return vec![];
+        }
+
+        self.offchain_hosts
+            .all()
+            .filter(|host| matches!(host.done_at(), Some(done_at) if done_at >= reverted_block))
+            .map(|host| {
+                host.set_done_at(None);
+                host.data_source().as_offchain().unwrap().source.clone()
+            })
+            .collect()
+    }
+
+    /// Because onchain hosts are ordered, removing them based on creation block is cheap and simple.
+    fn revert_onchain_hosts(&mut self, reverted_block: BlockNumber) {
+        // `onchain_hosts` is ordered by the creation block.
+        // See also 8f1bca33-d3b7-4035-affc-fd6161a12448.
+        while self
+            .onchain_hosts
+            .last()
+            .filter(|h| h.creation_block_number() >= Some(reverted_block))
+            .is_some()
+        {
+            self.onchain_hosts.pop();
+        }
+    }
+
+    /// Returns all hosts which match the trigger's address.
+    /// This is a performance optimization to reduce the number of calls to `match_and_decode`.
+    pub fn hosts_for_trigger(
+        &self,
+        trigger: &TriggerData<C>,
+    ) -> Box<dyn Iterator<Item = &T::Host> + Send + '_> {
+        match trigger {
+            TriggerData::Onchain(trigger) => self
+                .onchain_hosts
+                .matches_by_address(trigger.address_match()),
+            TriggerData::Offchain(trigger) => self
+                .offchain_hosts
+                .matches_by_address(trigger.source.address().as_deref()),
+            TriggerData::Subgraph(trigger) => self
+                .subgraph_hosts
+                .matches_by_address(Some(trigger.source.to_bytes().as_slice())),
+        }
+    }
+
+    pub(super) fn causality_region_next_value(&mut self) -> CausalityRegion {
+        self.causality_region_seq.next_val()
+    }
+
+    pub fn hosts_len(&self) -> usize {
+        self.onchain_hosts.len() + self.offchain_hosts.len()
+    }
+}
diff --git a/core/src/subgraph/context/mod.rs b/core/src/subgraph/context/mod.rs
new file mode 100644
index 00000000000..affbc09aa0f
--- /dev/null
+++ b/core/src/subgraph/context/mod.rs
@@ -0,0 +1,257 @@
+mod instance;
+
+use crate::polling_monitor::{
+    ArweaveService, IpfsRequest, IpfsService, PollingMonitor, PollingMonitorMetrics, spawn_monitor,
+};
+use anyhow::{self, Error};
+use bytes::Bytes;
+use graph::{
+    blockchain::Blockchain,
+    components::{store::DeploymentId, subgraph::HostMetrics},
+    data::subgraph::SubgraphManifest,
+    data_source::{
+        CausalityRegion, DataSource, DataSourceTemplate,
+        causality_region::CausalityRegionSeq,
+        offchain::{self, Base64},
+    },
+    derive::CheapClone,
+    ipfs::IpfsContext,
+    prelude::{
+        BlockNumber, CancelGuard, CheapClone, DeploymentHash, MetricsRegistry, RuntimeHostBuilder,
+        SubgraphCountMetric, TriggerProcessor,
+    },
+    slog::Logger,
+};
+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, CheapClone, Debug)]
+pub struct SubgraphKeepAlive {
+    alive_map: Arc<RwLock<HashMap<DeploymentId, CancelGuard>>>,
+    sg_metrics: Arc<SubgraphCountMetric>,
+}
+
+impl SubgraphKeepAlive {
+    pub fn new(sg_metrics: Arc<SubgraphCountMetric>) -> Self {
+        Self {
+            sg_metrics,
+            alive_map: Arc::new(RwLock::new(HashMap::default())),
+        }
+    }
+
+    pub fn remove(&self, deployment_id: &DeploymentId) {
+        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().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.
+//
+// Currently most of the changes are applied in `runner.rs`, but ideally more of that would be
+// refactored into the context so it wouldn't need `pub` fields. The entity cache should probably
+// also be moved here.
+pub struct IndexingContext<C, T>
+where
+    T: RuntimeHostBuilder<C>,
+    C: Blockchain,
+{
+    pub(crate) instance: SubgraphInstance<C, T>,
+    pub instances: SubgraphKeepAlive,
+    pub offchain_monitor: OffchainMonitor,
+    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> {
+    pub fn new(
+        manifest: SubgraphManifest<C>,
+        host_builder: T,
+        host_metrics: Arc<HostMetrics>,
+        causality_region_seq: CausalityRegionSeq,
+        instances: SubgraphKeepAlive,
+        offchain_monitor: OffchainMonitor,
+        trigger_processor: Box<dyn TriggerProcessor<C, T>>,
+        decoder: Box<Decoder<C, T>>,
+    ) -> Self {
+        let instance = SubgraphInstance::new(
+            manifest,
+            host_builder,
+            host_metrics.clone(),
+            causality_region_seq,
+        );
+
+        Self {
+            instance,
+            instances,
+            offchain_monitor,
+            trigger_processor,
+            decoder,
+        }
+    }
+
+    /// Removes data sources hosts with a creation block greater or equal to `reverted_block`, so
+    /// that they are no longer candidates for `process_trigger`.
+    ///
+    /// This does not currently affect the `offchain_monitor` or the `filter`, so they will continue
+    /// to include data sources that have been reverted. This is not ideal for performance, but it
+    /// does not affect correctness since triggers that have no matching host will be ignored by
+    /// `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) {
+        let removed = self.instance.revert_data_sources(reverted_block);
+
+        removed
+            .into_iter()
+            .for_each(|source| self.offchain_monitor.add_source(source))
+    }
+
+    pub fn add_dynamic_data_source(
+        &mut self,
+        logger: &Logger,
+        data_source: DataSource<C>,
+    ) -> Result<Option<Arc<T::Host>>, Error> {
+        let offchain_fields = data_source
+            .as_offchain()
+            .map(|ds| (ds.source.clone(), ds.is_processed()));
+        let host = self.instance.add_dynamic_data_source(logger, data_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);
+            }
+        }
+
+        Ok(host)
+    }
+
+    pub fn causality_region_next_value(&mut self) -> CausalityRegion {
+        self.instance.causality_region_next_value()
+    }
+
+    pub fn hosts_len(&self) -> usize {
+        self.instance.hosts_len()
+    }
+
+    pub fn onchain_data_sources(&self) -> impl Iterator<Item = &C::DataSource> + Clone {
+        self.instance.onchain_data_sources()
+    }
+
+    pub fn static_data_sources(&self) -> &[DataSource<C>] {
+        &self.instance.static_data_sources
+    }
+
+    pub fn templates(&self) -> &[DataSourceTemplate<C>] {
+        &self.instance.templates
+    }
+}
+
+pub struct OffchainMonitor {
+    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 {
+    pub fn new(
+        logger: Logger,
+        registry: Arc<MetricsRegistry>,
+        subgraph_hash: &DeploymentHash,
+        ipfs_service: IpfsService,
+        arweave_service: ArweaveService,
+    ) -> Self {
+        let metrics = Arc::new(PollingMonitorMetrics::new(registry, subgraph_hash));
+        // The channel is unbounded, as it is expected that `fn ready_offchain_events` is called
+        // frequently, or at least with the same frequency that requests are sent.
+        let (ipfs_monitor_tx, ipfs_monitor_rx) = mpsc::unbounded_channel();
+        let (arweave_monitor_tx, arweave_monitor_rx) = mpsc::unbounded_channel();
+
+        let ipfs_monitor = spawn_monitor(
+            ipfs_service,
+            ipfs_monitor_tx,
+            logger.cheap_clone(),
+            metrics.cheap_clone(),
+        );
+
+        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) {
+        match source {
+            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),
+        };
+    }
+
+    pub fn ready_offchain_events(&mut self) -> Result<Vec<offchain::TriggerData>, Error> {
+        use tokio::sync::mpsc::error::TryRecvError;
+
+        let mut triggers = vec![];
+        loop {
+            match self.ipfs_monitor_rx.try_recv() {
+                Ok((req, data)) => triggers.push(offchain::TriggerData {
+                    source: offchain::Source::Ipfs(req.path),
+                    data: Arc::new(data),
+                }),
+                Err(TryRecvError::Disconnected) => {
+                    anyhow::bail!("ipfs monitor unexpectedly terminated")
+                }
+                Err(TryRecvError::Empty) => break,
+            }
+        }
+
+        loop {
+            match self.arweave_monitor_rx.try_recv() {
+                Ok((base64, data)) => triggers.push(offchain::TriggerData {
+                    source: offchain::Source::Arweave(base64),
+                    data: Arc::new(data),
+                }),
+                Err(TryRecvError::Disconnected) => {
+                    anyhow::bail!("arweave monitor unexpectedly terminated")
+                }
+                Err(TryRecvError::Empty) => break,
+            }
+        }
+
+        Ok(triggers)
+    }
+}
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 191dc69cbf4..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},
@@ -15,10 +15,13 @@ pub struct IndexingInputs<C: Blockchain> {
     pub deployment: DeploymentLocator,
     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,
@@ -26,6 +29,58 @@ pub struct IndexingInputs<C: Blockchain> {
     pub poi_version: ProofOfIndexingVersion,
     pub network: String,
 
-    // Correspondence between data source or template position in the manifest and name.
-    pub manifest_idx_and_name: Vec<(u32, String)>,
+    /// Whether to instrument trigger processing and log additional,
+    /// possibly expensive and noisy, information
+    pub instrument: bool,
+}
+
+impl<C: Blockchain> IndexingInputs<C> {
+    pub fn with_store(&self, store: Arc<dyn WritableStore>) -> Self {
+        let IndexingInputs {
+            deployment,
+            features,
+            start_blocks,
+            end_blocks,
+            source_subgraph_stores,
+            stop_block,
+            max_end_block,
+            store: _,
+            debug_fork,
+            triggers_adapter,
+            chain,
+            templates,
+            unified_api_version,
+            static_filters,
+            poi_version,
+            network,
+            instrument,
+        } = self;
+        IndexingInputs {
+            deployment: deployment.clone(),
+            features: features.clone(),
+            start_blocks: start_blocks.clone(),
+            end_blocks: end_blocks.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(),
+            chain: chain.clone(),
+            templates: templates.clone(),
+            unified_api_version: unified_api_version.clone(),
+            static_filters: *static_filters,
+            poi_version: *poi_version,
+            network: network.clone(),
+            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 16913b37161..ea301ffc723 100644
--- a/core/src/subgraph/instance_manager.rs
+++ b/core/src/subgraph/instance_manager.rs
@@ -1,122 +1,127 @@
-use crate::polling_monitor::IpfsService;
+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 graph::blockchain::Blockchain;
-use graph::blockchain::NodeCapabilities;
-use graph::blockchain::{BlockchainKind, TriggerFilter};
+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>,
-    metrics_registry: Arc<dyn MetricsRegistry>,
+    metrics_registry: Arc<MetricsRegistry>,
     instances: SubgraphKeepAlive,
     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
+        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
+                    }
                 }
             }
         };
@@ -129,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
+                    );
+                }
             }
         });
     }
@@ -155,15 +164,18 @@ 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>,
         subgraph_store: Arc<S>,
         chains: Arc<BlockchainMap>,
-        metrics_registry: Arc<dyn MetricsRegistry>,
+        sg_metrics: Arc<SubgraphCountMetric>,
+        metrics_registry: Arc<MetricsRegistry>,
         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);
@@ -174,22 +186,79 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
             subgraph_store,
             chains,
             metrics_registry: metrics_registry.cheap_clone(),
-            instances: SubgraphKeepAlive::new(metrics_registry),
+            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,
@@ -198,45 +267,79 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         let subgraph_store = self.subgraph_store.cheap_clone();
         let registry = self.metrics_registry.cheap_clone();
 
-        let store = self
-            .subgraph_store
-            .cheap_clone()
-            .writable(logger.clone(), deployment.id)
-            .await?;
-
-        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");
+        info!(logger, "Resolve subgraph files using IPFS";
+            "n_data_sources" => manifest.data_sources.len(),
+            "n_templates" => manifest.templates.len(),
+        );
 
-        let mut manifest = manifest
-            .resolve(&link_resolver, &logger, ENV_VARS.max_spec_version.clone())
+        let manifest = manifest
+            .resolve(
+                &deployment.hash,
+                &link_resolver,
+                self.amp_client.cheap_clone(),
+                &logger,
+                ENV_VARS.max_spec_version.clone(),
+            )
             .await?;
 
-        info!(logger, "Successfully resolved subgraph files using IPFS");
+        {
+            let features = if manifest.features.is_empty() {
+                "ø".to_string()
+            } else {
+                manifest
+                    .features
+                    .iter()
+                    .map(|f| f.to_string())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            };
+            info!(logger, "Successfully resolved subgraph files using IPFS";
+                "n_data_sources" => manifest.data_sources.len(),
+                "n_templates" => manifest.templates.len(),
+                "features" => features
+            );
+        }
 
-        let manifest_idx_and_name: Vec<(u32, String)> = manifest.template_idx_and_name().collect();
+        let store = self
+            .subgraph_store
+            .cheap_clone()
+            .writable(
+                logger.clone(),
+                deployment.id,
+                Arc::new(manifest.template_idx_and_name().collect()),
+            )
+            .await?;
+
+        // Create deployment features from the manifest
+        // Write it to the database
+        let deployment_features = manifest.deployment_features();
+        self.subgraph_store
+            .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
@@ -244,38 +347,34 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         // that is done
         store.start_subgraph_deployment(&logger).await?;
 
-        // Dynamic data sources are loaded by appending them to the manifest.
-        //
-        // Refactor: Preferrably we'd avoid any mutation of the manifest.
-        let (manifest, static_data_sources) = {
-            let data_sources = load_dynamic_data_sources(store.clone(), logger.clone(), &manifest)
+        let dynamic_data_sources =
+            load_dynamic_data_sources(store.clone(), logger.clone(), &manifest)
                 .await
                 .context("Failed to load dynamic data sources")?;
 
-            let static_data_sources = manifest.data_sources.clone();
-
-            // Add dynamic data sources to the subgraph
-            manifest.data_sources.extend(data_sources);
+        // Combine the data sources from the manifest with the dynamic data sources
+        let mut data_sources = manifest.data_sources.clone();
+        data_sources.extend(dynamic_data_sources);
 
-            info!(
-                logger,
-                "Data source count at start: {}",
-                manifest.data_sources.len()
-            );
+        info!(logger, "Data source count at start: {}", data_sources.len());
 
-            (manifest, static_data_sources)
-        };
+        let onchain_data_sources = data_sources
+            .iter()
+            .filter_map(|d| d.as_onchain().cloned())
+            .collect::<Vec<_>>();
 
-        let static_filters =
-            self.static_filters || manifest.data_sources.len() >= ENV_VARS.static_filters_threshold;
+        let subgraph_data_sources = data_sources
+            .iter()
+            .filter_map(|d| d.as_subgraph())
+            .collect::<Vec<_>>();
 
-        let onchain_data_sources = manifest
-            .data_sources
+        let subgraph_ds_source_deployments = subgraph_data_sources
             .iter()
-            .filter_map(|d| d.as_onchain().cloned())
+            .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
@@ -283,40 +382,44 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
             .with_context(|| format!("no chain configured for network {}", network))?
             .clone();
 
-        // if static_filters is enabled, build a minimal filter with the static data sources and
-        // add the necessary filters based on templates.
-        // if not enabled we just stick to the filter based on all the data sources.
-        // 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.
-        let filter = if static_filters {
-            if !self.static_filters {
-                info!(logger, "forcing subgraph to use static filters.")
-            }
-
-            let onchain_data_sources = static_data_sources.iter().filter_map(|d| d.as_onchain());
-
-            let mut filter = C::TriggerFilter::from_data_sources(onchain_data_sources);
+        let start_blocks: Vec<BlockNumber> = data_sources
+            .iter()
+            .filter_map(|d| d.start_block())
+            .collect();
 
-            filter.extend_with_template(
-                manifest
-                    .templates
-                    .iter()
-                    .filter_map(|ds| ds.as_onchain())
-                    .cloned(),
-            );
-            filter
+        let end_blocks: BTreeSet<BlockNumber> = manifest
+            .data_sources
+            .iter()
+            .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 {
-            C::TriggerFilter::from_data_sources(onchain_data_sources.iter())
+            None
         };
 
-        let start_blocks = manifest.start_blocks();
-
         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
@@ -325,8 +428,11 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
             deployment.hash.clone(),
             "process",
             self.metrics_registry.clone(),
+            store.shard().to_string(),
         );
 
+        let gas_metrics = GasMetrics::new(deployment.hash.clone(), self.metrics_registry.clone());
+
         let unified_mapping_api_version = manifest.unified_mapping_api_version()?;
         let triggers_adapter = chain.triggers_adapter(&deployment, &required_capabilities, unified_mapping_api_version).map_err(|e|
                 anyhow!(
@@ -338,12 +444,14 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
             registry.cheap_clone(),
             deployment.hash.as_str(),
             stopwatch_metrics.clone(),
+            gas_metrics.clone(),
         ));
 
         let subgraph_metrics = Arc::new(SubgraphInstanceMetrics::new(
             registry.cheap_clone(),
             deployment.hash.as_str(),
             stopwatch_metrics.clone(),
+            deployment_status_metric,
         ));
 
         let block_stream_metrics = Arc::new(BlockStreamMetrics::new(
@@ -354,11 +462,12 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
             stopwatch_metrics,
         ));
 
-        let mut offchain_monitor = OffchainMonitor::new(
+        let offchain_monitor = OffchainMonitor::new(
             logger.cheap_clone(),
             registry.cheap_clone(),
             &manifest.id,
             self.ipfs_service.clone(),
+            self.arweave_service.clone(),
         );
 
         // Initialize deployment_head with current deployment head. Any sort of trouble in
@@ -366,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(),
         );
@@ -383,40 +493,58 @@ impl<S: SubgraphStore> SubgraphInstanceManager<S> {
         let causality_region_seq =
             CausalityRegionSeq::from_current(store.causality_region_curr_val().await?);
 
-        let instance = super::context::instance::SubgraphInstance::from_manifest(
-            &logger,
-            manifest,
-            host_builder,
-            host_metrics.clone(),
-            &mut offchain_monitor,
-            causality_region_seq,
-        )?;
+        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,
             chain,
             templates,
             unified_api_version,
-            static_filters,
-            manifest_idx_and_name,
+            static_filters: self.static_filters,
             poi_version,
-            network,
+            network: network.to_string(),
+            instrument,
         };
 
-        // The subgraph state tracks the state of the subgraph instance over time
-        let ctx = IndexingContext::new(
-            instance,
-            self.instances.cheap_clone(),
-            filter,
-            offchain_monitor,
-            tp,
-        );
+        // Initialize the indexing context, including both static and dynamic data sources.
+        // The order of inclusion is the order of processing when a same trigger matches
+        // multiple data sources.
+        let ctx = {
+            let mut ctx = IndexingContext::new(
+                manifest,
+                host_builder,
+                host_metrics.clone(),
+                causality_region_seq,
+                self.instances.cheap_clone(),
+                offchain_monitor,
+                tp,
+                decoder,
+            );
+            for data_source in data_sources {
+                ctx.add_dynamic_data_source(&logger, data_source)?;
+            }
+            ctx
+        };
 
         let metrics = RunnerMetrics {
             subgraph: subgraph_metrics,
@@ -443,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
@@ -459,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 4d3a0cab51d..00000000000
--- a/core/src/subgraph/provider.rs
+++ /dev/null
@@ -1,88 +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, *},
-};
-
-pub struct SubgraphAssignmentProvider<I> {
-    logger_factory: LoggerFactory,
-    subgraphs_running: Arc<Mutex<HashSet<DeploymentId>>>,
-    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,
-    ) -> 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,
-            subgraphs_running: Arc::new(Mutex::new(HashSet::new())),
-            link_resolver: link_resolver.with_retries().into(),
-            instance_manager: Arc::new(instance_manager),
-        }
-    }
-}
-
-#[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.subgraphs_running.lock().unwrap().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
-            .subgraphs_running
-            .lock()
-            .unwrap()
-            .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 b8d0f408e23..e9422671e25 100644
--- a/core/src/subgraph/registrar.rs
+++ b/core/src/subgraph/registrar.rs
@@ -1,36 +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::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::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,
@@ -38,9 +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());
@@ -54,21 +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
@@ -83,178 +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
-                                .assigned_node(&deployment)
-                                .map_err(|e| {
-                                    anyhow!("Failed to get subgraph assignment entity: {}", e)
-                                })
-                                .map(|assigned| -> Box<dyn Stream<Item = _, Error = _> + Send> {
-                                    if let Some(assigned) = assigned {
-                                        if assigned == node_id {
-                                            // 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.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());
 
@@ -269,6 +252,8 @@ where
         debug_fork: Option<DeploymentHash>,
         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
@@ -277,45 +262,48 @@ 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| {
             SubgraphRegistrarError::ResolveError(SubgraphManifestResolveError::ResolveError(e))
         })?;
 
+        // Give priority to deployment specific history_blocks value.
+        let history_blocks =
+            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,
-                )
-                .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(),
@@ -327,12 +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(),
@@ -344,41 +335,10 @@ where
                     node_id,
                     debug_fork,
                     self.version_switching_mode,
-                    &self.resolver,
-                )
-                .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,
-                )
-                .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,
+                    &resolver,
+                    self.amp_client.cheap_clone(),
+                    history_blocks,
+                    &self.amp_chain_names,
                 )
                 .await?
             }
@@ -395,9 +355,12 @@ where
     }
 
     async fn remove_subgraph(&self, name: SubgraphName) -> Result<(), SubgraphRegistrarError> {
-        self.store.clone().remove_subgraph(name.clone())?;
+        use itertools::Itertools;
+
+        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());
+        debug!(self.logger, "Removed subgraph"; "subgraph_name" => name.to_string(), "deployments" => format!("[{}]", hashes));
 
         Ok(())
     }
@@ -411,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(())
     }
 }
 
@@ -497,15 +420,18 @@ async fn resolve_start_block(
         .expect("cannot identify minimum start block because there are no data sources")
     {
         0 => Ok(None),
-        min_start_block => chain
-            .block_pointer_from_number(logger, min_start_block - 1)
-            .await
-            .map(Some)
-            .map_err(move |_| {
-                SubgraphRegistrarError::ManifestValidationError(vec![
-                    SubgraphManifestValidationError::BlockNotFound(min_start_block.to_string()),
-                ])
-            }),
+        min_start_block => Retry::start(retry_strategy(Some(2), RETRY_DEFAULT_LIMIT), move || {
+            chain
+                .block_pointer_from_number(logger, min_start_block - 1)
+                .inspect_err(move |e| warn!(&logger, "Failed to get block number: {}", e))
+        })
+        .await
+        .map(Some)
+        .map_err(move |_| {
+            SubgraphRegistrarError::ManifestValidationError(vec![
+                SubgraphManifestValidationError::BlockNotFound(min_start_block.to_string()),
+            ])
+        }),
     }
 }
 
@@ -528,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>,
@@ -541,27 +467,41 @@ 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,
+        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).await {
+        Ok(graft_pending) => graft_pending,
+        Err(StoreError::DeploymentNotFound(_)) => true,
+        Err(e) => return Err(SubgraphRegistrarError::StoreError(e)),
+    };
     let manifest = unvalidated
-        .validate(store.cheap_clone(), true)
+        .validate(store.cheap_clone(), should_validate)
         .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();
 
@@ -569,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";
@@ -626,19 +566,24 @@ async fn create_subgraph_version<C: Blockchain, S: SubgraphStore>(
 
     // Apply the subgraph versioning and deployment operations,
     // creating a new subgraph deployment if one doesn't exist.
-    let deployment = DeploymentCreate::new(raw_string, &manifest, start_block)
+    let mut deployment = DeploymentCreate::new(raw_string, &manifest, start_block)
         .graft(base_block)
         .debug(debug_fork)
         .entities_with_causality_region(needs_causality_region);
 
+    if let Some(history_blocks) = history_blocks_override {
+        deployment = deployment.with_history_blocks_override(history_blocks);
+    }
+
     deployment_store
         .create_subgraph_deployment(
             name,
             &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 521e68efe0c..00000000000
--- a/core/src/subgraph/runner.rs
+++ /dev/null
@@ -1,1069 +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, Blockchain, DataSource as _, TriggerFilter as _};
-use graph::components::store::{EmptyStore, EntityKey, StoredDynamicDataSource};
-use graph::components::{
-    store::ModificationsAndCache,
-    subgraph::{MappingError, PoICausalityRegion, ProofOfIndexing, SharedProofOfIndexing},
-};
-use graph::data::store::scalar::Bytes;
-use graph::data::subgraph::{
-    schema::{SubgraphError, SubgraphHealth, POI_OBJECT},
-    SubgraphFeature,
-};
-use graph::data_source::{
-    offchain, CausalityRegion, DataSource, DataSourceCreationError, DataSourceTemplate, TriggerData,
-};
-use graph::env::EnvVars;
-use graph::prelude::*;
-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);
-
-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::new(
-                    (MINUTE * 2).min(env_vars.subgraph_error_retry_ceil),
-                    env_vars.subgraph_error_retry_ceil,
-                ),
-                entity_lfu_cache: LfuCache::new(),
-            },
-            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
-    /// SubgraphInstance 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(&mut self, block_number: BlockNumber) -> Result<(), Error> {
-        self.state.entity_lfu_cache = LfuCache::new();
-
-        // 1. Revert all hosts(created by DDS) up to block_number inclusively.
-        // 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)?;
-        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
-    }
-
-    pub async fn run(self) -> Result<Self, Error> {
-        self.run_inner(false).await
-    }
-
-    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).
-                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();
-
-            let mut block_stream =
-                new_block_stream(&self.inputs, &self.ctx.filter, &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
-                match self
-                    .handle_stream_event(event, &block_stream_cancel_handle)
-                    .await?
-                {
-                    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 => 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)
-        ));
-
-        if triggers.len() == 1 {
-            debug!(&logger, "1 candidate trigger in this block");
-        } else {
-            debug!(
-                &logger,
-                "{} candidate triggers in this block",
-                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);
-
-        // Process events one after the other, passing in entity operations
-        // collected previously to every new event being processed
-        let mut block_state = 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);
-            }
-        };
-
-        // If new 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 needs_restart = block_state.has_created_data_sources() && !self.inputs.static_filters;
-
-        // 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() {
-                Arc::new(
-                    self.inputs
-                        .chain
-                        .refetch_firehose_block(&logger, firehose_cursor.clone())
-                        .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,
-                        &runtime_hosts,
-                        &block,
-                        &TriggerData::Onchain(trigger),
-                        block_state,
-                        &proof_of_indexing,
-                        &causality_region,
-                        &self.inputs.debug_fork,
-                        &self.metrics.subgraph,
-                    )
-                    .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,
-                &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,
-        } = block_state
-            .entity_cache
-            .as_modifications()
-            .map_err(|e| BlockProcessingError::Unknown(e.into()))?;
-        section.end();
-
-        // 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_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.entity_ref().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,
-            persisted_data_sources,
-            ..
-        } = block_state;
-
-        let first_error = deterministic_errors.first().cloned();
-
-        store
-            .transact_block_operations(
-                block_ptr,
-                firehose_cursor,
-                mods,
-                &self.metrics.host.stopwatch,
-                persisted_data_sources,
-                deterministic_errors,
-                self.inputs.manifest_idx_and_name.clone(),
-                processed_data_sources,
-            )
-            .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,
-                )
-                .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)
-    }
-
-    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))
-    }
-
-    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());
-        }
-
-        // Merge filters from data sources into the block stream builder
-        self.ctx
-            .filter
-            .extend(data_sources.iter().filter_map(|ds| ds.as_onchain()));
-    }
-}
-
-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::ProcessBlock(block, cursor))) => {
-                self.handle_process_block(block, cursor, cancel_handle)
-                    .await?
-            }
-            Some(Ok(BlockStreamEvent::Revert(revert_to_ptr, cursor))) => {
-                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>), Error> {
-        let mut mods = vec![];
-        let mut processed_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 = self.inputs.store.input_schema();
-            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,
-                )
-                .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_data_sources(),
-                "Attempted to create data source in offchain data source handler. This is not yet supported.",
-            );
-
-            // 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()?.modifications);
-            processed_data_sources.extend(block_state.processed_data_sources);
-        }
-
-        Ok((mods, processed_data_sources))
-    }
-}
-
-#[derive(Debug)]
-enum Action {
-    Continue,
-    Stop,
-    Restart,
-}
-
-#[async_trait]
-trait StreamEventHandler<C: Blockchain> {
-    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>;
-}
-
-#[async_trait]
-impl<C, T> StreamEventHandler<C> for SubgraphRunner<C, T>
-where
-    C: Blockchain,
-    T: RuntimeHostBuilder<C>,
-{
-    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().cached_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;
-
-        let elapsed = start.elapsed().as_secs_f64();
-        self.metrics
-            .subgraph
-            .block_processing_duration
-            .observe(elapsed);
-
-        match res {
-            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().cached_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);
-                    }
-                }
-
-                if matches!(action, Action::Restart) {
-                    // Cancel the stream for real
-                    self.ctx.instances.remove(&self.inputs.deployment.id);
-
-                    // And restart the subgraph
-                    return Ok(Action::Restart);
-                }
-
-                return Ok(Action::Continue);
-            }
-            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);
-                self.revert_state(block_ptr.block_number())?;
-
-                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:
-
-                        // Cancel the stream for real.
-                        self.ctx.instances.remove(&self.inputs.deployment.id);
-
-                        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);
-                    }
-                }
-            }
-        }
-    }
-
-    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, 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(subgraph_ptr.number)?;
-
-        Ok(Action::Continue)
-    }
-
-    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)
-    }
-}
-
-/// 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,
-    stopwatch: &StopwatchMetrics,
-    entity_cache: &mut EntityCache,
-) -> Result<(), Error> {
-    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
-        let entity_key = EntityKey {
-            entity_type: POI_OBJECT.to_owned(),
-
-            // 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
-            entity_id: causality_region.into(),
-            causality_region: CausalityRegion::ONCHAIN,
-        };
-
-        // Grab the current digest attribute on this entity
-        let prev_poi =
-            entity_cache
-                .get(&entity_key)
-                .map_err(Error::from)?
-                .map(|entity| match entity.get("digest") {
-                    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.
-        let new_poi_entity = entity! {
-            id: entity_key.entity_id.to_string(),
-            digest: updated_proof_of_indexing,
-        };
-
-        entity_cache.set(entity_key, new_poi_entity)?;
-    }
-
-    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 0d5edd84b65..c1da4b43199 100644
--- a/core/src/subgraph/state.rs
+++ b/core/src/subgraph/state.rs
@@ -1,15 +1,11 @@
 use graph::{
-    components::store::EntityKey,
-    prelude::Entity,
-    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,5 +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 791a9becc92..5547543f13d 100644
--- a/core/src/subgraph/stream.rs
+++ b/core/src/subgraph/stream.rs
@@ -1,50 +1,38 @@
 use crate::subgraph::inputs::IndexingInputs;
+use anyhow::bail;
 use graph::blockchain::block_stream::{BlockStream, BufferedBlockStream};
-use graph::blockchain::Blockchain;
-use graph::prelude::{Error, SubgraphInstanceMetrics};
+use graph::blockchain::{Blockchain, TriggerFilterWrapper};
+use graph::prelude::{CheapClone, Error, SubgraphInstanceMetrics};
 use std::sync::Arc;
 
-const BUFFERED_BLOCK_STREAM_SIZE: usize = 100;
-const BUFFERED_FIREHOSE_STREAM_SIZE: usize = 1;
-
 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();
 
-    let buffer_size = match is_firehose {
-        true => BUFFERED_FIREHOSE_STREAM_SIZE,
-        false => BUFFERED_BLOCK_STREAM_SIZE,
-    };
-
-    let current_ptr = inputs.store.block_ptr();
-
-    let block_stream = match is_firehose {
-        true => inputs.chain.new_firehose_block_stream(
+    match inputs
+        .chain
+        .new_block_stream(
             inputs.deployment.clone(),
-            inputs.store.block_cursor(),
+            inputs.store.cheap_clone(),
             inputs.start_blocks.clone(),
-            current_ptr,
+            inputs.source_subgraph_stores.clone(),
             Arc::new(filter.clone()),
             inputs.unified_api_version.clone(),
-        ),
-        false => inputs.chain.new_polling_block_stream(
-            inputs.deployment.clone(),
-            inputs.start_blocks.clone(),
-            current_ptr,
-            Arc::new(filter.clone()),
-            inputs.unified_api_version.clone(),
-        ),
+        )
+        .await
+    {
+        Ok(block_stream) => Ok(BufferedBlockStream::spawn_from_stream(
+            block_stream.buffer_size_hint(),
+            block_stream,
+        )),
+        Err(e) => {
+            if is_firehose {
+                metrics.firehose_connection_errors.inc();
+            }
+            bail!(e);
+        }
     }
-    .await;
-    if is_firehose && block_stream.is_err() {
-        metrics.firehose_connection_errors.inc();
-    }
-
-    Ok(BufferedBlockStream::spawn_from_stream(
-        block_stream?,
-        buffer_size,
-    ))
 }
diff --git a/core/src/subgraph/trigger_processor.rs b/core/src/subgraph/trigger_processor.rs
index 2eeb8275500..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 {}
@@ -19,58 +21,40 @@ where
     C: Blockchain,
     T: RuntimeHostBuilder<C>,
 {
-    async fn process_trigger(
-        &self,
+    async fn process_trigger<'a>(
+        &'a self,
         logger: &Logger,
-        hosts: &[Arc<T::Host>],
+        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>,
-    ) -> Result<BlockState<C>, MappingError> {
+        instrument: bool,
+    ) -> 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(
                     logger,
-                    mapping_trigger.block_ptr(),
                     mapping_trigger,
                     state,
                     proof_of_indexing.cheap_clone(),
                     debug_fork,
+                    instrument,
                 )
                 .await?;
             let elapsed = start.elapsed().as_secs_f64();
@@ -85,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/core/tests/README.md b/core/tests/README.md
new file mode 100644
index 00000000000..261623bcccf
--- /dev/null
+++ b/core/tests/README.md
@@ -0,0 +1,5 @@
+Put integration tests for this crate into `store/test-store/tests/core`.
+This avoids cyclic dev-dependencies which make rust-analyzer nearly
+unusable. Once [this
+issue](https://github.com/rust-lang/rust-analyzer/issues/14167) has been
+fixed, we can move tests back here
diff --git a/docker/Dockerfile b/docker/Dockerfile
index 8c0a8e19919..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,48 +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 ""
+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
@@ -96,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/
@@ -104,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 326a3535e9f..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
 
@@ -59,7 +34,7 @@ can access these via:
   - `postgresql://graph-node:let-me-in@localhost:5432/graph-node`
 
 Once this is up and running, you can use
-[`graph-cli`](https://github.com/graphprotocol/graph-cli) to create and
+[`graph-cli`](https://github.com/graphprotocol/graph-tooling/tree/main/packages/cli) to create and
 deploy your subgraph to the running Graph Node.
   
 ### Running Graph Node on an Macbook M1
@@ -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/cloudbuild.yaml b/docker/cloudbuild.yaml
index 39cf2856e62..0bf800cddad 100644
--- a/docker/cloudbuild.yaml
+++ b/docker/cloudbuild.yaml
@@ -1,5 +1,5 @@
 options:
-  machineType: "N1_HIGHCPU_32"
+  machineType: "E2_HIGHCPU_32"
 timeout: 1800s
 steps:
 - name: 'gcr.io/cloud-builders/docker'
diff --git a/docker/docker-compose.yml b/docker/docker-compose.yml
index 742de12649d..c78c2eb2194 100644
--- a/docker/docker-compose.yml
+++ b/docker/docker-compose.yml
@@ -22,11 +22,11 @@ services:
       ethereum: 'mainnet:http://host.docker.internal:8545'
       GRAPH_LOG: info
   ipfs:
-    image: ipfs/go-ipfs:v0.10.0
+    image: ipfs/kubo:v0.17.0
     ports:
       - '5001:5001'
     volumes:
-      - ./data/ipfs:/data/ipfs
+      - ./data/ipfs:/data/ipfs:Z
   postgres:
     image: postgres
     ports:
@@ -34,7 +34,8 @@ services:
     command:
       [
         "postgres",
-        "-cshared_preload_libraries=pg_stat_statements"
+        "-cshared_preload_libraries=pg_stat_statements",
+        "-cmax_connections=200"
       ]
     environment:
       POSTGRES_USER: graph-node
@@ -46,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/start b/docker/start
index bbeabd166a3..f1e4106363e 100755
--- a/docker/start
+++ b/docker/start
@@ -42,6 +42,7 @@ wait_for_ipfs() {
         then
             [ "$proto" = "https" ] && port=443 || port=80
         fi
+        echo "Waiting for IPFS ($host:$port)"
         wait_for "$host:$port" -t 120
     else
         echo "invalid IPFS URL: $1"
@@ -64,9 +65,10 @@ run_graph_node() {
     else
         unset GRAPH_NODE_CONFIG
         postgres_port=${postgres_port:-5432}
-        postgres_url="postgresql://$postgres_user:$postgres_pass@$postgres_host:$postgres_port/$postgres_db?sslmode=prefer"
+        postgres_url="postgresql://$postgres_user:$postgres_pass@$postgres_host:$postgres_port/$postgres_db?$postgres_args"
 
         wait_for_ipfs "$ipfs"
+        echo "Waiting for Postgres ($postgres_host:$postgres_port)"
         wait_for "$postgres_host:$postgres_port" -t 120
         sleep 5
 
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
new file mode 100644
index 00000000000..3e90d7ee62f
--- /dev/null
+++ b/docs/aggregations.md
@@ -0,0 +1,253 @@
+# Timeseries and aggregations
+
+_This feature is available from spec version 1.1.0 onwards_
+
+## Overview
+
+Aggregations are declared in the subgraph schema through two types: one that
+stores the raw data points for the time series, and one that defines how raw
+data points are to be aggregated. A very simple aggregation can be declared like this:
+
+```graphql
+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")
+}
+```
+
+Mappings for this schema will add data points by creating `Data` entities
+just as they would for normal entities. `graph-node` will then automatically
+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 `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.
+Both fields are set automatically by `graph-node`. The `timestamp` is set to
+the beginning of the time period that that aggregation instance represents,
+for example, to the beginning of the hour for an hourly aggregation. The
+`id` field is set to the `id` of one of the raw data points that went into
+the aggregation. Which one is chosen is not specified and should not be
+relied on.
+
+**TODO**: figure out whether we should just automatically add `id` and
+`timestamp` and have validation just check that these fields don't exist
+
+Aggregations can also contain _dimensions_, which are fields that are not
+aggregated but are used to group the data points. For example, the
+`TokenStats` aggregation below has a `token` field that is used to group the
+data points by token:
+
+```graphql
+# Normal entity
+type Token @entity { .. }
+
+# Raw data points
+type TokenData @entity(timeseries: true) {
+    id: Bytes!
+    timestamp: Timestamp!
+    token: Token!
+    amount: BigDecimal!
+    priceUSD: BigDecimal!
+}
+
+# Aggregations over TokenData
+type TokenStats @aggregation(intervals: ["hour", "day"], source: "TokenData") {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  totalVolume: BigDecimal! @aggregate(fn: "sum", arg: "amount")
+  priceUSD: BigDecimal! @aggregate(fn: "last", arg: "priceUSD")
+  count: Int8! @aggregate(fn: "count", cumulative: true)
+}
+```
+
+Fields in aggregations without the `@aggregate` directive are called
+_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.
+
+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.
+
+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 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
+
+An aggregation is defined with an `@aggregation` annotation. The annotation
+must have two arguments:
+
+- `intervals`: a non-empty array of intervals; currently, only `hour` and `day`
+  are supported
+- `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 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, or an expression
+  using only constants and attributes of the timeseries type
+
+#### Aggregation functions
+
+The following aggregation functions are currently supported:
+
+| Name    | Description       |
+| ------- | ----------------- |
+| `sum`   | Sum of all values |
+| `count` | Number of values  |
+| `min`   | Minimum value     |
+| `max`   | Maximum value     |
+| `first` | First value       |
+| `last`  | Last value        |
+
+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
+
+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.
+
+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:
+
+- For each dimension, an optional filter to test for equality of that
+  dimension
+- A mandatory `interval`
+- An optional `current` to indicate whether to include the current,
+  partially filled bucket in the response. Can be either `exclude` (the
+  default) or `include`
+- 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: exclude,
+      where: {
+        token: "0x1234",
+        timestamp_gte: 1234567890,
+        timestamp_lt: 1234567890 }) {
+  id
+  timestamp
+  token
+  totalVolume
+  avgVolume
+}
+```
+
+### 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 53a9299efed..db5fc083a5f 100644
--- a/docs/config.md
+++ b/docs/config.md
@@ -5,11 +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:
-* `[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.
+The TOML file consists of three sections:
+
+- [`[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
@@ -99,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)
-* `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`
-* `headers`: HTTP headers to be added on every request. Defaults to none.
-* `limit`: the maximum number of subgraphs that can use this provider.
+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 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**
@@ -151,13 +265,13 @@ approximate and can differ from the true number by a small amount
 (generally less than 10)
 
 The limit is set through rules that match on the node name. If a node's
-name does not match any rule, the corresponding provider will be disabled 
-for that node. 
+name does not match any rule, the corresponding provider will be disabled
+for that node.
 
 If the match property is omitted then the provider will be unlimited on every
-node. 
+node.
 
-It is recommended that at least one provider is generally unlimited. 
+It is recommended that at least one provider is generally unlimited.
 The limit is set in the following way:
 
 ```toml
@@ -174,7 +288,7 @@ provider = [
 Nodes named `some_node_.*` will use `mainnet-1` for at most 10 subgraphs,
 and `mainnet-0` for everything else, nodes named `other_node_.*` will never
 use `mainnet-1` and always `mainnet-0`. Any node whose name does not match
-one of these patterns will not be able to use and `mainnet-1`. 
+one of these patterns will not be able to use and `mainnet-1`.
 
 ## Controlling Deployment
 
@@ -237,6 +351,7 @@ indexers = [
 
 Nodes can be configured to explicitly be query nodes by including the
 following in the configuration file:
+
 ```toml
 [general]
 query = "<regular expression>"
@@ -250,6 +365,7 @@ try to connect to any of the configured Ethereum providers.
 
 The following file is equivalent to using the `--postgres-url` command line
 option:
+
 ```toml
 [store]
 [store.primary]
@@ -261,21 +377,26 @@ indexers = [ "<.. list of all indexing nodes ..>" ]
 
 ## Validating configuration files
 
-A configuration file can be checked for validity by passing the `--check-config`
-flag to `graph-node`. The command
+A configuration file can be checked for validity with the `config check`
+command. Running
+
 ```shell
-graph-node --config $CONFIG_FILE --check-config
+graph-node --config $CONFIG_FILE config check
 ```
-will read the configuration file and print information about syntax errors or, for
-valid files, a JSON representation of the configuration.
+
+will read the configuration file and print information about syntax errors
+and some internal inconsistencies, for example, when a shard that is not
+declared as a store is used in a deployment rule.
 
 ## Simulating deployment placement
 
 Given a configuration file, placement of newly deployed subgraphs can be
 simulated with
+
 ```shell
 graphman --config $CONFIG_FILE config place some/subgraph mainnet
 ```
+
 The command will not make any changes, but simply print where that subgraph
 would be placed. The output will indicate the database shard that will hold
 the subgraph's data, and a list of indexing nodes that could be used for
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 2bed9a09ab4..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
@@ -25,11 +30,11 @@ those.
 - `DISABLE_BLOCK_INGESTOR`: set to `true` to disable block ingestion. Leave
   unset or set to `false` to leave block ingestion enabled.
 - `ETHEREUM_BLOCK_BATCH_SIZE`: number of Ethereum blocks to request in parallel.
-  Also limits other parallel requests such such as trace_filter. Defaults to 10.
+  Also limits other parallel requests such as trace_filter. Defaults to 10.
 - `GRAPH_ETHEREUM_MAX_BLOCK_RANGE_SIZE`: Maximum number of blocks to scan for
   triggers in each request (defaults to 1000).
 - `GRAPH_ETHEREUM_MAX_EVENT_ONLY_RANGE`: Maximum range size for `eth.getLogs`
-  requests that dont filter on contract address, only event signature (defaults to 500).
+  requests that don't filter on contract address, only event signature (defaults to 500).
 - `GRAPH_ETHEREUM_JSON_RPC_TIMEOUT`: Timeout for Ethereum JSON-RPC requests.
 - `GRAPH_ETHEREUM_REQUEST_RETRIES`: Number of times to retry JSON-RPC requests
   made against Ethereum. This is used for requests that will not fail the
@@ -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
 
@@ -70,7 +82,8 @@ those.
 
 - `GRAPH_IPFS_TIMEOUT`: timeout for IPFS, which includes requests for manifest files
   and from mappings (in seconds, default is 60).
-- `GRAPH_MAX_IPFS_FILE_BYTES`: maximum size for a file that can be retrieved (in bytes, default is 256 MiB).
+- `GRAPH_MAX_IPFS_FILE_BYTES`: maximum size for a file that can be retrieved by an `ipfs cat` call.
+  This affects both subgraph definition files and `file/ipfs` data sources. In bytes, default is 25 MiB.
 - `GRAPH_MAX_IPFS_MAP_FILE_SIZE`: maximum size of files that can be processed
   with `ipfs.map`. When a file is processed through `ipfs.map`, the entities
   generated from that are kept in memory until the entire file is done
@@ -78,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 both concurrent and per second requests 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
 
@@ -104,23 +126,17 @@ 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.
+  This will validate and ensure every query executes follows the execution
+  rules. Default: `false`
 - `SILENT_GRAPHQL_VALIDATIONS`: If `ENABLE_GRAPHQL_VALIDATIONS` is enabled, you are also able to just
   silently print the GraphQL validation errors, without failing the actual query. Note: queries
-  might still fail as part of the later stage validations running, during GraphQL engine execution.
+  might still fail as part of the later stage validations running, during
+  GraphQL engine execution. Default: `true`
 - `GRAPH_GRAPHQL_DISABLE_BOOL_FILTERS`: disables the ability to use AND/OR
   filters. This is useful if we want to disable filters because of
   performance reasons.
@@ -139,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
 
@@ -157,6 +177,8 @@ those.
 - `THEGRAPH_STORE_POSTGRES_DIESEL_URL`: postgres instance used when running
   tests. Set to `postgresql://<DBUSER>:<DBPASSWORD>@<DBHOST>:<DBPORT>/<DBNAME>`
 - `GRAPH_KILL_IF_UNRESPONSIVE`: If set, the process will be killed if unresponsive.
+- `GRAPH_KILL_IF_UNRESPONSIVE_TIMEOUT_SECS`: Timeout in seconds before killing
+  the node if `GRAPH_KILL_IF_UNRESPONSIVE` is true. The default value is 10s.
 - `GRAPH_LOG_QUERY_TIMING`: Control whether the process logs details of
   processing GraphQL and SQL queries. The value is a comma separated list
   of `sql`,`gql`, and `cache`. If `gql` is present in the list, each
@@ -169,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.
@@ -200,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.
@@ -216,7 +245,125 @@ 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.
 - `GRAPH_DEBUG_FORK`: the IPFS hash id of the subgraph to fork.
+- `GRAPH_STORE_HISTORY_SLACK_FACTOR`: How much history a subgraph with
+  limited history can accumulate before it will be pruned. Setting this to
+  1.1 means that the subgraph will be pruned every time it contains 10%
+  more history (in blocks) than its history limit. The default value is 1.2
+  and the value must be at least 1.01
+- `GRAPH_STORE_HISTORY_REBUILD_THRESHOLD`,
+  `GRAPH_STORE_HISTORY_DELETE_THRESHOLD`: when pruning, prune by copying
+  the entities we will keep to new tables if we estimate that we will
+  remove more than a factor of `REBUILD_THRESHOLD` of the deployment's
+  history. If we estimate to remove a factor between `REBUILD_THRESHOLD`
+  and `DELETE_THRESHOLD`, prune by deleting from the existing tables of the
+  deployment. If we estimate to remove less than `DELETE_THRESHOLD`
+  entities, do not change the table. Both settings are floats, and default
+  to 0.5 for the `REBUILD_THRESHOLD` and 0.05 for the `DELETE_THRESHOLD`;
+  they must be between 0 and 1, and `REBUILD_THRESHOLD` must be bigger than
+  `DELETE_THRESHOLD`.
+- `GRAPH_STORE_WRITE_BATCH_DURATION`: how long to accumulate changes during
+  syncing into a batch before a write has to happen in seconds. The default
+  is 300s. Setting this to 0 disables write batching.
+- `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 e7ea53a7ca1..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-cli) – A CLI for building and compiling projects that are deployed to the Graph Node.
-3. [Graph TypeScript Library](https://github.com/graphprotocol/graph-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 Etheruem node](#23-starting-the-graph-node-and-connecting-to-an-etheruem-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-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-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-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-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-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 0964efc6051..8c857703dda 100644
--- a/docs/graphman.md
+++ b/docs/graphman.md
@@ -52,7 +52,7 @@ By default, it shows the following attributes for the deployment:
 -   **name**
 -   **status** *(`pending` or `current`)*
 -   **id** *(the `Qm...` identifier for the deployment's subgraph)*
--   **namespace** *(The database schema which contain's that deployment data tables)*
+-   **namespace** *(The database schema which contains that deployment data tables)*
 -   **shard**
 -   **active** *(If there are multiple entries for the same subgraph, only one of them will be active. That's the one we use for querying)*
 -   **chain**
@@ -169,7 +169,7 @@ primary shard.
 
 No indexed data is lost as a result of this command.
 
-This sub-command is used as previus step towards removing all data from unused subgraphs, followed by
+This sub-command is used as previous step towards removing all data from unused subgraphs, followed by
 `graphman unused remove`.
 
 A deployment is unused if it fulfills all of these criteria:
@@ -236,7 +236,7 @@ Remove a specific unused deployment
 
 ### SYNOPSIS
 
-    Delete a deployment and all it's indexed data
+    Delete a deployment and all its 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
@@ -288,7 +288,7 @@ Stop, unassign and delete all indexed data from a specific deployment by its dep
 
 Stop, unassign and delete all indexed data from a specific deployment by its subgraph name
 
-    graphman --config config.toml drop autor/subgraph-name
+    graphman --config config.toml drop author/subgraph-name
 
 <a id="check-blocks"></a>
 # ⌘ Check Blocks
@@ -322,7 +322,7 @@ is useful to diagnose the integrity of cached blocks and eventually fix them.
 
 ### OPTIONS
 
-Blocks can be selected by different methods. The `check-blocks` command let's you use the block hash, a single
+Blocks can be selected by different methods. The `check-blocks` command lets you use the block hash, a single
 number or a number range to refer to which blocks it should verify:
 
 #### `by-hash`
@@ -338,7 +338,7 @@ number or a number range to refer to which blocks it should verify:
     graphman --config <config> chain check-blocks <chain-name> by-range [-f|--from <block-number>] [-t|--to <block-number>] [--delete-duplicates]
 
 The `by-range` method lets you scan for numeric block ranges and offers the `--from` and `--to` options for
-you to define the search bounds. If one of those options is ommited, `graphman` will consider an open bound
+you to define the search bounds. If one of those options is omitted, `graphman` will consider an open bound
 and will scan all blocks up to or after that number.
 
 Over time, it can happen that a JSON RPC provider offers different blocks for the same block number. In those
@@ -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 441c5f279aa..d54a39babbe 100644
--- a/docs/implementation/README.md
+++ b/docs/implementation/README.md
@@ -9,3 +9,5 @@ the code should go into comments.
 * [Time-travel Queries](./time-travel.md)
 * [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 eea61687910..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-cli) and [graph-ts](https://github.com/graphprotocol/graph-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-cli/pull/760
-    - https://github.com/graphprotocol/graph-cli/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-cli/pull/827
-    - https://github.com/graphprotocol/graph-cli/pull/851
-    - https://github.com/graphprotocol/graph-cli/pull/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 ee54fb30361..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`     |                                                      |
@@ -106,26 +121,27 @@ shard alongside the deployment's data in `sgdNNN`.
 | `start_block_hash`      | `bytea`    | Parent of the smallest start block from the manifest |
 | `start_block_number`    | `int4`     |                                                      |
 | `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.
 
@@ -140,3 +156,16 @@ correctly across index node restarts.
 
 The table `subgraphs.table_stats` stores which tables for a deployment
 should have the 'account-like' optimization turned on.
+
+### `subgraphs.subgraph_features`
+
+Details about features that a deployment uses, Maintained in the primary.
+
+| Column         | Type      | Use         |
+| -------------- | --------- | ----------- |
+| `id`           | `text!`   | primary key |
+| `spec_version` | `text!`   |             |
+| `api_version`  | `text`    |             |
+| `features`     | `text[]!` |             |
+| `data_sources` | `text[]!` |             |
+| `handlers`     | `text[]!` |             |
diff --git a/docs/implementation/offchain.md b/docs/implementation/offchain.md
new file mode 100644
index 00000000000..268aba5157b
--- /dev/null
+++ b/docs/implementation/offchain.md
@@ -0,0 +1,25 @@
+# Offchain data sources
+
+### Summary
+
+Graph Node supports syncing offchain data sources in a subgraph, such as IPFS files. The documentation for subgraph developers can be found in the official docs. This document describes the implementation of offchain data sources and how support for a new kinds offchain data source can be added.
+
+### Implementation Overview
+
+The implementation of offchain data sources has multiple reusable components and data structures, seeking to simplify the addition of new kinds of file data sources. The initially supported data source kind is `file/ipfs`, so in particular any new file kind should be able to reuse a lot the existing code.
+
+The data structures that represent an offchain data source, along with the code that parses it from the manifest or creates it as a dynamic data source, lives in the `graph` crate, in `data_source/offchain.rs`.  A new file kind would probably only need a new `enum Source` variant, and the kind would need to be added to `const OFFCHAIN_KINDS`.
+
+The `OffchainMonitor` is responsible for tracking and fetching the offchain data. It currently lives in `subgraph/context.rs`. When an offchain data source is created from a template, `fn add_source` is called. It is expected that a background task will monitor the source for relevant events, in the case of a file that means the file becoming available and the event is the file content. To process these events, the subgraph runner calls `fn ready_offchain_events`  periodically.
+
+If the data source kind being added relies on polling to check the availability of the monitored object, the generic `PollingMonitor` component can be used. Then the only implementation work is implementing the polling logic itself, as a `tower` service. The `IpfsService` serves as an example of how to do that.
+
+### Testing
+
+Automated testing for this functionality can be tricky, and will need to be discussed in each case, but the `file_data_sources` test in the `runner_tests.rs` can serve as a starting point of how to write an integration test using offchain data source.
+
+### Notes
+
+- Offchain data sources currently can only exist as dynamic data sources, instantiated from templates, and not as static data sources configured in the manifest.
+- Some parts of the existing support for offchain data sources assumes they are 'one shot', meaning only a single trigger is ever handled by each offchain data source. This works well for files, the file is found, handled, and that's it. More complex offchain data sources will require additional planning.
+- Entities from offchain data sources do not currently influence the PoI. Causality region ids are not deterministic. 
diff --git a/docs/implementation/pruning.md b/docs/implementation/pruning.md
new file mode 100644
index 00000000000..4faf66f4e31
--- /dev/null
+++ b/docs/implementation/pruning.md
@@ -0,0 +1,99 @@
+## Pruning deployments
+
+Subgraphs, by default, store a full version history for entities, allowing
+consumers to query the subgraph as of any historical block. Pruning is an
+operation that deletes entity versions from a deployment older than a
+certain block, so it is no longer possible to query the deployment as of
+prior blocks. In GraphQL, those are only queries with a constraint `block {
+number: <n> } }` or a similar constraint by block hash where `n` is before
+the block to which the deployment is pruned. Queries that are run at a
+block height greater than that are not affected by pruning, and there is no
+difference between running these queries against an unpruned and a pruned
+deployment.
+
+Because pruning reduces the amount of data in a deployment, it reduces the
+amount of storage needed for that deployment, and is beneficial for both
+query performance and indexing speed. Especially compared to the default of
+keeping all history for a deployment, it can often reduce the amount of
+data for a deployment by a very large amount and speed up queries
+considerably. See [caveats](#caveats) below for the downsides.
+
+The block `b` to which a deployment is pruned is controlled by how many
+blocks `history_blocks` of history to retain; `b` is calculated internally
+using `history_blocks` and the latest block of the deployment when the
+prune operation is performed. When pruning finishes, it updates the
+`earliest_block` for the deployment. The `earliest_block` can be retrieved
+through the `index-node` status API, and `graph-node` will return an error
+for any query that tries to time-travel to a point before
+`earliest_block`. The value of `history_blocks` must be greater than
+`ETHEREUM_REORG_THRESHOLD` to make sure that reverts can never conflict
+with pruning.
+
+Pruning is started by running `graphman prune`. That command will perform
+an initial prune of the deployment and set the subgraph's `history_blocks`
+setting which is used to periodically check whether the deployment has
+accumulated more history than that. Whenever the deployment does contain
+more history than that, the deployment is automatically repruned. If
+ongoing pruning is not desired, pass the `--once` flag to `graphman
+prune`. Ongoing pruning can be turned off by setting `history_blocks` to a
+very large value with the `--history` flag.
+
+Repruning is performed whenever the deployment has more than
+`history_blocks * GRAPH_STORE_HISTORY_SLACK_FACTOR` blocks of history. The
+environment variable `GRAPH_STORE_HISTORY_SLACK_FACTOR` therefore controls
+how often repruning is performed: with
+`GRAPH_STORE_HISTORY_SLACK_FACTOR=1.5` and `history_blocks` set to 10,000,
+a reprune will happen every 5,000 blocks. After the initial pruning, a
+reprune therefore happens every `history_blocks * (1 -
+GRAPH_STORE_HISTORY_SLACK_FACTOR)` blocks. This value should be set high
+enough so that repruning occurs relatively infrequently to not cause too
+much database work.
+
+Pruning uses two different strategies for how to remove unneeded data:
+rebuilding tables and deleting old entity versions. Deleting old entity
+versions is straightforward: this strategy deletes rows from the underlying
+tables. Rebuilding tables will copy the data that should be kept from the
+existing tables into new tables and then replaces the existing tables with
+these much smaller tables. Which strategy to use is determined for each
+table individually, and governed by the settings for
+`GRAPH_STORE_HISTORY_REBUILD_THRESHOLD` and
+`GRAPH_STORE_HISTORY_DELETE_THRESHOLD`, both numbers between 0 and 1: if we
+estimate that we will remove more than `REBUILD_THRESHOLD` of the table,
+the table will be rebuilt. If we estimate that we will remove a fraction
+between `REBUILD_THRESHOLD` and `DELETE_THRESHOLD` of the table, unneeded
+entity versions will be deleted. If we estimate to remove less than
+`DELETE_THRESHOLD`, the table is not changed at all. With both strategies,
+operations are broken into batches that should each take
+`GRAPH_STORE_BATCH_TARGET_DURATION` seconds to avoid causing very
+long-running transactions.
+
+Pruning, in most cases, runs in parallel with indexing and does not block
+it. When the rebuild strategy is used, pruning does block indexing while it
+copies non-final entities from the existing table to the new table.
+
+The initial prune started by `graphman prune` prints a progress report on
+the console. For the ongoing prune runs that are periodically performed,
+the following information is logged: a message `Start pruning historical
+entities` which includes the earliest and latest block, a message `Analyzed
+N tables`, and a message `Finished pruning entities` with details about how
+much was deleted or copied and how long that took. Pruning analyzes tables,
+if that seems necessary, because its estimates of how much of a table is
+likely not needed are based on Postgres statistics.
+
+### Caveats
+
+Pruning is a user-visible operation and does affect some of the things that
+can be done with a deployment:
+
+* because it removes history, it restricts how far back time-travel queries
+  can be performed. This will only be an issue for entities that keep
+  lifetime statistics about some object (e.g., a token) and are used to
+  produce time series: after pruning, it is only possible to produce a time
+  series that goes back no more than `history_blocks`. It is very
+  beneficial though for entities that keep daily or similar statistics
+  about some object as it removes data that is not needed once the time
+  period is over, and does not affect how far back time series based on
+  these objects can be retrieved.
+* it restricts how far back a graft can be performed. Because it removes
+  history, it becomes impossible to graft more than `history_blocks` before
+  the current deployment head.
diff --git a/docs/implementation/schema-generation.md b/docs/implementation/schema-generation.md
index c8bba833681..fbd227f9de6 100644
--- a/docs/implementation/schema-generation.md
+++ b/docs/implementation/schema-generation.md
@@ -5,13 +5,13 @@ table definition in Postgres.
 
 Schema generation follows a few simple rules:
 
-* the data for a subgraph is entirely stored in a Postgres namespace whose
+- the data for a subgraph is entirely stored in a Postgres namespace whose
   name is `sgdNNNN`. The mapping between namespace name and deployment id is
   kept in `deployment_schemas`
-* the data for each entity type is stored in a table whose structure follows
+- the data for each entity type is stored in a table whose structure follows
   the declaration of the type in the GraphQL schema
-* enums in the GraphQL schema are stored as enum types in Postgres
-* interfaces are not stored in the database, only the concrete types that
+- enums in the GraphQL schema are stored as enum types in Postgres
+- interfaces are not stored in the database, only the concrete types that
   implement the interface are stored
 
 Any table for an entity type has the following structure:
@@ -32,20 +32,20 @@ queries](./time-travel.md).
 The attributes of the GraphQL type correspond directly to columns in the
 generated table. The types of these columns are
 
-* the `id` column can have type `ID`, `String`, and `Bytes`, where `ID` is
+- the `id` column can have type `ID`, `String`, and `Bytes`, where `ID` is
   an alias for `String` for historical reasons.
-* if the attribute has a primitive type, the column has the SQL type that
+- if the attribute has a primitive type, the column has the SQL type that
   most closely mirrors the GraphQL type. `BigDecimal` and `BigInt` are
   stored as `numeric`, `Bytes` is stored as `bytea`, etc.
-* if the attribute references another entity, the column has the type of the
+- if the attribute references another entity, the column has the type of the
   `id` type of the referenced entity type. We do not use foreign key
   constraints to allow storing an entity that references an entity that will
   only be created later. Foreign key constraint violations will therefore
   only be detected when a query is issued, or simply lead to the reference
   missing from the query result.
-* if the attribute has an enum type, we generate a SQL enum type and use
+- if the attribute has an enum type, we generate a SQL enum type and use
   that as the type of the column.
-* if the attribute has a list type, like `[String]`, the corresponding
+- if the attribute has a list type, like `[String]`, the corresponding
   column uses an array type. We do not allow nested arrays like `[[String]]`
   in GraphQL, so arrays will only ever contain entries of a primitive type.
 
@@ -70,6 +70,22 @@ constraint `unique(id)` to such tables, and can avoid expensive GiST
 indexes in favor of simple BTree indexes since the `block$` column is an
 integer.
 
+### Timeseries
+
+Entity types declared with `@entity(timeseries: true)` are represented in
+the same way as immutable entities. The only difference is that timeseries
+also must have a `timestamp` attribute.
+
+### Aggregations
+
+Entity types declared with `@aggregation` are represented by several tables,
+one for each `interval` from the `@aggregation` directive. The tables are
+named `TYPE_INTERVAL` where `TYPE` is the name of the aggregation, and
+`INTERVAL` is the name of the interval; they do not support mutating
+entities as aggregations are never updated, only appended to. The tables
+have one column for each dimension and aggregate. The type of the columns is
+determined in the same way as for those of normal entity types.
+
 ## Indexing
 
 We do not know ahead of time which queries will be issued and therefore
@@ -79,17 +95,17 @@ are open issues at this time.
 
 We generate the following indexes for each table:
 
-* for mutable entity types
-  * an exclusion index over `(id, block_range)` that ensures that the
+- for mutable entity types
+  - an exclusion index over `(id, block_range)` that ensures that the
     versions for the same entity `id` have disjoint block ranges
-  * a BRIN index on `(lower(block_range), COALESCE(upper(block_range),
-    2147483647), vid)` that helps speed up some operations, especially
+  - a BRIN index on `(lower(block_range), COALESCE(upper(block_range),
+2147483647), vid)` that helps speed up some operations, especially
     reversion, in tables that have good data locality, for example, tables
     where entities are never updated or deleted
-* for immutable entity types
-  * a unique index on `id`
-  * a BRIN index on `(block$, vid)`
-* for each attribute, an index called `attr_N_M_..` where `N` is the number
+- for immutable and timeseries entity types
+  - a unique index on `id`
+  - a BRIN index on `(block$, vid)`
+- for each attribute, an index called `attr_N_M_..` where `N` is the number
   of the entity type in the GraphQL schema, and `M` is the number of the
   attribute within that type. For attributes of a primitive type, the index
   is a BTree index. For attributes that reference other entities, the index
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/metrics.md b/docs/metrics.md
index 7a545b1469a..61c223f8256 100644
--- a/docs/metrics.md
+++ b/docs/metrics.md
@@ -27,7 +27,7 @@ Track the **last reverted block** for a subgraph deployment
 - `deployment_sync_secs`
 total **time spent syncing**
 - `deployment_transact_block_operations_duration`
-Measures **duration of commiting all the entity operations** in a block and **updating the subgraph pointer**
+Measures **duration of committing all the entity operations** in a block and **updating the subgraph pointer**
 - `deployment_trigger_processing_duration`
 Measures **duration of trigger processing** for a subgraph deployment
 - `eth_rpc_errors`
@@ -57,6 +57,9 @@ the **maximum size of a query result** (in CacheWeight)
 the **size of the result of successful GraphQL queries** (in CacheWeight)
 - `query_semaphore_wait_ms`
 Moving **average of time spent on waiting for postgres query semaphore**
+- `query_blocks_behind`
+A histogram for how many blocks behind the subgraph head queries are being made at.
+This helps inform pruning decisions.
 - `query_kill_rate`
 The rate at which the load manager kills queries
 - `registered_metrics`
@@ -66,4 +69,4 @@ The **number of Postgres connections** currently **checked out**
 - `store_connection_error_count`
 The **number of Postgres connections errors**
 - `store_connection_wait_time_ms`
-**Average connection wait time**
+**Average connection wait time**
\ No newline at end of file
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/sharding.md b/docs/sharding.md
new file mode 100644
index 00000000000..de2015be22a
--- /dev/null
+++ b/docs/sharding.md
@@ -0,0 +1,158 @@
+# Sharding
+
+When a `graph-node` installation grows beyond what a single Postgres
+instance can handle, it is possible to scale the system horizontally by
+adding more Postgres instances. This is called _sharding_ and each Postgres
+instance is called a _shard_. The resulting `graph-node` system uses all
+these Postgres instances together, essentially forming a distributed
+database. Sharding relies heavily on the fact that in almost all cases the
+traffic for a single subgraph can be handled by a single Postgres instance,
+and load can be distributed by storing different subgraphs in different
+shards.
+
+In a sharded setup, one shard is special, and is called the _primary_. The
+primary is used to store system-wide metadata such as the mapping of
+subgraph names to IPFS hashes, a directory of all subgraphs and the shards
+in which each is stored, or the list of configured chains. In general,
+metadata that rarely changes is stored in the primary whereas metadata that
+changes frequently such as the subgraph head pointer is stored in the
+shards. The details of which metadata tables are stored where can be found
+in [this document](./implementation/metadata.md).
+
+## Setting up
+
+Sharding requires that `graph-node` uses a [configuration file](./config.md)
+rather than the older mechanism of configuring `graph-node` entirely with
+environment variables. It is configured by adding additional
+`[store.<name>]` entries to `graph-node.toml` as described
+[here](./config.md#configuring-multiple-databases)
+
+In a sharded setup, shards communicate with each other using the
+[`postgres_fdw`](https://www.postgresql.org/docs/current/postgres-fdw.html)
+extension. `graph-node` sets up the required foreign servers and foreign
+tables to achieve this. It uses the connection information from the
+configuration file for that which requires that the `connection` string for
+each shard is in the form `postgres://USER:PASSWORD@HOST[:PORT]/DB` since
+`graph-node` needs to parse the connection string to extract these
+components.
+
+Before setting up sharding, it is important to make sure that the shards can
+talk to each other. That requires in particular that firewall rules allow
+traffic from each shard to each other shard, and that authentication
+configuration like `pg_hba.conf` allows connections from all the other
+shards using the target shard's credentials.
+
+When a new shard is added to the configuration file, `graph-node` will
+initialize the database schema of that shard during startup. Once the schema
+has been initialized, it is possible to manually check inter-shard
+connectivity by running `select count(*) from primary_public.chains;` and
+`select count(*) from shard_<name>_subgraphs.subgraph` --- the result of
+these queries doesn't matter, it only matters that they succeed.
+
+With multiple shards, `graph-node` will periodically copy some metadata from
+the primary to all the other shards. The metadata that gets copied is the
+metadata that is needed to respond to queries as each query needs the
+primary to find the shard that stores the subgraph's data. The copies of the
+metadata are used when the primary is down to ensure that queries can still
+be answered.
+
+## Best practices
+
+Usually, a `graph-node` installation starts out with a single shard. When a
+new shard is added, the original shard, which is now called the _primary_,
+can still be used in the same way it was used before, and existing subgraphs
+and block caches can remain in the primary.
+
+Data can be added to new shards by setting up [deployment
+rules](./config.md#controlling-deployment) that send certain subgraphs to
+the new shard. It is also possible to store the block cache for new chains
+in a new shard by setting the `shard` attribute of the [chain
+definition](./config.md#configuring-ethereum-providers)
+
+With shards, there are many possibilities how data can be split between
+them. One possible setup is:
+
+- a small primary that mostly stores metadata
+- multiple shards for low-traffic subgraphs with a large number of subgraphs
+  per shard
+- one or a small number of shards for high-traffic subgraphs with a small
+  number of subgraphs per shard
+- one or more dedicated shards that store only block caches
+
+## Copying between shards
+
+Besides deployment rules for new subgraphs, it is also possible to copy and
+move subgraphs between shards. The command `graphman copy create` starts the
+process of copying a subgraph from one shard to another. It is possible to
+have a copy of the same deployment, identified by an IPFS hash, in multiple
+shards, but only one copy can exist in each shard. If a deployment has
+multiple copies, exactly one of them is marked as `active` and is the one
+that is used to respond to queries. The copies are indexed independently
+from each other, according to how they are assigned to index nodes.
+
+By default, `graphman copy create` will copy the data of the source subgraph
+up to the point where the copy was initiated and then start indexing the
+subgraph independently from its source. When the `--activate` flag is passed
+to `graphman copy create`, the copy process will mark the copy as `active`
+once copying has finished and the copy has caught up to the chain head. When
+the `--replace` flag is passed, the copy process will also mark the source
+of the copy as unused, so that the unused deployment reaper built into
+`graph-node` will eventually delete it. In the default configuration, the
+source will be deleted about 8 hours after the copy has synced to the chain
+head.
+
+When a subgraph has multiple copies, copies that are not `active` can be
+made eligible for deletion by simply unassigning them. The unused deployment
+reaper will eventually delete them.
+
+Copying a deployment can, depending on the size of the deployment, take a
+long time. The command `graphman copy stats sgdDEST` can be used to check on
+the progress of the copy. Copying also periodically logs progress messages.
+After the data has been copied, the copy process has to perform a few
+operations that can take a very long time with not much output. In
+particular, it has to count all the entities in a subgraph to update the
+`entity_count` of the copy.
+
+During copying, `graph-node` creates a namespace in the destination shard
+that has the same `sgdNNN` identifier as the deployment in the source shard
+and maps all tables from the source into the destination shard. That
+namespace in the destination will be automatically deleted when the copy
+finishes.
+
+The command `graphman copy list` can be used to list all currently active or
+pending copy operations. The number of active copy operations is restricted
+to 5 for each source shard/destination shard pair to limit the amount of
+load that copying can put on the shards.
+
+## Namespaces
+
+Sharding creates a few namespaces ('schemas') within Postgres which are used
+to import data from one shard into another. These namespaces are:
+
+- `primary_public`: maps some important tables from the primary into each shard
+- `shard_<name>_subgraphs`: maps some important tables from each shard into
+  every other shard
+
+The code that sets up these mappings is in `ForeignServer::map_primary` and
+`ForeignServer::map_metadata`
+[here](https://github.com/graphprotocol/graph-node/blob/master/store/postgres/src/connection_pool.rs)
+
+The mappings can be rebuilt by running `graphman database remap`.
+
+The split of metadata between the primary and the shards currently poses
+some issues for dashboarding data that requires information from both the
+primary and a shard. That will be improved in a future release.
+
+## Removing a shard
+
+When a shard is no longer needed, it can be removed from the configuration.
+This requires that nothing references that shard anymore. In particular that
+means that there is no deployment that is still stored in that shard, and
+that no chain is stored in it. If these two conditions are met, removing a
+shard is as simple as deleting its declaration from the configuration file.
+
+Removing a shard in this way will leave the foreign tables in
+`shard_<name>_subgraphs`, the user mapping and foreign server definition in
+all the other shards behind. Those will not hamper the operation of
+`graph-node` but can be removed by running the corresponding `DROP` commands
+via `psql`.
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 14b47b059dc..caad7943e84 100644
--- a/docs/subgraph-manifest.md
+++ b/docs/subgraph-manifest.md
@@ -34,7 +34,7 @@ Any data format that has a well-defined 1:1 mapping with the [IPLD Canonical For
 | --- | --- | --- |
 | **kind** | *String | The type of data source. Possible values: *ethereum/contract*.|
 | **name** | *String* | The name of the source data. Will be used to generate APIs in the mapping and also for self-documentation purposes. |
-| **network** | *String* | For blockchains, this describes which network the subgraph targets. For Ethereum, this can be any of "mainnet", "rinkeby", "kovan", "ropsten", "goerli", "poa-core", "poa-sokol", "xdai", "matic", "mumbai", "fantom", "bsc" or "clover". Developers could look for an up to date list in the graph-cli [*code*](https://github.com/graphprotocol/graph-cli/blob/main/packages/cli/src/protocols/index.js#L70-L107).|
+| **network** | *String* | For blockchains, this describes which network the subgraph targets. For Ethereum, this can be any of "mainnet", "rinkeby", "kovan", "ropsten", "goerli", "poa-core", "poa-sokol", "xdai", "matic", "mumbai", "fantom", "bsc" or "clover". Developers could look for an up to date list in the graph-cli [*code*](https://github.com/graphprotocol/graph-tooling/blob/main/packages/cli/src/protocols/index.ts#L76-L117).|
 | **source** | [*EthereumContractSource*](#151-ethereumcontractsource) | The source data on a blockchain such as Ethereum. |
 | **mapping** | [*Mapping*](#152-mapping) | The transformation logic applied to the data prior to being indexed. |
 
@@ -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 3a5e01d6004..13364f1a9fd 100644
--- a/graph/Cargo.toml
+++ b/graph/Cargo.toml
@@ -4,71 +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.9"
-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.10.1"
-diesel = { version = "1.4.8", features = ["postgres", "serde_json", "numeric", "r2d2", "chrono"] }
-diesel_derives = "1.4"
-chrono = "0.4.23"
-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.2", 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"
-lazy_static = "1.4.0"
-num-bigint = { version = "^0.2.6", features = ["serde"] }
-num_cpus = "1.15.0"
-num-traits = "0.2.15"
-rand = "0.8.4"
-regex = "1.5.4"
-semver = { version = "1.0.16", features = ["serde"] }
-serde = { version = "1.0.126", features = ["rc"] }
-serde_derive = "1.0.125"
-serde_json = { version = "1.0", features = ["arbitrary_precision"] }
-serde_yaml = "0.8"
-slog = { version = "2.7.0", features = ["release_max_level_trace", "max_level_trace"] }
-stable-hash_legacy = { version = "0.3.3", package = "stable-hash" }
-stable-hash = { version = "0.4.2" }
-strum = "0.21.0"
-strum_macros = "0.21.1"
+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", 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.3"
-tiny-keccak = "1.5.0"
-tokio = { version = "1.16.1", features = ["time", "sync", "macros", "test-util", "rt-multi-thread", "parking_lot"] }
-tokio-stream = { version = "0.1.12", features = ["sync"] }
-tokio-retry = "0.3.0"
-url = "2.3.1"
-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.10.5"
+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.1"
+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]
-test-store = { path = "../store/test-store" }
-clap = { version = "3.2.23", features = ["derive", "env"] }
+clap.workspace = true
 maplit = "1.0.2"
+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 14399c784c1..184e22dc7e1 100644
--- a/graph/build.rs
+++ b/graph/build.rs
@@ -1,21 +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)");
 }
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 18c557f45c6..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,16 +239,12 @@ 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,
         };
-        BigInt::from(3u64).pow(size as u8) * BigInt::from(f)
+        BigInt::from(3u64).pow(size as u8).unwrap() * BigInt::from(f)
     }
 
     fn sample(&self, size: usize, rng: Option<&mut SmallRng>) -> Box<Self> {
@@ -261,20 +256,16 @@ 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) * BigInt::from(f);
+        let bi = BigInt::from(3u64).pow(size as u8).unwrap() * BigInt::from(f);
         BigDecimal::new(bi, exp)
     }
 
@@ -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 {
@@ -324,15 +315,22 @@ fn make_object(size: usize, mut rng: Option<&mut SmallRng>) -> Object {
             7 => {
                 let mut obj = Vec::new();
                 for j in 0..(i % 51) {
-                    obj.push((format!("key{}", j), r::Value::String(format!("value{}", j))));
+                    obj.push((
+                        Word::from(format!("key{}", j)),
+                        r::Value::String(format!("value{}", j)),
+                    ));
                 }
                 r::Value::Object(Object::from_iter(obj))
             }
             _ => unreachable!(),
         };
 
-        let key = rng.as_deref_mut().map(|rng| rng.gen()).unwrap_or(i) % modulus;
-        obj.push((format!("val{}", key), value));
+        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)
 }
@@ -346,7 +344,7 @@ fn make_domains(size: usize, _rng: Option<&mut SmallRng>) -> Object {
     };
 
     let domains: Vec<_> = (0..size).map(|_| owner.clone()).collect();
-    Object::from_iter([("domains".to_string(), r::Value::List(domains))])
+    Object::from_iter([("domains".into(), r::Value::List(domains))])
 }
 
 /// Template for testing caching of `Object`
@@ -362,7 +360,7 @@ impl Template for Object {
             Box::new(Object::from_iter(
                 self.iter()
                     .take(size)
-                    .map(|(k, v)| (k.to_owned(), v.clone())),
+                    .map(|(k, v)| (Word::from(k), v.clone())),
             ))
         } else {
             Box::new(make_object(size, rng))
@@ -385,7 +383,7 @@ impl Template for QueryResult {
                     .unwrap()
                     .iter()
                     .take(size)
-                    .map(|(k, v)| (k.to_owned(), v.clone())),
+                    .map(|(k, v)| (Word::from(k), v.clone())),
             )))
         } else {
             Box::new(QueryResult::new(make_domains(size, rng)))
@@ -403,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 {
@@ -428,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)
@@ -463,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)
@@ -551,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),
     };
 
@@ -621,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));
@@ -635,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);
         }
     }
@@ -672,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
new file mode 100644
index 00000000000..87888ef155b
--- /dev/null
+++ b/graph/examples/validate.rs
@@ -0,0 +1,315 @@
+/// Validate subgraph schemas by parsing them into `InputSchema` and making
+/// sure that they are valid
+///
+/// The input files must be in a particular format; that can be generated by
+/// running this script against graph-node shard(s). Before running it,
+/// change the `dbs` variable to list all databases against which it should
+/// run.
+///
+/// ```
+/// #! /bin/bash
+///
+/// read -r -d '' query <<EOF
+/// \copy (select to_jsonb(a.*) from (select id, schema from subgraphs.subgraph_manifest) a) to '%s'
+/// EOF
+///
+/// dbs="shard1 shard2 .."
+///
+/// dir=/var/tmp/schemas
+/// mkdir -p $dir
+///
+/// for db in $dbs
+/// do
+///     echo "Dump $db"
+///     q=$(printf "$query" "$dir/$db.json")
+///     psql -qXt service=$db -c "$q"
+///     sed -r -i -e 's/\\\\/\\/g' "$dir/$db.json"
+/// done
+///
+/// ```
+use clap::Parser;
+
+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::DeploymentHash;
+use graph::prelude::s;
+use graph::schema::InputSchema;
+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);
+    println!("usage: validate schema.graphql ...");
+    println!("\nValidate subgraph schemas");
+    std::process::exit(1);
+}
+
+pub fn ensure<T, E: std::fmt::Display>(res: Result<T, E>, msg: &str) -> T {
+    match res {
+        Ok(ok) => ok,
+        Err(err) => {
+            eprintln!("{}:\n    {}", msg, err);
+            exit(1)
+        }
+    }
+}
+
+fn subgraph_id(schema: &s::Document) -> DeploymentHash {
+    let id = schema
+        .get_object_type_definitions()
+        .first()
+        .and_then(|obj_type| obj_type.find_directive("subgraphId"))
+        .and_then(|dir| dir.argument("id"))
+        .and_then(|arg| match arg {
+            s::Value::String(s) => Some(s.to_owned()),
+            _ => None,
+        })
+        .unwrap_or("unknown".to_string());
+    DeploymentHash::new(id).expect("subgraph id is not a valid deployment hash")
+}
+
+#[derive(Deserialize)]
+struct Entry {
+    id: i32,
+    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",
+    version = env!("CARGO_PKG_VERSION"),
+    author = env!("CARGO_PKG_AUTHORS"),
+    about = "Validate subgraph schemas"
+)]
+struct Opts {
+    /// Validate a batch of schemas in bulk. When this is set, the input
+    /// files must be JSONL files where each line has an `id` and a `schema`
+    #[clap(short, long)]
+    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) -> 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) => {
+            bail!("InputSchema: {}[{}]: {}", name, id, e);
+        }
+    };
+    if api {
+        let _api_schema = match input_schema.api_schema() {
+            Ok(schema) => schema,
+            Err(e) => {
+                bail!("ApiSchema: {}[{}]: {}", name, id, e);
+            }
+        };
+    }
+    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
+    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 {
+            eprintln!("Validating schemas from {schema}");
+            let file = File::open(schema).expect("file exists");
+            let rdr = BufReader::new(file);
+            for line in rdr.lines() {
+                let line = line.expect("invalid line").replace("\\\\", "\\");
+                let entry = serde_json::from_str::<Entry>(&line).expect("line is valid json");
+
+                let raw = &entry.schema;
+                let name = format!("sgd{}", entry.id);
+                runner.run(raw, &name, opt.api);
+            }
+        }
+    } else {
+        for schema in &opt.schemas {
+            eprintln!("Validating schema from {schema}");
+            let raw = std::fs::read_to_string(schema).expect("file exists");
+            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.proto b/graph/proto/substreams.proto
deleted file mode 100644
index e860e3bfdb1..00000000000
--- a/graph/proto/substreams.proto
+++ /dev/null
@@ -1,312 +0,0 @@
-// File generated using this command at the root of `graph-node` project
-// and assuming `substreams` repository is a sibling of `graph-node` (note that you
-// might need to adjust the `head -nN` and `skip N` values in the commands below to skip
-// more/less lines):
-//
-// ```
-// cat graph/proto/substreams.proto | head -n16 > /tmp/substreams.proto && mv /tmp/substreams.proto graph/proto/substreams.proto
-// cat ../substreams/proto/sf/substreams/v1/substreams.proto | grep -Ev 'import *"sf/substreams' >> graph/proto/substreams.proto
-// cat ../substreams/proto/sf/substreams/v1/modules.proto | skip 6 >> graph/proto/substreams.proto
-// cat ../substreams/proto/sf/substreams/v1/package.proto | skip 9 >> graph/proto/substreams.proto
-// cat ../substreams/proto/sf/substreams/v1/clock.proto | skip 7 >> graph/proto/substreams.proto
-// # Manually add line `import "google/protobuf/descriptor.proto";` below `import "google/protobuf/timestamp.proto";`
-// ```
-//
-// FIXME: We copy over and inline most of the substreams files, this is bad and we need a better way to
-// generate that, outside of doing this copying over.
-syntax = "proto3";
-
-package sf.substreams.v1;
-option go_package = "github.com/streamingfast/substreams/pb/sf/substreams/v1;pbsubstreams";
-
-import "google/protobuf/any.proto";
-import "google/protobuf/timestamp.proto";
-import "google/protobuf/descriptor.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;
-  repeated ForkStep fork_steps = 4;
-  string irreversibility_condition = 5;
-
-  // By default, the engine runs in developer mode, with richer and deeper output,
-  // * support for multiple `output_modules`, of `store` and `map` kinds
-  // * support for `initial_store_snapshot_for_modules`
-  // * log outputs for output modules
-  //
-  // With `production_mode`, however, you trade off functionality for high speed, where it:
-  // * restricts the possible requested `output_modules` to a single mapper module,
-  // * turns off support for `initial_store_snapshot_for_modules`,
-  // * still streams output linearly, with a cursor, but at higher speeds
-  // * and purges log outputs from responses.
-  bool production_mode = 9;
-
-  Modules modules = 6;
-  repeated string output_modules = 7;
-  repeated string initial_store_snapshot_for_modules = 8;
-}
-
-message Response {
-  oneof message {
-    SessionInit session = 5; // Always sent first
-    ModulesProgress progress = 1; // Progress of data preparation, before sending in the stream of `data` events.
-    InitialSnapshotData snapshot_data = 2;
-    InitialSnapshotComplete snapshot_complete = 3;
-    BlockScopedData data = 4;
-  }
-}
-
-enum ForkStep {
-  STEP_UNKNOWN = 0;
-  // Block is new head block of the chain, that is linear with the previous block
-  STEP_NEW = 1;
-  // Block is now forked and should be undone, it's not the head block of the chain anymore
-  STEP_UNDO = 2;
-  // Removed, was STEP_REDO
-  reserved 3;
-  // Block is now irreversible and can be committed to (finality is chain specific, see chain documentation for more details)
-  STEP_IRREVERSIBLE = 4;
-  // Removed, was STEP_STALLED
-  reserved 5;
-}
-
-message SessionInit  {
-  string trace_id = 1;
-}
-
-message InitialSnapshotComplete {
-  string cursor = 1;
-}
-
-message InitialSnapshotData {
-  string module_name = 1;
-  StoreDeltas deltas = 2;
-  uint64 sent_keys = 4;
-  uint64 total_keys = 3;
-}
-
-message BlockScopedData {
-  repeated ModuleOutput outputs = 1;
-  Clock clock = 3;
-  ForkStep step = 6;
-  string cursor = 10;
-}
-
-message ModuleOutput {
-  string name = 1;
-
-  oneof data {
-    google.protobuf.Any map_output = 2;
-
-    // StoreDeltas 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.
-    StoreDeltas debug_store_deltas = 3;
-  }
-  repeated string debug_logs = 4;
-  // 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 debug_logs_truncated = 5;
-
-  bool cached = 6;
-}
-
-// think about:
-// message ModuleOutput { ...
-//   ModuleOutputDebug debug_info = 6;
-// ...}
-//message ModuleOutputDebug {
-//  StoreDeltas store_deltas = 3;
-//  repeated string logs = 4;
-//  // 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 = 5;
-//}
-
-message ModulesProgress {
-  repeated ModuleProgress modules = 1;
-}
-
-message ModuleProgress {
-  string name = 1;
-
-  oneof type {
-    ProcessedRange processed_ranges = 2;
-    InitialState initial_state = 3;
-    ProcessedBytes processed_bytes = 4;
-    Failed failed = 5;
-  }
-
-  message ProcessedRange {
-    repeated BlockRange processed_ranges = 1;
-  }
-  message InitialState {
-    uint64 available_up_to_block = 2;
-  }
-  message ProcessedBytes {
-    uint64 total_bytes_read = 1;
-    uint64 total_bytes_written = 2;
-  }
-  message Failed {
-    string reason = 1;
-    repeated string logs = 2;
-    // 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 = 3;
-  }
-}
-
-message BlockRange {
-  uint64 start_block = 2;
-  uint64 end_block = 3;
-}
-
-message StoreDeltas {
-  repeated StoreDelta deltas = 1;
-}
-
-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 Output {
-  uint64 block_num = 1;
-  string block_id = 2;
-  google.protobuf.Timestamp timestamp = 4;
-  google.protobuf.Any value = 10;
-}
-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;
-    }
-
-    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 Output {
-    string type = 1;
-  }
-}
-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; // In case protosets add a field some day.
-  reserved 3; // In case protosets add a field some day.
-  reserved 4; // In case protosets add a field some day.
-
-  uint64 version = 5;
-  sf.substreams.v1.Modules modules = 6;
-  repeated ModuleMetadata module_meta = 7;
-  repeated PackageMetadata package_meta = 8;
-}
-
-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 Clock {
-  string id = 1;
-  uint64 number = 2;
-  google.protobuf.Timestamp timestamp = 3;
-}
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 90cfedce5d6..8098cfea664 100644
--- a/graph/src/blockchain/block_stream.rs
+++ b/graph/src/blockchain/block_stream.rs
@@ -1,35 +1,44 @@
+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 std::collections::{BTreeMap, BTreeSet, HashMap};
 use std::fmt;
 use std::sync::Arc;
 use thiserror::Error;
 use tokio::sync::mpsc::{self, Receiver, Sender};
 
-use super::{Block, BlockPtr, 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::substreams::BlockScopedData;
+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 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> {
     pub fn spawn_from_stream(
-        stream: Box<dyn BlockStream<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 {
@@ -48,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 {
@@ -57,7 +66,7 @@ impl<C: Blockchain + 'static> BufferedBlockStream<C> {
                     return Err(anyhow!(
                         "buffered blockstream channel is closed, stopping. Err: {}",
                         err
-                    ))
+                    ));
                 }
             }
         }
@@ -66,10 +75,14 @@ impl<C: Blockchain + 'static> BufferedBlockStream<C> {
     }
 }
 
-impl<C: Blockchain> BlockStream<C> for BufferedBlockStream<C> {}
+impl<C: Blockchain> BlockStream<C> for BufferedBlockStream<C> {
+    fn buffer_size_hint(&self) -> usize {
+        unreachable!()
+    }
+}
 
 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>,
@@ -80,8 +93,9 @@ 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;
 }
 
 /// BlockRefetcher abstraction allows a chain to decide if a block must be refetched after a dynamic data source was added
@@ -113,13 +127,36 @@ pub trait BlockStreamBuilder<C: Blockchain>: Send + Sync {
 
     async fn build_polling(
         &self,
-        chain: Arc<C>,
+        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>>>;
+
+    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<TriggerFilterWrapper<C>>,
+        unified_api_version: UnifiedMappingApiVersion,
+    ) -> 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)]
@@ -170,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>
@@ -188,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();
 
@@ -228,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.
@@ -253,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(
@@ -269,16 +616,25 @@ 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]
 pub trait FirehoseMapper<C: Blockchain>: Send + Sync {
+    fn trigger_filter(&self) -> &C::TriggerFilter;
+
     async fn to_block_stream_event(
         &self,
         logger: &Logger,
         response: &firehose::Response,
-        adapter: &Arc<dyn TriggersAdapter<C>>,
-        filter: &C::TriggerFilter,
     ) -> Result<BlockStreamEvent<C>, FirehoseError>;
 
     /// Returns the [BlockPtr] value for this given block number. This is the block pointer
@@ -313,14 +669,14 @@ pub trait FirehoseMapper<C: Blockchain>: Send + Sync {
 }
 
 #[async_trait]
-pub trait SubstreamsMapper<C: Blockchain>: Send + Sync {
-    async fn to_block_stream_event(
+pub trait BlockStreamMapper<C: Blockchain>: Send + Sync {
+    fn decode_block(&self, output: Option<&[u8]>) -> Result<Option<C::Block>, BlockStreamError>;
+
+    async fn block_with_triggers(
         &self,
         logger: &Logger,
-        response: &BlockScopedData,
-        // adapter: &Arc<dyn TriggersAdapter<C>>,
-        // filter: &C::TriggerFilter,
-    ) -> Result<Option<BlockStreamEvent<C>>, SubstreamsError>;
+        block: C::Block,
+    ) -> Result<BlockWithTriggers<C>, BlockStreamError>;
 }
 
 #[derive(Error, Debug)]
@@ -334,26 +690,21 @@ pub enum FirehoseError {
     UnknownError(#[from] anyhow::Error),
 }
 
-#[derive(Error, Debug)]
-pub enum SubstreamsError {
-    #[error("response is missing the clock information")]
-    MissingClockError,
-    /// 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)]
@@ -364,29 +715,16 @@ pub enum BlockStreamEvent<C: Blockchain> {
     ProcessBlock(BlockWithTriggers<C>, 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()),
-        }
-    }
-}
-
 #[derive(Clone)]
 pub struct BlockStreamMetrics {
     pub deployment_head: Box<Gauge>,
-    pub deployment_failed: Box<Gauge>,
     pub reverted_blocks: Gauge,
     pub stopwatch: StopwatchMetrics,
 }
 
 impl BlockStreamMetrics {
     pub fn new(
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
         deployment_id: &DeploymentHash,
         network: String,
         shard: String,
@@ -407,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,
         }
@@ -442,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::{
@@ -451,7 +780,8 @@ mod test {
     };
 
     use super::{
-        BlockStream, BlockStreamEvent, BlockWithTriggers, BufferedBlockStream, FirehoseCursor,
+        BlockStream, BlockStreamError, BlockStreamEvent, BlockWithTriggers, BufferedBlockStream,
+        FirehoseCursor,
     };
 
     #[derive(Debug)]
@@ -459,10 +789,14 @@ mod test {
         number: u64,
     }
 
-    impl BlockStream<MockBlockchain> for TestStream {}
+    impl BlockStream<MockBlockchain> for TestStream {
+        fn buffer_size_hint(&self) -> usize {
+            1
+        }
+    }
 
     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>,
@@ -481,7 +815,7 @@ mod test {
         }
     }
 
-    #[tokio::test]
+    #[crate::test]
     async fn consume_stream() {
         let initial_block = 100;
         let buffer_size = 5;
@@ -491,9 +825,9 @@ mod test {
         });
         let guard = SharedCancelGuard::new();
 
-        let mut stream = BufferedBlockStream::spawn_from_stream(stream, buffer_size)
+        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/client.rs b/graph/src/blockchain/client.rs
index 5820921b2b8..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.random().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.random(),
+            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 331c1ff330f..1a0ff0f2c06 100644
--- a/graph/src/blockchain/firehose_block_ingestor.rs
+++ b/graph/src/blockchain/firehose_block_ingestor.rs
@@ -2,18 +2,22 @@ use std::{marker::PhantomData, sync::Arc, time::Duration};
 
 use crate::{
     blockchain::Block as BlockchainBlock,
-    components::store::ChainStore,
-    firehose::{self, decode_firehose_block, FirehoseEndpoint, 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};
+use async_trait::async_trait;
 use futures03::StreamExt;
 use prost::Message;
 use prost_types::Any;
-use slog::trace;
+use slog::{o, trace};
 use tonic::Streaming;
 
+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";
 
@@ -32,33 +36,36 @@ impl From<&Transforms> for Any {
     }
 }
 
-pub struct FirehoseBlockIngestor<M>
+pub struct FirehoseBlockIngestor<M, C: Blockchain>
 where
     M: prost::Message + BlockchainBlock + Default + 'static,
 {
-    chain_store: Arc<dyn ChainStore>,
-    endpoint: Arc<FirehoseEndpoint>,
+    chain_head_store: Arc<dyn ChainHeadStore>,
+    client: Arc<ChainClient<C>>,
     logger: Logger,
     default_transforms: Vec<Transforms>,
+    chain_name: ChainName,
 
     phantom: PhantomData<M>,
 }
 
-impl<M> FirehoseBlockIngestor<M>
+impl<M, C: Blockchain> FirehoseBlockIngestor<M, C>
 where
     M: prost::Message + BlockchainBlock + Default + 'static,
 {
     pub fn new(
-        chain_store: Arc<dyn ChainStore>,
-        endpoint: Arc<FirehoseEndpoint>,
+        chain_head_store: Arc<dyn ChainHeadStore>,
+        client: Arc<ChainClient<C>>,
         logger: Logger,
-    ) -> FirehoseBlockIngestor<M> {
+        chain_name: ChainName,
+    ) -> FirehoseBlockIngestor<M, C> {
         FirehoseBlockIngestor {
-            chain_store,
-            endpoint,
+            chain_head_store,
+            client,
             logger,
             phantom: PhantomData {},
             default_transforms: vec![],
+            chain_name,
         }
     }
 
@@ -67,52 +74,11 @@ where
         self
     }
 
-    pub async fn run(self) {
-        let mut latest_cursor = self.fetch_head_cursor().await;
-        let mut backoff =
-            ExponentialBackoff::new(Duration::from_millis(250), Duration::from_secs(30));
-
-        loop {
-            info!(
-                self.logger,
-                "Blockstream disconnected, connecting"; "endpoint uri" => format_args!("{}", self.endpoint), "cursor" => format_args!("{}", latest_cursor),
-            );
-
-            let result = self
-                .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()
-                })
-                .await;
-
-            match result {
-                Ok(stream) => {
-                    info!(self.logger, "Blockstream connected, consuming blocks");
-
-                    // Consume the stream of blocks until an error is hit
-                    latest_cursor = self.process_blocks(latest_cursor, stream).await
-                }
-                Err(e) => {
-                    error!(self.logger, "Unable to connect to endpoint: {:#}", e);
-                }
-            }
-
-            // If we reach this point, we must wait a bit before retrying
-            backoff.sleep_async().await;
-        }
-    }
-
     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() {
+            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);
@@ -139,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 {
@@ -183,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
@@ -192,3 +158,80 @@ where
         Ok(())
     }
 }
+
+#[async_trait]
+impl<M, C: Blockchain> BlockIngestor for FirehoseBlockIngestor<M, C>
+where
+    M: prost::Message + BlockchainBlock + Default + 'static,
+{
+    async fn run(self: Box<Self>) {
+        let mut latest_cursor = self.fetch_head_cursor().await;
+        let mut backoff =
+            ExponentialBackoff::new(Duration::from_millis(250), Duration::from_secs(30));
+
+        loop {
+            let endpoint = match self.client.firehose_endpoint().await {
+                Ok(endpoint) => endpoint,
+                Err(err) => {
+                    error!(
+                        self.logger,
+                        "Unable to get a connection for block ingestor, err: {}", err
+                    );
+                    backoff.sleep_async().await;
+                    continue;
+                }
+            };
+
+            let logger = self.logger.new(
+                o!("provider" => endpoint.provider.to_string(), "network_name"=> self.network_name().to_string()),
+            );
+
+            info!(
+                logger,
+                "Trying to reconnect the Blockstream after disconnect"; "endpoint uri" => format_args!("{}", endpoint), "cursor" => format_args!("{}", latest_cursor),
+            );
+
+            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()
+                    },
+                    &firehose::ConnectionHeaders::new(),
+                )
+                .await;
+
+            match result {
+                Ok(stream) => {
+                    info!(logger, "Blockstream connected, consuming blocks");
+
+                    // Consume the stream of blocks until an error is hit
+                    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);
+                }
+            }
+
+            // If we reach this point, we must wait a bit before retrying
+            backoff.sleep_async().await;
+        }
+    }
+
+    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 cc60acdb38a..9ad0f2aa6e5 100644
--- a/graph/src/blockchain/firehose_block_stream.rs
+++ b/graph/src/blockchain/firehose_block_stream.rs
@@ -1,7 +1,10 @@
-use super::block_stream::{BlockStream, BlockStreamEvent, FirehoseMapper};
-use super::{Blockchain, TriggersAdapter};
-use crate::blockchain::block_stream::FirehoseCursor;
+use super::Blockchain;
+use super::block_stream::{
+    BlockStream, BlockStreamError, BlockStreamEvent, FIREHOSE_BUFFER_STREAM_SIZE, FirehoseMapper,
+};
+use super::client::ChainClient;
 use crate::blockchain::TriggerFilter;
+use crate::blockchain::block_stream::FirehoseCursor;
 use crate::prelude::*;
 use crate::util::backoff::ExponentialBackoff;
 use crate::{firehose, firehose::FirehoseEndpoint};
@@ -14,7 +17,6 @@ use tonic::Status;
 
 struct FirehoseBlockStreamMetrics {
     deployment: DeploymentHash,
-    provider: String,
     restarts: CounterVec,
     connect_duration: GaugeVec,
     time_between_responses: HistogramVec,
@@ -22,14 +24,9 @@ struct FirehoseBlockStreamMetrics {
 }
 
 impl FirehoseBlockStreamMetrics {
-    pub fn new(
-        registry: Arc<dyn MetricsRegistry>,
-        deployment: DeploymentHash,
-        provider: String,
-    ) -> Self {
+    pub fn new(registry: Arc<MetricsRegistry>, deployment: DeploymentHash) -> Self {
         Self {
             deployment,
-            provider,
 
             restarts: registry
                 .global_counter_vec(
@@ -65,36 +62,36 @@ impl FirehoseBlockStreamMetrics {
         }
     }
 
-    fn observe_successful_connection(&self, time: &mut Instant) {
+    fn observe_successful_connection(&self, time: &mut Instant, provider: &str) {
         self.restarts
-            .with_label_values(&[&self.deployment, &self.provider, "true"])
+            .with_label_values(&[self.deployment.as_str(), provider, "true"])
             .inc();
         self.connect_duration
-            .with_label_values(&[&self.deployment, &self.provider])
+            .with_label_values(&[self.deployment.as_str(), provider])
             .set(time.elapsed().as_secs_f64());
 
         // Reset last connection timestamp
         *time = Instant::now();
     }
 
-    fn observe_failed_connection(&self, time: &mut Instant) {
+    fn observe_failed_connection(&self, time: &mut Instant, provider: &str) {
         self.restarts
-            .with_label_values(&[&self.deployment, &self.provider, "false"])
+            .with_label_values(&[self.deployment.as_str(), provider, "false"])
             .inc();
         self.connect_duration
-            .with_label_values(&[&self.deployment, &self.provider])
+            .with_label_values(&[self.deployment.as_str(), provider])
             .set(time.elapsed().as_secs_f64());
 
         // Reset last connection timestamp
         *time = Instant::now();
     }
 
-    fn observe_response(&self, kind: &str, time: &mut Instant) {
+    fn observe_response(&self, kind: &str, time: &mut Instant, provider: &str) {
         self.time_between_responses
-            .with_label_values(&[&self.deployment, &self.provider])
+            .with_label_values(&[self.deployment.as_str(), provider])
             .observe(time.elapsed().as_secs_f64());
         self.responses
-            .with_label_values(&[&self.deployment, &self.provider, kind])
+            .with_label_values(&[self.deployment.as_str(), provider, kind])
             .inc();
 
         // Reset last response timestamp
@@ -103,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>
@@ -112,19 +109,21 @@ where
 {
     pub fn new<F>(
         deployment: DeploymentHash,
-        endpoint: Arc<FirehoseEndpoint>,
+        client: Arc<ChainClient<C>>,
         subgraph_current_block: Option<BlockPtr>,
         cursor: FirehoseCursor,
         mapper: Arc<F>,
-        adapter: Arc<dyn TriggersAdapter<C>>,
-        filter: Arc<C::TriggerFilter>,
         start_blocks: Vec<BlockNumber>,
         logger: Logger,
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
     ) -> Self
     where
         F: FirehoseMapper<C> + 'static,
     {
+        if !client.is_firehose() {
+            unreachable!("Firehose block stream called with rpc endpoint");
+        }
+
         let manifest_start_block_num = start_blocks
             .into_iter()
             .min()
@@ -132,16 +131,13 @@ where
             // start at Genesis block.
             .unwrap_or(0);
 
-        let metrics =
-            FirehoseBlockStreamMetrics::new(registry, deployment, endpoint.provider.clone());
-
+        let metrics = FirehoseBlockStreamMetrics::new(registry, deployment.clone());
         FirehoseBlockStream {
             stream: Box::pin(stream_blocks(
-                endpoint,
+                client,
                 cursor,
+                deployment,
                 mapper,
-                adapter,
-                filter,
                 manifest_start_block_num,
                 subgraph_current_block,
                 logger,
@@ -152,16 +148,15 @@ where
 }
 
 fn stream_blocks<C: Blockchain, F: FirehoseMapper<C>>(
-    endpoint: Arc<FirehoseEndpoint>,
+    client: Arc<ChainClient<C>>,
     mut latest_cursor: FirehoseCursor,
+    deployment: DeploymentHash,
     mapper: Arc<F>,
-    adapter: Arc<dyn TriggersAdapter<C>>,
-    filter: Arc<C::TriggerFilter>,
     manifest_start_block_num: BlockNumber,
     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()
@@ -208,21 +203,28 @@ 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().await?;
+            let logger = logger.new(o!("deployment" => deployment.clone(), "provider" => endpoint.provider.to_string()));
+
             info!(
                 &logger,
                 "Blockstream disconnected, connecting";
                 "endpoint_uri" => format_args!("{}", endpoint),
                 "start_block" => start_block_num,
+                "subgraph" => &deployment,
                 "cursor" => latest_cursor.to_string(),
+                "provider_err_count" => endpoint.current_error_count(),
             );
 
             // We just reconnected, assume that we want to back off on errors
@@ -236,11 +238,11 @@ fn stream_blocks<C: Blockchain, F: FirehoseMapper<C>>(
             };
 
             if endpoint.filters_enabled {
-                request.transforms = filter.as_ref().clone().to_firehose_filter();
+                request.transforms = mapper.trigger_filter().clone().to_firehose_filter();
             }
 
             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 {
@@ -248,7 +250,7 @@ fn stream_blocks<C: Blockchain, F: FirehoseMapper<C>>(
                     info!(&logger, "Blockstream connected");
 
                     // Track the time it takes to set up the block stream
-                    metrics.observe_successful_connection(&mut connect_start);
+                    metrics.observe_successful_connection(&mut connect_start, &endpoint.provider);
 
                     let mut last_response_time = Instant::now();
                     let mut expected_stream_end = false;
@@ -261,15 +263,13 @@ fn stream_blocks<C: Blockchain, F: FirehoseMapper<C>>(
                             manifest_start_block_num,
                             subgraph_current_block.as_ref(),
                             mapper.as_ref(),
-                            &adapter,
-                            &filter,
                             &logger,
                         ).await {
                             Ok(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);
+                                metrics.observe_response("proceed", &mut last_response_time, &endpoint.provider);
 
                                 yield event;
 
@@ -279,7 +279,7 @@ fn stream_blocks<C: Blockchain, F: FirehoseMapper<C>>(
                                 // Reset backoff because we got a good value from the stream
                                 backoff.reset();
 
-                                metrics.observe_response("rewind", &mut last_response_time);
+                                metrics.observe_response("rewind", &mut last_response_time, &endpoint.provider);
 
                                 // It's totally correct to pass the None as the cursor here, if we are here, there
                                 // was no cursor before anyway, so it's totally fine to pass `None`
@@ -306,7 +306,7 @@ fn stream_blocks<C: Blockchain, F: FirehoseMapper<C>>(
                                 // 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);
+                                metrics.observe_response("error", &mut last_response_time, &endpoint.provider);
 
                                 error!(logger, "{:#}", err);
                                 expected_stream_end = true;
@@ -324,7 +324,7 @@ fn stream_blocks<C: Blockchain, F: FirehoseMapper<C>>(
                     // case where we actually _want_ to back off in case we keep
                     // having connection errors.
 
-                    metrics.observe_failed_connection(&mut connect_start);
+                    metrics.observe_failed_connection(&mut connect_start, &endpoint.provider);
 
                     error!(logger, "Unable to connect to endpoint: {:#}", e);
                 }
@@ -350,28 +350,31 @@ async fn process_firehose_response<C: Blockchain, F: FirehoseMapper<C>>(
     manifest_start_block_num: BlockNumber,
     subgraph_current_block: Option<&BlockPtr>,
     mapper: &F,
-    adapter: &Arc<dyn TriggersAdapter<C>>,
-    filter: &C::TriggerFilter,
     logger: &Logger,
 ) -> Result<BlockResponse<C>, Error> {
     let response = result.context("An error occurred while streaming blocks")?;
 
     let event = mapper
-        .to_block_stream_event(logger, &response, adapter, filter)
+        .to_block_stream_event(logger, &response)
         .await
         .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
@@ -380,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.
@@ -410,14 +416,18 @@ 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)
     }
 }
 
-impl<C: Blockchain> BlockStream<C> for FirehoseBlockStream<C> {}
+impl<C: Blockchain> BlockStream<C> for FirehoseBlockStream<C> {
+    fn buffer_size_hint(&self) -> usize {
+        FIREHOSE_BUFFER_STREAM_SIZE
+    }
+}
 
 fn must_check_subgraph_continuity(
     logger: &Logger,
@@ -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 1a66b384265..a87e3da1fc3 100644
--- a/graph/src/blockchain/mock.rs
+++ b/graph/src/blockchain/mock.rs
@@ -1,23 +1,45 @@
 use crate::{
-    components::{link_resolver::LinkResolver, store::BlockNumber},
-    prelude::DataSourceTemplateInfo,
+    bail,
+    components::{
+        ethereum::CachedBlock,
+        link_resolver::LinkResolver,
+        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,
+    },
 };
-use anyhow::Error;
+use alloy::primitives::{B256, U256};
+use anyhow::{Error, Result};
 use async_trait::async_trait;
-use core::fmt;
 use serde::Deserialize;
-use std::{convert::TryFrom, sync::Arc};
+use slog::Logger;
+use std::{
+    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
+    convert::TryFrom,
+    sync::Arc,
+};
 
 use super::{
-    block_stream::{self, FirehoseCursor},
+    BlockIngestor, BlockTime, ChainIdentifier, EmptyNodeCapabilities, ExtendedBlockPtr, HostFn,
+    IngestorError, MappingTriggerTrait, NoopDecoderHook, Trigger, TriggerFilterWrapper,
+    TriggerWithHandler,
+    block_stream::{self, BlockStream, FirehoseCursor},
     client::ChainClient,
-    HostFn, IngestorError, TriggerWithHandler,
 };
 
 use super::{
-    block_stream::BlockWithTriggers, Block, BlockPtr, Blockchain, BlockchainKind, DataSource,
-    DataSourceTemplate, NodeCapabilities, RuntimeAdapter, TriggerData, TriggerFilter,
-    TriggersAdapter, UnresolvedDataSource, UnresolvedDataSourceTemplate,
+    Block, BlockPtr, Blockchain, BlockchainKind, DataSource, DataSourceTemplate, RuntimeAdapter,
+    TriggerData, TriggerFilter, TriggersAdapter, UnresolvedDataSource,
+    UnresolvedDataSourceTemplate, block_stream::BlockWithTriggers,
 };
 
 #[derive(Debug)]
@@ -30,27 +52,55 @@ 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 {
+        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,
     }
 }
 
 #[derive(Clone)]
-pub struct MockDataSource;
+pub struct MockDataSource {
+    pub api_version: semver::Version,
+    pub kind: String,
+    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!()
     }
 
@@ -62,16 +112,30 @@ impl<C: Blockchain> DataSource<C> for MockDataSource {
         todo!()
     }
 
+    fn handler_kinds(&self) -> HashSet<&str> {
+        vec!["mock_handler_1", "mock_handler_2"]
+            .into_iter()
+            .collect()
+    }
+
+    fn has_declared_calls(&self) -> bool {
+        true
+    }
+
+    fn end_block(&self) -> Option<BlockNumber> {
+        todo!()
+    }
+
     fn name(&self) -> &str {
         todo!()
     }
 
     fn kind(&self) -> &str {
-        todo!()
+        self.kind.as_str()
     }
 
     fn network(&self) -> Option<&str> {
-        todo!()
+        self.network.as_deref()
     }
 
     fn context(&self) -> std::sync::Arc<Option<crate::prelude::DataSourceContext>> {
@@ -83,7 +147,7 @@ impl<C: Blockchain> DataSource<C> for MockDataSource {
     }
 
     fn api_version(&self) -> semver::Version {
-        todo!()
+        self.api_version.clone()
     }
 
     fn runtime(&self) -> Option<Arc<Vec<u8>>> {
@@ -108,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!()
     }
 }
@@ -126,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!()
     }
@@ -137,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!()
     }
@@ -153,6 +225,14 @@ impl<C: Blockchain> DataSourceTemplate<C> for MockDataSourceTemplate {
     fn manifest_idx(&self) -> u32 {
         todo!()
     }
+
+    fn kind(&self) -> &str {
+        todo!()
+    }
+
+    fn info(&self) -> DataSourceTemplateInfo {
+        todo!()
+    }
 }
 
 #[derive(Clone, Default, Deserialize)]
@@ -162,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!()
     }
@@ -173,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!()
     }
 
@@ -209,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;
 
@@ -216,11 +342,20 @@ impl TriggerData for MockTriggerData {
     fn error_context(&self) -> String {
         todo!()
     }
+
+    fn address_match(&self) -> Option<&[u8]> {
+        None
+    }
 }
 
 #[derive(Debug)]
 pub struct MockMappingTrigger {}
 
+impl MappingTriggerTrait for MockMappingTrigger {
+    fn error_context(&self) -> String {
+        todo!()
+    }
+}
 #[derive(Clone, Default)]
 pub struct MockTriggerFilter;
 
@@ -245,25 +380,10 @@ impl<C: Blockchain> TriggerFilter<C> for MockTriggerFilter {
     }
 }
 
-#[derive(Debug)]
-pub struct MockNodeCapabilities;
-
-impl fmt::Display for MockNodeCapabilities {
-    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        todo!()
-    }
-}
-
-impl<C: Blockchain> NodeCapabilities<C> for MockNodeCapabilities {
-    fn from_data_sources(_data_sources: &[C::DataSource]) -> Self {
-        todo!()
-    }
-}
-
 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!()
     }
 }
@@ -289,7 +409,9 @@ impl Blockchain for MockBlockchain {
 
     type TriggerFilter = MockTriggerFilter;
 
-    type NodeCapabilities = MockNodeCapabilities;
+    type NodeCapabilities = EmptyNodeCapabilities<Self>;
+
+    type DecoderHook = NoopDecoderHook;
 
     fn triggers_adapter(
         &self,
@@ -300,26 +422,15 @@ impl Blockchain for MockBlockchain {
         todo!()
     }
 
-    async fn new_firehose_block_stream(
-        &self,
-        _deployment: crate::components::store::DeploymentLocator,
-        _block_cursor: FirehoseCursor,
-        _start_blocks: Vec<crate::components::store::BlockNumber>,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: std::sync::Arc<Self::TriggerFilter>,
-        _unified_api_version: crate::data::subgraph::UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn block_stream::BlockStream<Self>>, anyhow::Error> {
-        todo!()
-    }
-
-    async fn new_polling_block_stream(
+    async fn new_block_stream(
         &self,
-        _deployment: crate::components::store::DeploymentLocator,
-        _start_blocks: Vec<crate::components::store::BlockNumber>,
-        _subgraph_current_block: Option<BlockPtr>,
-        _filter: std::sync::Arc<Self::TriggerFilter>,
-        _unified_api_version: crate::data::subgraph::UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn block_stream::BlockStream<Self>>, anyhow::Error> {
+        _deployment: DeploymentLocator,
+        _store: impl DeploymentCursorTracker,
+        _start_blocks: Vec<BlockNumber>,
+        _source_subgraph_stores: Vec<Arc<dyn SourceableStore>>,
+        _filter: Arc<TriggerFilterWrapper<Self>>,
+        _unified_api_version: UnifiedMappingApiVersion,
+    ) -> Result<Box<dyn BlockStream<Self>>, Error> {
         todo!()
     }
 
@@ -335,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!()
     }
 
@@ -347,11 +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!()
     }
+
+    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 8c9f7ff5f74..df942d19910 100644
--- a/graph/src/blockchain/mod.rs
+++ b/graph/src/blockchain/mod.rs
@@ -8,48 +8,62 @@ mod empty_node_capabilities;
 pub mod firehose_block_ingestor;
 pub mod firehose_block_stream;
 pub mod mock;
-pub mod polling_block_stream;
-pub mod substreams_block_stream;
+mod noop_runtime_adapter;
 mod types;
 
 // Try to reexport most of the necessary types
 use crate::{
     cheap_clone::CheapClone,
-    components::store::{DeploymentLocator, StoredDynamicDataSource},
-    data::subgraph::UnifiedMappingApiVersion,
-    data_source,
-    prelude::DataSourceContext,
-    runtime::{gas::GasCounter, AscHeap, HostExportError},
-};
-use crate::{
     components::{
-        store::{BlockNumber, ChainStore},
-        subgraph::DataSourceTemplateInfo,
+        metrics::subgraph::SubgraphInstanceMetrics,
+        store::{
+            DeploymentCursorTracker, DeploymentLocator, SourceableStore, StoredDynamicDataSource,
+        },
+        subgraph::{HostMetrics, InstanceDSTemplateInfo, MappingError},
+        trigger_processor::RunnableTriggers,
     },
-    prelude::{thiserror::Error, LinkResolver},
+    data::subgraph::{MIN_SPEC_VERSION, UnifiedMappingApiVersion},
+    data_source::{self, DataSourceTemplateInfo, subgraph},
+    prelude::{DataSourceContext, DeploymentHash},
+    runtime::{AscHeap, HostExportError, gas::GasCounter},
+};
+use crate::{
+    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;
 use std::{
     any::Any,
-    collections::HashMap,
+    collections::{HashMap, HashSet},
     fmt::{self, Debug},
     str::FromStr,
     sync::Arc,
 };
-use web3::types::H256;
 
 pub use block_stream::{ChainHeadUpdateListener, ChainHeadUpdateStream, TriggersAdapter};
 pub use empty_node_capabilities::EmptyNodeCapabilities;
-pub use types::{BlockHash, BlockPtr, ChainIdentifier};
+pub use noop_runtime_adapter::NoopRuntimeAdapter;
+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) -> ChainName;
+    fn kind(&self) -> BlockchainKind;
+}
 
 pub trait TriggersAdapterSelector<C: Blockchain>: Sync + Send {
     fn triggers_adapter(
@@ -81,6 +95,8 @@ pub trait Block: Send + Sync {
     fn data(&self) -> Result<serde_json::Value, serde_json::Error> {
         Ok(serde_json::Value::Null)
     }
+
+    fn timestamp(&self) -> BlockTime;
 }
 
 #[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
@@ -126,25 +142,17 @@ impl ChainStoreBlock {
     }
 }
 
-// // ChainClient represents the type of client used to ingest data from the chain. For most chains
-// // this will be either firehose or some sort of rpc client.
-// // If a specific chain requires more than one adapter this should be handled by the chain specifically
-// // as it's not common behavior across chains.
-// pub enum ChainClient<C: Blockchain> {
-//     Firehose(FirehoseEndpoints),
-//     Rpc(C::Client),
-// }
-
 #[async_trait]
 // This is only `Debug` because some tests require that
 pub trait Blockchain: Debug + Sized + Send + Sync + Unpin + 'static {
     const KIND: BlockchainKind;
     const ALIASES: &'static [&'static str] = &[];
 
-    type Client: Debug + Default;
+    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;
+
     type DataSource: DataSource<Self>;
     type UnresolvedDataSource: UnresolvedDataSource<Self>;
 
@@ -156,13 +164,18 @@ pub trait Blockchain: Debug + Sized + Send + Sync + Unpin + 'static {
 
     /// Decoded trigger ready to be processed by the mapping.
     /// New implementations should have this be the same as `TriggerData`.
-    type MappingTrigger: Send + Sync + Debug;
+    type MappingTrigger: MappingTriggerTrait + Send + Sync + Debug;
 
     /// Trigger filter used as input to the triggers adapter.
     type TriggerFilter: TriggerFilter<Self>;
 
     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,
@@ -170,26 +183,18 @@ pub trait Blockchain: Debug + Sized + Send + Sync + Unpin + 'static {
         unified_api_version: UnifiedMappingApiVersion,
     ) -> Result<Arc<dyn TriggersAdapter<Self>>, Error>;
 
-    async fn new_firehose_block_stream(
-        &self,
-        deployment: DeploymentLocator,
-        block_cursor: FirehoseCursor,
-        start_blocks: Vec<BlockNumber>,
-        subgraph_current_block: Option<BlockPtr>,
-        filter: Arc<Self::TriggerFilter>,
-        unified_api_version: UnifiedMappingApiVersion,
-    ) -> Result<Box<dyn BlockStream<Self>>, Error>;
-
-    async fn new_polling_block_stream(
+    async fn new_block_stream(
         &self,
         deployment: DeploymentLocator,
+        store: impl DeploymentCursorTracker,
         start_blocks: Vec<BlockNumber>,
-        subgraph_current_block: Option<BlockPtr>,
-        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,
@@ -205,9 +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>>;
+
+    async fn block_ingestor(&self) -> anyhow::Result<Box<dyn BlockIngestor>>;
 }
 
 #[derive(Error, Debug)]
@@ -215,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(),
+        }
     }
 }
 
@@ -252,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,
@@ -261,14 +310,22 @@ pub trait DataSource<C: Blockchain>: 'static + Sized + Send + Sync + Clone {
 
     fn address(&self) -> Option<&[u8]>;
     fn start_block(&self) -> BlockNumber;
+    fn end_block(&self) -> Option<BlockNumber>;
     fn name(&self) -> &str;
     fn kind(&self) -> &str;
     fn network(&self) -> Option<&str>;
     fn context(&self) -> Arc<Option<DataSourceContext>>;
     fn creation_block(&self) -> Option<BlockNumber>;
     fn api_version(&self) -> semver::Version;
+
+    fn min_spec_version(&self) -> semver::Version {
+        MIN_SPEC_VERSION
+    }
+
     fn runtime(&self) -> Option<Arc<Vec<u8>>>;
 
+    fn handler_kinds(&self) -> HashSet<&str>;
+
     /// Checks if `trigger` matches this data source, and if so decodes it into a `MappingTrigger`.
     /// A return of `Ok(None)` mean the trigger does not match.
     ///
@@ -292,7 +349,15 @@ 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().is_some_and(|end_block| block > end_block)
+    }
+
+    fn has_declared_calls(&self) -> bool {
+        false
+    }
 }
 
 #[async_trait]
@@ -301,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>;
 }
 
@@ -312,6 +379,16 @@ pub trait DataSourceTemplate<C: Blockchain>: Send + Sync + Debug {
     fn runtime(&self) -> Option<Arc<Vec<u8>>>;
     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]
@@ -320,16 +397,130 @@ 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>".
     fn error_context(&self) -> String;
+
+    /// If this trigger can only possibly match data sources with a specific address, then it can be
+    /// returned here for improved trigger matching performance, which helps subgraphs with many
+    /// data sources. But this optimization is not required, so returning `None` is always correct.
+    ///
+    /// When this does return `Some`, make sure that the `DataSource::address` of matching data
+    /// sources is equal to the addresssed returned here.
+    fn address_match(&self) -> Option<&[u8]>;
+}
+
+pub trait MappingTriggerTrait {
+    /// 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>".
+    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> {
@@ -337,27 +528,24 @@ pub struct HostFnCtx<'a> {
     pub block_ptr: BlockPtr,
     pub heap: &'a mut dyn AscHeap,
     pub gas: GasCounter,
+    pub metrics: Arc<HostMetrics>,
 }
 
 /// 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> {
@@ -368,29 +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,
 }
 
 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",
         };
         write!(f, "{}", value)
     }
@@ -401,11 +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),
+            "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)),
         }
     }
@@ -419,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")
@@ -433,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
new file mode 100644
index 00000000000..0b8b9e0707c
--- /dev/null
+++ b/graph/src/blockchain/noop_runtime_adapter.rs
@@ -0,0 +1,24 @@
+use std::marker::PhantomData;
+
+use crate::data_source;
+
+use super::{Blockchain, HostFn, RuntimeAdapter};
+
+/// A [`RuntimeAdapter`] that does not expose any host functions.
+#[derive(Debug, Clone)]
+pub struct NoopRuntimeAdapter<C>(PhantomData<C>);
+
+impl<C> Default for NoopRuntimeAdapter<C> {
+    fn default() -> Self {
+        Self(PhantomData)
+    }
+}
+
+impl<C> RuntimeAdapter<C> for NoopRuntimeAdapter<C>
+where
+    C: Blockchain,
+{
+    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 b9884870172..00000000000
--- a/graph/src/blockchain/substreams_block_stream.rs
+++ /dev/null
@@ -1,331 +0,0 @@
-use super::block_stream::SubstreamsMapper;
-use crate::blockchain::block_stream::{BlockStream, BlockStreamEvent};
-use crate::blockchain::Blockchain;
-use crate::firehose::FirehoseEndpoint;
-use crate::prelude::*;
-use crate::substreams::response::Message;
-use crate::substreams::ForkStep::{StepNew, StepUndo};
-use crate::substreams::{Modules, Request, Response};
-use crate::util::backoff::ExponentialBackoff;
-use async_stream::try_stream;
-use futures03::{Stream, StreamExt};
-use std::sync::Arc;
-use std::task::{Context, Poll};
-use std::time::{Duration, Instant};
-use tonic::Status;
-
-struct SubstreamsBlockStreamMetrics {
-    deployment: DeploymentHash,
-    provider: String,
-    restarts: CounterVec,
-    connect_duration: GaugeVec,
-    time_between_responses: HistogramVec,
-    responses: CounterVec,
-}
-
-impl SubstreamsBlockStreamMetrics {
-    pub fn new(
-        registry: Arc<dyn MetricsRegistry>,
-        deployment: DeploymentHash,
-        provider: String,
-    ) -> Self {
-        Self {
-            deployment,
-            provider,
-
-            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) {
-        self.restarts
-            .with_label_values(&[&self.deployment, &self.provider, "true"])
-            .inc();
-        self.connect_duration
-            .with_label_values(&[&self.deployment, &self.provider])
-            .set(time.elapsed().as_secs_f64());
-
-        // Reset last connection timestamp
-        *time = Instant::now();
-    }
-
-    fn observe_failed_connection(&self, time: &mut Instant) {
-        self.restarts
-            .with_label_values(&[&self.deployment, &self.provider, "false"])
-            .inc();
-        self.connect_duration
-            .with_label_values(&[&self.deployment, &self.provider])
-            .set(time.elapsed().as_secs_f64());
-
-        // Reset last connection timestamp
-        *time = Instant::now();
-    }
-
-    fn observe_response(&self, kind: &str, time: &mut Instant) {
-        self.time_between_responses
-            .with_label_values(&[&self.deployment, &self.provider])
-            .observe(time.elapsed().as_secs_f64());
-        self.responses
-            .with_label_values(&[&self.deployment, &self.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,
-        endpoint: Arc<FirehoseEndpoint>,
-        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<dyn MetricsRegistry>,
-    ) -> Self
-    where
-        F: SubstreamsMapper<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, endpoint.provider.clone());
-
-        SubstreamsBlockStream {
-            stream: Box::pin(stream_blocks(
-                endpoint,
-                cursor,
-                mapper,
-                modules,
-                module_name,
-                manifest_start_block_num,
-                manifest_end_block_num,
-                subgraph_current_block,
-                logger,
-                metrics,
-            )),
-        }
-    }
-}
-
-fn stream_blocks<C: Blockchain, F: SubstreamsMapper<C>>(
-    endpoint: Arc<FirehoseEndpoint>,
-    cursor: Option<String>,
-    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;
-
-    try_stream! {
-        loop {
-            info!(
-                &logger,
-                "Blockstreams disconnected, connecting";
-                "endpoint_uri" => format_args!("{}", endpoint),
-                "start_block" => start_block_num,
-                "cursor" => &latest_cursor,
-            );
-
-            // 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,
-                fork_steps: vec![StepNew as i32, StepUndo as i32],
-                irreversibility_condition: "".to_string(),
-                modules: modules.clone(),
-                output_modules: vec![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);
-
-                    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(),
-                            &logger,
-                        ).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);
-
-                                        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);
-
-                                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);
-
-                    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: SubstreamsMapper<C>>(
-    result: Result<Response, Status>,
-    mapper: &F,
-    logger: &Logger,
-) -> 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 response.message {
-        Some(Message::Data(block_scoped_data)) => {
-            match mapper
-                .to_block_stream_event(logger, &block_scoped_data)
-                .await
-                .context("Mapping block to BlockStreamEvent failed")?
-            {
-                Some(event) => Ok(Some(BlockResponse::Proceed(
-                    event,
-                    block_scoped_data.cursor.to_string(),
-                ))),
-                None => Ok(None),
-            }
-        }
-        None => {
-            warn!(&logger, "Got None on substream message");
-            Ok(None)
-        }
-        _ => Ok(None),
-    }
-}
-
-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> {}
diff --git a/graph/src/blockchain/types.rs b/graph/src/blockchain/types.rs
index de7bbce0ed7..dc88bd91841 100644
--- a/graph/src/blockchain/types.rs
+++ b/graph/src/blockchain/types.rs
@@ -1,16 +1,30 @@
+use alloy::primitives::B256;
 use anyhow::anyhow;
+use diesel::deserialize::FromSql;
+use diesel::pg::Pg;
+use diesel::serialize::{Output, ToSql};
+use diesel::sql_types::Timestamptz;
+use diesel::sql_types::{Bytea, Nullable, Text};
+use diesel_derives::{AsExpression, FromSqlRow};
+use serde::{Deserialize, Deserializer};
 use std::convert::TryFrom;
+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, 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)]
+#[derive(Clone, Default, PartialEq, Eq, Hash, FromSqlRow, AsExpression)]
+#[diesel(sql_type = Bytea)]
 pub struct BlockHash(pub Box<[u8]>);
 
 impl_stable_hash!(BlockHash(transparent: AsBytes));
@@ -20,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
@@ -29,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())
     }
 }
 
@@ -51,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;
 
@@ -84,17 +116,44 @@ impl FromStr for BlockHash {
     }
 }
 
+impl FromSql<Nullable<Text>, Pg> for BlockHash {
+    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())
+    }
+}
+
+impl FromSql<Text, Pg> for BlockHash {
+    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())
+    }
+}
+
+impl FromSql<Bytea, Pg> for BlockHash {
+    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 {
@@ -113,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()
     }
@@ -148,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()))
     }
 }
 
@@ -169,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,
+        }
     }
 }
 
@@ -221,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! {
@@ -262,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()
     }
 }
 
@@ -274,9 +320,351 @@ 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 {
     pub net_version: String,
     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!(
+            f,
+            "net_version: {}, genesis_block_hash: {}",
+            self.net_version, self.genesis_block_hash
+        )
+    }
+}
+
+/// 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, 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(Timestamp::NONE);
+
+    pub const MAX: Self = Self(Timestamp::MAX);
+
+    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(
+            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 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 * 45 * 60, 0)
+    }
+
+    pub fn as_secs_since_epoch(&self) -> i64 {
+        self.0.as_secs_since_epoch()
+    }
+
+    /// Return the number of the last bucket that starts before `self`
+    /// assuming buckets have the given `length`
+    pub(crate) fn bucket(&self, length: Duration) -> usize {
+        // Treat any time before the epoch as zero, i.e., the epoch; in
+        // practice, we will only deal with block times that are pretty far
+        // after the epoch
+        let ts = self.0.timestamp_millis().max(0);
+        let nr = ts as u128 / length.as_millis();
+        usize::try_from(nr).unwrap()
+    }
+}
+
+impl From<Duration> for BlockTime {
+    fn from(d: Duration) -> Self {
+        Self::since_epoch(i64::try_from(d.as_secs()).unwrap(), d.subsec_nanos())
+    }
+}
+
+impl From<Timestamp> for BlockTime {
+    fn from(value: Timestamp) -> Self {
+        Self(value)
+    }
+}
+
+impl From<BlockTime> for Value {
+    fn from(block_time: BlockTime) -> Self {
+        Value::Timestamp(block_time.0)
+    }
+}
+
+impl TryFrom<&Value> for BlockTime {
+    type Error = anyhow::Error;
+
+    fn try_from(value: &Value) -> Result<Self, Self::Error> {
+        match value {
+            Value::Int8(ts) => Ok(BlockTime::since_epoch(*ts, 0)),
+            _ => Err(anyhow!("invalid block time: {:?}", value)),
+        }
+    }
+}
+
+impl ToSql<Timestamptz, Pg> for BlockTime {
+    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 7deff5cd681..a8250bd6fb0 100644
--- a/graph/src/cheap_clone.rs
+++ b/graph/src/cheap_clone.rs
@@ -1,38 +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 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: ?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 {}
+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 69bec236648..104f6dbe036 100644
--- a/graph/src/components/ethereum/types.rs
+++ b/graph/src/components/ethereum/types.rs
@@ -1,59 +1,162 @@
+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::{convert::TryFrom, sync::Arc};
-use web3::types::{
-    Action, Address, Block, Bytes, Log, Res, Trace, Transaction, TransactionReceipt, H256, U256,
-    U64,
+use std::sync::Arc;
+
+use crate::{
+    blockchain::{BlockPtr, BlockTime},
+    prelude::BlockNumber,
 };
 
-use crate::{blockchain::BlockPtr, prelude::BlockNumber};
+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 type LightEthereumBlock = Block<Transaction>;
+    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 {
+        self.0.timestamp()
     }
 }
 
@@ -81,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)]
@@ -106,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,
@@ -145,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 ed7738308c2..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::{CacheStatus, Query, QueryTarget};
-use crate::data::subscription::{Subscription, SubscriptionError, SubscriptionResult};
-use crate::data::{graphql::effort::LoadManager, query::QueryResults};
-use crate::prelude::DeploymentHash;
+use crate::data::query::{Query, QueryTarget};
+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,16 +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 load_manager(&self) -> Arc<LoadManager>;
-
     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 {
@@ -51,9 +41,5 @@ pub trait GraphQLMetrics: Send + Sync + 'static {
     fn observe_query_parsing(&self, duration: Duration, results: &QueryResults);
     fn observe_query_validation(&self, duration: Duration, id: &DeploymentHash);
     fn observe_query_validation_error(&self, error_codes: Vec<&str>, id: &DeploymentHash);
-}
-
-#[async_trait]
-pub trait QueryLoadManager: Send + Sync {
-    fn record_work(&self, shape_hash: u64, duration: Duration, cache_status: CacheStatus);
+    fn observe_query_blocks_behind(&self, blocks_behind: i32, id: &DeploymentHash);
 }
diff --git a/graph/src/components/link_resolver.rs b/graph/src/components/link_resolver.rs
deleted file mode 100644
index 42f6a2651bc..00000000000
--- a/graph/src/components/link_resolver.rs
+++ /dev/null
@@ -1,44 +0,0 @@
-use std::pin::Pin;
-use std::time::Duration;
-
-use async_trait::async_trait;
-use futures03::prelude::Stream;
-use serde_json::Value;
-use slog::Logger;
-
-use crate::data::subgraph::Link;
-use crate::prelude::Error;
-use std::fmt::Debug;
-
-/// The values that `json_stream` returns. The struct contains the deserialized
-/// JSON value from the input stream, together with the line number from which
-/// the value was read.
-pub struct JsonStreamValue {
-    pub value: Value,
-    pub line: usize,
-}
-
-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>;
-}
diff --git a/graph/src/components/link_resolver/arweave.rs b/graph/src/components/link_resolver/arweave.rs
new file mode 100644
index 00000000000..e42263c9fe1
--- /dev/null
+++ b/graph/src/components/link_resolver/arweave.rs
@@ -0,0 +1,179 @@
+use std::pin::Pin;
+
+use async_trait::async_trait;
+use futures03::prelude::Stream;
+use reqwest::Client;
+use serde_json::Value;
+use slog::{Logger, debug};
+use thiserror::Error;
+
+use crate::data_source::offchain::Base64;
+use crate::derive::CheapClone;
+use crate::prelude::Error;
+use std::fmt::Debug;
+
+/// The values that `json_stream` returns. The struct contains the deserialized
+/// JSON value from the input stream, together with the line number from which
+/// the value was read.
+pub struct JsonStreamValue {
+    pub value: Value,
+    pub line: usize,
+}
+
+pub type JsonValueStream =
+    Pin<Box<dyn Stream<Item = Result<JsonStreamValue, Error>> + Send + 'static>>;
+
+#[derive(Debug)]
+pub struct ArweaveClient {
+    base_url: url::Url,
+    client: Client,
+    logger: Logger,
+}
+
+#[derive(Debug, Clone, CheapClone)]
+pub enum FileSizeLimit {
+    Unlimited,
+    MaxBytes(u64),
+}
+
+impl Default for ArweaveClient {
+    fn default() -> Self {
+        use slog::o;
+
+        Self {
+            base_url: "https://arweave.net".parse().unwrap(),
+            client: Client::builder().gzip(false).build().unwrap(),
+            logger: Logger::root(slog::Discard, o!()),
+        }
+    }
+}
+
+impl ArweaveClient {
+    pub fn new(logger: Logger, base_url: url::Url) -> Self {
+        Self {
+            base_url,
+            logger,
+            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);
+            }
+        }
+    }
+}
+
+#[async_trait]
+impl ArweaveResolver for ArweaveClient {
+    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> {
+        let url = self.base_url.join(file.as_str())?;
+        let rsp = self
+            .client
+            .get(url)
+            .send()
+            .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 });
+            }
+            _ => {}
+        };
+
+        debug!(self.logger, "Got arweave file {file}");
+
+        rsp.bytes()
+            .await
+            .map(|b| b.into())
+            .map_err(ArweaveClientError::from)
+    }
+}
+
+#[async_trait]
+pub trait ArweaveResolver: Send + Sync + 'static + Debug {
+    async fn get(&self, file: &Base64) -> Result<Vec<u8>, ArweaveClientError>;
+    async fn get_with_limit(
+        &self,
+        file: &Base64,
+        limit: &FileSizeLimit,
+    ) -> Result<Vec<u8>, ArweaveClientError>;
+}
+
+#[derive(Error, Debug)]
+pub enum ArweaveClientError {
+    #[error("Invalid file URL {0}")]
+    InvalidUrl(#[from] url::ParseError),
+    #[error("Unable to check the file size")]
+    UnableToCheckFileSize,
+    #[error("Arweave file is too large. The limit is {max} and file content was {got} bytes")]
+    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, 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.
+    #[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)]
+        struct Manifest {
+            pub manifest: String,
+        }
+
+        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,
+            Manifest {
+                manifest: "arweave/paths".to_string(),
+            }
+        );
+    }
+}
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
new file mode 100644
index 00000000000..120e90cb0dc
--- /dev/null
+++ b/graph/src/components/metrics/gas.rs
@@ -0,0 +1,73 @@
+use super::MetricsRegistry;
+use crate::{cheap_clone::CheapClone, prelude::DeploymentHash};
+use prometheus::CounterVec;
+use std::sync::Arc;
+
+#[derive(Clone)]
+pub struct GasMetrics {
+    pub gas_counter: CounterVec,
+    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
+            .global_deployment_counter_vec(
+                "deployment_gas",
+                "total gas used",
+                subgraph_id.as_str(),
+                &["method"],
+            )
+            .unwrap_or_else(|err| {
+                panic!(
+                    "Failed to register deployment_gas prometheus counter for {}: {}",
+                    subgraph_id, err
+                )
+            });
+
+        let op_counter = registry
+            .global_deployment_counter_vec(
+                "deployment_op_count",
+                "total number of operations",
+                subgraph_id.as_str(),
+                &["method"],
+            )
+            .unwrap_or_else(|err| {
+                panic!(
+                    "Failed to register deployment_op_count prometheus counter for {}: {}",
+                    subgraph_id, err
+                )
+            });
+
+        GasMetrics {
+            gas_counter,
+            op_counter,
+        }
+    }
+
+    pub fn mock() -> Self {
+        let subgraph_id = DeploymentHash::default();
+        Self::new(subgraph_id, Arc::new(MetricsRegistry::mock()))
+    }
+
+    pub fn track_gas(&self, method: &str, gas_used: u64) {
+        self.gas_counter
+            .with_label_values(&[method])
+            .inc_by(gas_used as f64);
+    }
+
+    pub fn track_operations(&self, method: &str, op_count: u64) {
+        self.op_counter
+            .with_label_values(&[method])
+            .inc_by(op_count as f64);
+    }
+}
diff --git a/graph/src/components/metrics/mod.rs b/graph/src/components/metrics/mod.rs
index 4a95241d44e..f028c8aa515 100644
--- a/graph/src/components/metrics/mod.rs
+++ b/graph/src/components/metrics/mod.rs
@@ -1,18 +1,22 @@
 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;
 pub mod subgraph;
 
+pub use registry::MetricsRegistry;
+
 use std::collections::HashMap;
 
 /// Metrics for measuring where time is spent during indexing.
 pub mod stopwatch;
 
-fn deployment_labels(subgraph: &str) -> HashMap<String, String> {
-    labels! { String::from("deployment") => String::from(subgraph), }
-}
+pub mod gas;
+
+pub mod block_state;
 
 /// Create an unregistered counter with labels
 pub fn counter_with_labels(
@@ -33,266 +37,3 @@ pub fn gauge_with_labels(
     let opts = Opts::new(name, help).const_labels(const_labels);
     Gauge::with_opts(opts)
 }
-
-pub trait MetricsRegistry: Send + Sync + 'static {
-    fn register(&self, name: &str, c: Box<dyn Collector>);
-
-    fn unregister(&self, metric: Box<dyn Collector>);
-
-    fn global_counter(
-        &self,
-        name: &str,
-        help: &str,
-        const_labels: HashMap<String, String>,
-    ) -> Result<Counter, PrometheusError>;
-
-    fn global_counter_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: &[&str],
-    ) -> Result<CounterVec, PrometheusError>;
-
-    fn global_deployment_counter(
-        &self,
-        name: &str,
-        help: &str,
-        subgraph: &str,
-    ) -> Result<Counter, PrometheusError> {
-        self.global_counter(name, help, deployment_labels(subgraph))
-    }
-
-    fn global_deployment_counter_vec(
-        &self,
-        name: &str,
-        help: &str,
-        subgraph: &str,
-        variable_labels: &[&str],
-    ) -> Result<CounterVec, PrometheusError>;
-
-    fn global_gauge(
-        &self,
-        name: &str,
-        help: &str,
-        const_labels: HashMap<String, String>,
-    ) -> Result<Gauge, PrometheusError>;
-
-    fn global_gauge_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: &[&str],
-    ) -> Result<GaugeVec, PrometheusError>;
-
-    fn new_gauge(
-        &self,
-        name: &str,
-        help: &str,
-        const_labels: HashMap<String, String>,
-    ) -> Result<Box<Gauge>, PrometheusError> {
-        let opts = Opts::new(name, help).const_labels(const_labels);
-        let gauge = Box::new(Gauge::with_opts(opts)?);
-        self.register(name, gauge.clone());
-        Ok(gauge)
-    }
-
-    fn new_deployment_gauge(
-        &self,
-        name: &str,
-        help: &str,
-        subgraph: &str,
-    ) -> Result<Gauge, PrometheusError> {
-        let opts = Opts::new(name, help).const_labels(deployment_labels(subgraph));
-        let gauge = Gauge::with_opts(opts)?;
-        self.register(name, Box::new(gauge.clone()));
-        Ok(gauge)
-    }
-
-    fn new_gauge_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: Vec<String>,
-    ) -> Result<Box<GaugeVec>, PrometheusError> {
-        let opts = Opts::new(name, help);
-        let gauges = Box::new(GaugeVec::new(
-            opts,
-            variable_labels
-                .iter()
-                .map(String::as_str)
-                .collect::<Vec<&str>>()
-                .as_slice(),
-        )?);
-        self.register(name, gauges.clone());
-        Ok(gauges)
-    }
-
-    fn new_deployment_gauge_vec(
-        &self,
-        name: &str,
-        help: &str,
-        subgraph: &str,
-        variable_labels: Vec<String>,
-    ) -> Result<Box<GaugeVec>, PrometheusError> {
-        let opts = Opts::new(name, help).const_labels(deployment_labels(subgraph));
-        let gauges = Box::new(GaugeVec::new(
-            opts,
-            variable_labels
-                .iter()
-                .map(String::as_str)
-                .collect::<Vec<&str>>()
-                .as_slice(),
-        )?);
-        self.register(name, gauges.clone());
-        Ok(gauges)
-    }
-
-    fn new_counter(&self, name: &str, help: &str) -> Result<Box<Counter>, PrometheusError> {
-        let opts = Opts::new(name, help);
-        let counter = Box::new(Counter::with_opts(opts)?);
-        self.register(name, counter.clone());
-        Ok(counter)
-    }
-
-    fn new_counter_with_labels(
-        &self,
-        name: &str,
-        help: &str,
-        const_labels: HashMap<String, String>,
-    ) -> Result<Box<Counter>, PrometheusError> {
-        let counter = Box::new(counter_with_labels(name, help, const_labels)?);
-        self.register(name, counter.clone());
-        Ok(counter)
-    }
-
-    fn new_deployment_counter(
-        &self,
-        name: &str,
-        help: &str,
-        subgraph: &str,
-    ) -> Result<Counter, PrometheusError> {
-        let counter = counter_with_labels(name, help, deployment_labels(subgraph))?;
-        self.register(name, Box::new(counter.clone()));
-        Ok(counter)
-    }
-
-    fn new_counter_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: Vec<String>,
-    ) -> Result<Box<CounterVec>, PrometheusError> {
-        let opts = Opts::new(name, help);
-        let counters = Box::new(CounterVec::new(
-            opts,
-            variable_labels
-                .iter()
-                .map(String::as_str)
-                .collect::<Vec<&str>>()
-                .as_slice(),
-        )?);
-        self.register(name, counters.clone());
-        Ok(counters)
-    }
-
-    fn new_deployment_counter_vec(
-        &self,
-        name: &str,
-        help: &str,
-        subgraph: &str,
-        variable_labels: Vec<String>,
-    ) -> Result<Box<CounterVec>, PrometheusError> {
-        let opts = Opts::new(name, help).const_labels(deployment_labels(subgraph));
-        let counters = Box::new(CounterVec::new(
-            opts,
-            variable_labels
-                .iter()
-                .map(String::as_str)
-                .collect::<Vec<&str>>()
-                .as_slice(),
-        )?);
-        self.register(name, counters.clone());
-        Ok(counters)
-    }
-
-    fn new_deployment_histogram(
-        &self,
-        name: &str,
-        help: &str,
-        subgraph: &str,
-        buckets: Vec<f64>,
-    ) -> Result<Box<Histogram>, PrometheusError> {
-        let opts = HistogramOpts::new(name, help)
-            .const_labels(deployment_labels(subgraph))
-            .buckets(buckets);
-        let histogram = Box::new(Histogram::with_opts(opts)?);
-        self.register(name, histogram.clone());
-        Ok(histogram)
-    }
-
-    fn new_histogram(
-        &self,
-        name: &str,
-        help: &str,
-        buckets: Vec<f64>,
-    ) -> Result<Box<Histogram>, PrometheusError> {
-        let opts = HistogramOpts::new(name, help).buckets(buckets);
-        let histogram = Box::new(Histogram::with_opts(opts)?);
-        self.register(name, histogram.clone());
-        Ok(histogram)
-    }
-
-    fn new_histogram_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: Vec<String>,
-        buckets: Vec<f64>,
-    ) -> Result<Box<HistogramVec>, PrometheusError> {
-        let opts = Opts::new(name, help);
-        let histograms = Box::new(HistogramVec::new(
-            HistogramOpts {
-                common_opts: opts,
-                buckets,
-            },
-            variable_labels
-                .iter()
-                .map(String::as_str)
-                .collect::<Vec<&str>>()
-                .as_slice(),
-        )?);
-        self.register(name, histograms.clone());
-        Ok(histograms)
-    }
-
-    fn new_deployment_histogram_vec(
-        &self,
-        name: &str,
-        help: &str,
-        subgraph: &str,
-        variable_labels: Vec<String>,
-        buckets: Vec<f64>,
-    ) -> Result<Box<HistogramVec>, PrometheusError> {
-        let opts = Opts::new(name, help).const_labels(deployment_labels(subgraph));
-        let histograms = Box::new(HistogramVec::new(
-            HistogramOpts {
-                common_opts: opts,
-                buckets,
-            },
-            variable_labels
-                .iter()
-                .map(String::as_str)
-                .collect::<Vec<&str>>()
-                .as_slice(),
-        )?);
-        self.register(name, histograms.clone());
-        Ok(histograms)
-    }
-
-    fn global_histogram_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: &[&str],
-    ) -> Result<HistogramVec, PrometheusError>;
-}
diff --git a/graph/src/components/metrics/registry.rs b/graph/src/components/metrics/registry.rs
new file mode 100644
index 00000000000..5efb6564ef7
--- /dev/null
+++ b/graph/src/components/metrics/registry.rs
@@ -0,0 +1,579 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+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;
+use crate::prometheus::{
+    Counter, CounterVec, Error as PrometheusError, Gauge, GaugeVec, HistogramOpts, HistogramVec,
+    Opts, Registry,
+};
+use crate::slog::{self, Logger, error, o};
+
+pub struct MetricsRegistry {
+    logger: Logger,
+    registry: Arc<Registry>,
+    register_errors: Box<Counter>,
+    unregister_errors: Box<Counter>,
+    registered_metrics: Box<Gauge>,
+
+    /// Global metrics are lazily initialized and identified by
+    /// the `Desc.id` that hashes the name and const label values
+    global_counters: RwLock<HashMap<u64, Counter>>,
+    global_counter_vecs: RwLock<HashMap<u64, CounterVec>>,
+    global_gauges: RwLock<HashMap<u64, Gauge>>,
+    global_gauge_vecs: RwLock<HashMap<u64, GaugeVec>>,
+    global_histogram_vecs: RwLock<HashMap<u64, HistogramVec>>,
+}
+
+impl MetricsRegistry {
+    pub fn new(logger: Logger, registry: Arc<Registry>) -> Self {
+        // Generate internal metrics
+        let register_errors = Self::gen_register_errors_counter(registry.clone());
+        let unregister_errors = Self::gen_unregister_errors_counter(registry.clone());
+        let registered_metrics = Self::gen_registered_metrics_gauge(registry.clone());
+
+        MetricsRegistry {
+            logger: logger.new(o!("component" => String::from("MetricsRegistry"))),
+            registry,
+            register_errors,
+            unregister_errors,
+            registered_metrics,
+            global_counters: RwLock::new(HashMap::new()),
+            global_counter_vecs: RwLock::new(HashMap::new()),
+            global_gauges: RwLock::new(HashMap::new()),
+            global_gauge_vecs: RwLock::new(HashMap::new()),
+            global_histogram_vecs: RwLock::new(HashMap::new()),
+        }
+    }
+
+    pub fn mock() -> Self {
+        MetricsRegistry::new(Logger::root(slog::Discard, o!()), Arc::new(Registry::new()))
+    }
+
+    fn gen_register_errors_counter(registry: Arc<Registry>) -> Box<Counter> {
+        let opts = Opts::new(
+            String::from("metrics_register_errors"),
+            String::from("Counts Prometheus metrics register errors"),
+        );
+        let counter = Box::new(
+            Counter::with_opts(opts).expect("failed to create `metrics_register_errors` counter"),
+        );
+        registry
+            .register(counter.clone())
+            .expect("failed to register `metrics_register_errors` counter");
+        counter
+    }
+
+    fn gen_unregister_errors_counter(registry: Arc<Registry>) -> Box<Counter> {
+        let opts = Opts::new(
+            String::from("metrics_unregister_errors"),
+            String::from("Counts Prometheus metrics unregister errors"),
+        );
+        let counter = Box::new(
+            Counter::with_opts(opts).expect("failed to create `metrics_unregister_errors` counter"),
+        );
+        registry
+            .register(counter.clone())
+            .expect("failed to register `metrics_unregister_errors` counter");
+        counter
+    }
+
+    fn gen_registered_metrics_gauge(registry: Arc<Registry>) -> Box<Gauge> {
+        let opts = Opts::new(
+            String::from("registered_metrics"),
+            String::from("Tracks the number of registered metrics on the node"),
+        );
+        let gauge =
+            Box::new(Gauge::with_opts(opts).expect("failed to create `registered_metrics` gauge"));
+        registry
+            .register(gauge.clone())
+            .expect("failed to register `registered_metrics` gauge");
+        gauge
+    }
+
+    fn global_counter_vec_internal(
+        &self,
+        name: &str,
+        help: &str,
+        deployment: Option<&str>,
+        variable_labels: &[&str],
+    ) -> Result<CounterVec, PrometheusError> {
+        let opts = Opts::new(name, help);
+        let opts = match deployment {
+            None => opts,
+            Some(deployment) => opts.const_label("deployment", deployment),
+        };
+        let counters = CounterVec::new(opts, variable_labels)?;
+        let id = counters.desc().first().unwrap().id;
+        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()
+                .insert(id, counters.clone());
+            Ok(counters)
+        }
+    }
+
+    /// 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();
+            }
+            Err(err) => {
+                error!(logger, "Failed to register a new metric"; "error" => format!("{err:#}"));
+                self.register_errors.inc();
+            }
+        }
+    }
+
+    pub fn global_counter(
+        &self,
+        name: &str,
+        help: &str,
+        const_labels: HashMap<String, String>,
+    ) -> 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().get(&id).cloned();
+        if let Some(counter) = maybe_counter {
+            Ok(counter)
+        } else {
+            self.register(name, Box::new(counter.clone()));
+            self.global_counters.write().insert(id, counter.clone());
+            Ok(counter)
+        }
+    }
+
+    pub fn global_deployment_counter(
+        &self,
+        name: &str,
+        help: &str,
+        subgraph: &str,
+    ) -> Result<Counter, PrometheusError> {
+        self.global_counter(name, help, deployment_labels(subgraph))
+    }
+
+    pub fn global_counter_vec(
+        &self,
+        name: &str,
+        help: &str,
+        variable_labels: &[&str],
+    ) -> Result<CounterVec, PrometheusError> {
+        self.global_counter_vec_internal(name, help, None, variable_labels)
+    }
+
+    pub fn global_deployment_counter_vec(
+        &self,
+        name: &str,
+        help: &str,
+        subgraph: &str,
+        variable_labels: &[&str],
+    ) -> Result<CounterVec, PrometheusError> {
+        self.global_counter_vec_internal(name, help, Some(subgraph), variable_labels)
+    }
+
+    pub fn global_gauge(
+        &self,
+        name: &str,
+        help: &str,
+        const_labels: HashMap<String, String>,
+    ) -> 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().get(&id).cloned();
+        if let Some(gauge) = maybe_gauge {
+            Ok(gauge)
+        } else {
+            self.register(name, Box::new(gauge.clone()));
+            self.global_gauges.write().insert(id, gauge.clone());
+            Ok(gauge)
+        }
+    }
+
+    pub fn global_gauge_vec(
+        &self,
+        name: &str,
+        help: &str,
+        variable_labels: &[&str],
+    ) -> Result<GaugeVec, PrometheusError> {
+        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().get(&id).cloned();
+        if let Some(gauges) = maybe_gauge {
+            Ok(gauges)
+        } else {
+            self.register(name, Box::new(gauges.clone()));
+            self.global_gauge_vecs.write().insert(id, gauges.clone());
+            Ok(gauges)
+        }
+    }
+
+    pub fn global_histogram_vec(
+        &self,
+        name: &str,
+        help: &str,
+        variable_labels: &[&str],
+    ) -> Result<HistogramVec, PrometheusError> {
+        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().get(&id).cloned();
+        if let Some(histograms) = maybe_histogram {
+            Ok(histograms)
+        } else {
+            self.register(name, Box::new(histograms.clone()));
+            self.global_histogram_vecs
+                .write()
+                .insert(id, histograms.clone());
+            Ok(histograms)
+        }
+    }
+
+    pub fn unregister(&self, metric: Box<dyn Collector>) {
+        match self.registry.unregister(metric) {
+            Ok(_) => {
+                self.registered_metrics.dec();
+            }
+            Err(e) => {
+                self.unregister_errors.inc();
+                error!(self.logger, "Unregistering metric failed = {:?}", e,);
+            }
+        };
+    }
+
+    pub fn new_gauge(
+        &self,
+        name: &str,
+        help: &str,
+        const_labels: HashMap<String, String>,
+    ) -> Result<Box<Gauge>, PrometheusError> {
+        let opts = Opts::new(name, help).const_labels(const_labels);
+        let gauge = Box::new(Gauge::with_opts(opts)?);
+        self.register(name, gauge.clone());
+        Ok(gauge)
+    }
+
+    pub fn new_deployment_gauge(
+        &self,
+        name: &str,
+        help: &str,
+        subgraph: &str,
+    ) -> Result<Gauge, PrometheusError> {
+        let opts = Opts::new(name, help).const_labels(deployment_labels(subgraph));
+        let gauge = Gauge::with_opts(opts)?;
+        self.register(name, Box::new(gauge.clone()));
+        Ok(gauge)
+    }
+
+    pub fn new_gauge_vec(
+        &self,
+        name: &str,
+        help: &str,
+        variable_labels: Vec<String>,
+    ) -> Result<Box<GaugeVec>, PrometheusError> {
+        let opts = Opts::new(name, help);
+        let gauges = Box::new(GaugeVec::new(
+            opts,
+            variable_labels
+                .iter()
+                .map(String::as_str)
+                .collect::<Vec<&str>>()
+                .as_slice(),
+        )?);
+        self.register(name, gauges.clone());
+        Ok(gauges)
+    }
+
+    pub fn new_deployment_gauge_vec(
+        &self,
+        name: &str,
+        help: &str,
+        subgraph: &str,
+        variable_labels: Vec<String>,
+    ) -> Result<Box<GaugeVec>, PrometheusError> {
+        let opts = Opts::new(name, help).const_labels(deployment_labels(subgraph));
+        let gauges = Box::new(GaugeVec::new(
+            opts,
+            variable_labels
+                .iter()
+                .map(String::as_str)
+                .collect::<Vec<&str>>()
+                .as_slice(),
+        )?);
+        self.register(name, gauges.clone());
+        Ok(gauges)
+    }
+
+    pub fn new_counter(&self, name: &str, help: &str) -> Result<Box<Counter>, PrometheusError> {
+        let opts = Opts::new(name, help);
+        let counter = Box::new(Counter::with_opts(opts)?);
+        self.register(name, counter.clone());
+        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,
+        help: &str,
+        const_labels: HashMap<String, String>,
+    ) -> Result<Box<Counter>, PrometheusError> {
+        let counter = Box::new(counter_with_labels(name, help, const_labels)?);
+        self.register(name, counter.clone());
+        Ok(counter)
+    }
+
+    pub fn new_deployment_counter(
+        &self,
+        name: &str,
+        help: &str,
+        subgraph: &str,
+    ) -> Result<Counter, PrometheusError> {
+        let counter = counter_with_labels(name, help, deployment_labels(subgraph))?;
+        self.register(name, Box::new(counter.clone()));
+        Ok(counter)
+    }
+
+    pub fn new_int_counter_vec(
+        &self,
+        name: &str,
+        help: &str,
+        variable_labels: &[&str],
+    ) -> Result<Box<IntCounterVec>, PrometheusError> {
+        let opts = Opts::new(name, help);
+        let counters = Box::new(IntCounterVec::new(opts, variable_labels)?);
+        self.register(name, counters.clone());
+        Ok(counters)
+    }
+
+    pub fn new_counter_vec(
+        &self,
+        name: &str,
+        help: &str,
+        variable_labels: Vec<String>,
+    ) -> Result<Box<CounterVec>, PrometheusError> {
+        let opts = Opts::new(name, help);
+        let counters = Box::new(CounterVec::new(
+            opts,
+            variable_labels
+                .iter()
+                .map(String::as_str)
+                .collect::<Vec<&str>>()
+                .as_slice(),
+        )?);
+        self.register(name, counters.clone());
+        Ok(counters)
+    }
+
+    pub fn new_deployment_counter_vec(
+        &self,
+        name: &str,
+        help: &str,
+        subgraph: &str,
+        variable_labels: Vec<String>,
+    ) -> Result<Box<CounterVec>, PrometheusError> {
+        let opts = Opts::new(name, help).const_labels(deployment_labels(subgraph));
+        let counters = Box::new(CounterVec::new(
+            opts,
+            variable_labels
+                .iter()
+                .map(String::as_str)
+                .collect::<Vec<&str>>()
+                .as_slice(),
+        )?);
+        self.register(name, counters.clone());
+        Ok(counters)
+    }
+
+    pub fn new_deployment_histogram(
+        &self,
+        name: &str,
+        help: &str,
+        subgraph: &str,
+        buckets: Vec<f64>,
+    ) -> Result<Box<Histogram>, PrometheusError> {
+        let opts = HistogramOpts::new(name, help)
+            .const_labels(deployment_labels(subgraph))
+            .buckets(buckets);
+        let histogram = Box::new(Histogram::with_opts(opts)?);
+        self.register(name, histogram.clone());
+        Ok(histogram)
+    }
+
+    pub fn new_histogram(
+        &self,
+        name: &str,
+        help: &str,
+        buckets: Vec<f64>,
+    ) -> Result<Box<Histogram>, PrometheusError> {
+        let opts = HistogramOpts::new(name, help).buckets(buckets);
+        let histogram = Box::new(Histogram::with_opts(opts)?);
+        self.register(name, histogram.clone());
+        Ok(histogram)
+    }
+
+    pub fn new_histogram_vec(
+        &self,
+        name: &str,
+        help: &str,
+        variable_labels: Vec<String>,
+        buckets: Vec<f64>,
+    ) -> Result<Box<HistogramVec>, PrometheusError> {
+        let opts = Opts::new(name, help);
+        let histograms = Box::new(HistogramVec::new(
+            HistogramOpts {
+                common_opts: opts,
+                buckets,
+            },
+            variable_labels
+                .iter()
+                .map(String::as_str)
+                .collect::<Vec<&str>>()
+                .as_slice(),
+        )?);
+        self.register(name, histograms.clone());
+        Ok(histograms)
+    }
+
+    pub fn new_deployment_histogram_vec(
+        &self,
+        name: &str,
+        help: &str,
+        subgraph: &str,
+        variable_labels: Vec<String>,
+        buckets: Vec<f64>,
+    ) -> Result<Box<HistogramVec>, PrometheusError> {
+        let opts = Opts::new(name, help).const_labels(deployment_labels(subgraph));
+        let histograms = Box::new(HistogramVec::new(
+            HistogramOpts {
+                common_opts: opts,
+                buckets,
+            },
+            variable_labels
+                .iter()
+                .map(String::as_str)
+                .collect::<Vec<&str>>()
+                .as_slice(),
+        )?);
+        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> {
+    labels! { String::from("deployment") => String::from(subgraph), }
+}
+
+#[test]
+fn global_counters_are_shared() {
+    use crate::log;
+
+    let logger = log::logger(false);
+    let prom_reg = Arc::new(Registry::new());
+    let registry = MetricsRegistry::new(logger, prom_reg);
+
+    fn check_counters(
+        registry: &MetricsRegistry,
+        name: &str,
+        const_labels: HashMap<String, String>,
+    ) {
+        let c1 = registry
+            .global_counter(name, "help me", const_labels.clone())
+            .expect("first test counter");
+        let c2 = registry
+            .global_counter(name, "help me", const_labels)
+            .expect("second test counter");
+        let desc1 = c1.desc();
+        let desc2 = c2.desc();
+        let d1 = desc1.first().unwrap();
+        let d2 = desc2.first().unwrap();
+
+        // Registering the same metric with the same name and
+        // const labels twice works and returns the same metric (logically)
+        assert_eq!(d1.id, d2.id, "counters: {}", name);
+
+        // They share the reported values
+        c1.inc_by(7.0);
+        c2.inc_by(2.0);
+        assert_eq!(9.0, c1.get(), "counters: {}", name);
+        assert_eq!(9.0, c2.get(), "counters: {}", name);
+    }
+
+    check_counters(&registry, "nolabels", HashMap::new());
+
+    let const_labels = {
+        let mut map = HashMap::new();
+        map.insert("pool".to_owned(), "main".to_owned());
+        map
+    };
+    check_counters(&registry, "pool", const_labels);
+
+    let const_labels = {
+        let mut map = HashMap::new();
+        map.insert("pool".to_owned(), "replica0".to_owned());
+        map
+    };
+    check_counters(&registry, "pool", const_labels);
+}
diff --git a/graph/src/components/metrics/stopwatch.rs b/graph/src/components/metrics/stopwatch.rs
index fe56cdb722a..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,20 +34,19 @@ 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,
         subgraph_id: DeploymentHash,
         stage: &str,
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
+        shard: String,
     ) -> Self {
         let stage = stage.to_owned();
         let mut inner = StopwatchInner {
@@ -54,7 +55,7 @@ impl StopwatchMetrics {
                     "deployment_sync_secs",
                     "total time spent syncing",
                     subgraph_id.as_str(),
-                    &["section", "stage"],
+                    &["section", "stage", "shard"],
                 )
                 .unwrap_or_else(|_| {
                     panic!(
@@ -64,6 +65,7 @@ impl StopwatchMetrics {
                 }),
             logger,
             stage,
+            shard,
             section_stack: Vec::new(),
             timer: Instant::now(),
         };
@@ -100,6 +102,10 @@ impl StopwatchMetrics {
             self.inner.lock().unwrap().end_section(id)
         }
     }
+
+    pub fn shard(&self) -> String {
+        self.inner.lock().unwrap().shard.to_string()
+    }
 }
 
 /// We want to account for all subgraph indexing time, based on "wall clock" time. To do this we
@@ -120,6 +126,8 @@ struct StopwatchInner {
     // The processing stage the metrics belong to; for pipelined uses, the
     // pipeline stage
     stage: String,
+
+    shard: String,
 }
 
 impl StopwatchInner {
@@ -128,7 +136,7 @@ impl StopwatchInner {
             // Register the current timer.
             let elapsed = self.timer.elapsed().as_secs_f64();
             self.counter
-                .get_metric_with_label_values(&[section, &self.stage])
+                .get_metric_with_label_values(&[section, &self.stage, &self.shard])
                 .map(|counter| counter.inc_by(elapsed))
                 .unwrap_or_else(|e| {
                     error!(self.logger, "failed to find counter for section";
@@ -142,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);
     }
@@ -160,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 d4308ca0a47..e45e7bd33a5 100644
--- a/graph/src/components/metrics/subgraph.rs
+++ b/graph/src/components/metrics/subgraph.rs
@@ -1,27 +1,37 @@
-use prometheus::Counter;
-
-use crate::blockchain::block_stream::BlockStreamMetrics;
-use crate::prelude::{Gauge, Histogram, HostMetrics, MetricsRegistry};
 use std::collections::HashMap;
 use std::sync::Arc;
+use std::time::Duration;
+
+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>,
 }
 
 impl SubgraphInstanceMetrics {
     pub fn new(
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
         subgraph_hash: &str,
         stopwatch: StopwatchMetrics,
+        deployment_status: DeploymentStatusMetric,
     ) -> Self {
         let block_trigger_count = registry
             .new_deployment_histogram(
@@ -64,13 +74,39 @@ impl SubgraphInstanceMetrics {
             )
             .expect("failed to create firehose_connection_errors counter");
 
+        let labels = HashMap::from_iter([
+            ("deployment".to_string(), subgraph_hash.to_string()),
+            ("shard".to_string(), stopwatch.shard().to_string()),
+        ]);
+        let blocks_processed_secs = registry
+            .new_counter_with_labels(
+                "deployment_blocks_processed_secs",
+                "Measures the time spent processing blocks",
+                labels.clone(),
+            )
+            .expect("failed to create blocks_processed_secs gauge");
+        let blocks_processed_count = registry
+            .new_counter_with_labels(
+                "deployment_blocks_processed_count",
+                "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,
         }
     }
 
@@ -78,29 +114,48 @@ impl SubgraphInstanceMetrics {
         self.trigger_processing_duration.observe(duration);
     }
 
-    pub fn unregister(&self, registry: Arc<dyn MetricsRegistry>) {
+    pub fn observe_block_processed(&self, duration: Duration, block_done: bool) {
+        self.blocks_processed_secs.inc_by(duration.as_secs_f64());
+        if block_done {
+            self.blocks_processed_count.inc();
+        }
+    }
+
+    pub fn unregister(&self, registry: Arc<MetricsRegistry>) {
         registry.unregister(self.block_processing_duration.clone());
         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()));
     }
 }
 
 #[derive(Debug)]
 pub struct SubgraphCountMetric {
-    pub subgraph_count: Box<Gauge>,
+    pub running_count: Box<Gauge>,
+    pub deployment_count: Box<Gauge>,
 }
 
 impl SubgraphCountMetric {
-    pub fn new(registry: Arc<dyn MetricsRegistry>) -> Self {
-        let subgraph_count = registry
+    pub fn new(registry: Arc<MetricsRegistry>) -> Self {
+        let running_count = registry
             .new_gauge(
-                "deployment_count",
+                "deployment_running_count",
                 "Counts the number of deployments currently being indexed by the graph-node.",
                 HashMap::new(),
             )
             .expect("failed to create `deployment_count` gauge");
-        Self { subgraph_count }
+        let deployment_count = registry
+            .new_gauge(
+                "deployment_count",
+                "Counts the number of deployments currently deployed to the graph-node.",
+                HashMap::new(),
+            )
+            .expect("failed to create `deployment_count` gauge");
+        Self {
+            running_count,
+            deployment_count,
+        }
     }
 }
 
@@ -112,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 eddf1fa51a8..e8f6fa1eacb 100644
--- a/graph/src/components/server/index_node.rs
+++ b/graph/src/components/server/index_node.rs
@@ -1,8 +1,4 @@
-use std::sync::Arc;
-
-use futures::prelude::*;
-
-use crate::prelude::{BlockNumber, Schema};
+use crate::{prelude::BlockNumber, schema::InputSchema};
 
 /// This is only needed to support the explorer API.
 #[derive(Debug)]
@@ -15,17 +11,6 @@ pub struct VersionInfo {
     pub failed: bool,
     pub description: Option<String>,
     pub repository: Option<String>,
-    pub schema: Arc<Schema>,
+    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 538af72ff18..0bc3f17efef 100644
--- a/graph/src/components/store/entity_cache.rs
+++ b/graph/src/components/store/entity_cache.rs
@@ -1,11 +1,125 @@
-use anyhow::anyhow;
-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::{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)),
+        }
+    }
 
-use crate::components::store::{self as s, Entity, EntityKey, EntityOp, EntityOperation};
-use crate::prelude::{Schema, ENV_VARS};
-use crate::util::lfu_cache::LfuCache;
+    /// 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
+    Store,
+    /// Get from the entities that have been stored during this block
+    InBlock,
+}
+
+/// A representation of entity operations that can be accumulated.
+#[derive(Debug, Clone)]
+enum EntityOp {
+    Remove,
+    Update(Entity),
+    Overwrite(Entity),
+}
+
+impl EntityOp {
+    fn apply_to<E: Borrow<Entity>>(
+        self,
+        entity: &Option<E>,
+    ) -> Result<Option<Entity>, InternError> {
+        use EntityOp::*;
+        match (self, entity) {
+            (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))
+            }
+        }
+    }
+
+    fn accumulate(&mut self, next: EntityOp) {
+        use EntityOp::*;
+        let update = match next {
+            // Remove and Overwrite ignore the current value.
+            Remove | Overwrite(_) => {
+                *self = next;
+                return;
+            }
+            Update(update) => update,
+        };
+
+        // We have an update, apply it.
+        match self {
+            // This is how `Overwrite` is constructed, by accumulating `Update` onto `Remove`.
+            Remove => *self = Overwrite(update),
+            Update(current) | Overwrite(current) => current.merge(update),
+        }
+    }
+}
 
 /// A cache for entities from the store that provides the basic functionality
 /// needed for the store interactions in the host exports. This struct tracks
@@ -14,10 +128,13 @@ use crate::util::lfu_cache::LfuCache;
 ///   (1) no entity appears in more than one operation
 ///   (2) only entities that will actually be changed from what they
 ///       are in the store are changed
+///
+/// It is important for correctness that this struct is newly instantiated
+/// at every block using `with_current` to seed the cache.
 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>,
@@ -31,7 +148,10 @@ pub struct EntityCache {
     /// The store is only used to read entities.
     pub store: Arc<dyn s::ReadStore>,
 
-    schema: Arc<Schema>,
+    pub schema: InputSchema,
+
+    /// Shared sequence generator for VIDs and entity IDs within a block.
+    pub seq_gen: SeqGenerator,
 }
 
 impl Debug for EntityCache {
@@ -45,11 +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(),
@@ -57,12 +178,22 @@ impl EntityCache {
             in_handler: false,
             schema: store.input_schema(),
             store,
+            seq_gen,
         }
     }
 
+    /// Make a new entity. The entity is not part of the cache
+    pub fn make_entity<I: IntoEntityIterator>(
+        &self,
+        iter: I,
+    ) -> Result<Entity, EntityValidationError> {
+        self.schema.make_entity(iter)
+    }
+
     pub fn with_current(
         store: Arc<dyn s::ReadStore>,
-        current: LfuCache<EntityKey, Option<Entity>>,
+        current: EntityLfuCache,
+        seq_gen: SeqGenerator,
     ) -> EntityCache {
         EntityCache {
             current,
@@ -71,9 +202,14 @@ impl EntityCache {
             in_handler: false,
             schema: store.input_schema(),
             store,
+            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;
@@ -96,23 +232,113 @@ impl EntityCache {
         self.handler_updates.clear();
     }
 
-    pub fn get(&mut self, eref: &EntityKey) -> Result<Option<Entity>, s::QueryExecutionError> {
+    pub async fn get(
+        &mut self,
+        key: &EntityKey,
+        scope: GetScope,
+    ) -> Result<Option<Arc<Entity>>, StoreError> {
         // Get the current entity, apply any updates from `updates`, then
         // from `handler_updates`.
-        let mut entity = self.current.get_entity(&*self.store, eref)?;
-
-        // Always test the cache consistency in debug mode.
-        debug_assert!(entity == self.store.get(eref).unwrap());
+        let mut entity: Option<Arc<Entity>> = match scope {
+            GetScope::Store => {
+                if !self.current.contains_key(key) {
+                    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().cheap_clone()
+            }
+            GetScope::InBlock => None,
+        };
 
-        if let Some(op) = self.updates.get(eref).cloned() {
-            entity = op.apply_to(entity)
+        // Always test the cache consistency in debug mode. The test only
+        // 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).await.unwrap().map(Arc::new)
+            }
+            GetScope::InBlock => true,
+        });
+
+        if let Some(op) = self.updates.get(key).cloned() {
+            entity = op
+                .apply_to(&entity)
+                .map_err(|e| key.unknown_attribute(e))?
+                .map(Arc::new);
         }
-        if let Some(op) = self.handler_updates.get(eref).cloned() {
-            entity = op.apply_to(entity)
+        if let Some(op) = self.handler_updates.get(key).cloned() {
+            entity = op
+                .apply_to(&entity)
+                .map_err(|e| key.unknown_attribute(e))?
+                .map(Arc::new);
         }
         Ok(entity)
     }
 
+    pub async fn load_related(
+        &mut self,
+        eref: &LoadRelatedRequest,
+    ) -> Result<Vec<Entity>, anyhow::Error> {
+        let (entity_type, field) = self.schema.get_field_related(eref)?;
+
+        let query = DerivedEntityQuery {
+            entity_type,
+            entity_field: field.name.clone(),
+            value: eref.entity_id.clone(),
+            causality_region: eref.causality_region,
+        };
+
+        // Entities that satisfied the query at the start of this block.
+        let stored = self.store.get_derived(&query).await?;
+
+        for (key, entity) in &stored {
+            if !self.current.contains_key(key) {
+                self.current
+                    .insert(key.clone(), Some(Arc::new(entity.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);
+            }
+        }
+
+        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))?;
+            }
+            if let Some(op) = self.handler_updates.get(key).cloned() {
+                entity = op.apply_to(&entity).map_err(|e| key.unknown_attribute(e))?;
+            }
+
+            // Include the entity only if its final state still matches the query.
+            if let Some(entity) = entity
+                && query.matches(key, &entity)
+            {
+                result.push(entity);
+            }
+        }
+
+        Ok(result)
+    }
+
     pub fn remove(&mut self, key: EntityKey) {
         self.entity_op(key, EntityOp::Remove);
     }
@@ -122,36 +348,39 @@ 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, mut entity: Entity) -> Result<(), anyhow::Error> {
-        fn check_id(key: &EntityKey, prev_id: &str) -> Result<(), anyhow::Error> {
-            if prev_id != key.entity_id.as_str() {
-                Err(anyhow!(
-                    "Value of {} attribute 'id' conflicts with ID passed to `store.set()`: \
-                {} != {}",
-                    key.entity_type,
-                    prev_id,
+    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,
-                ))
-            } else {
-                Ok(())
+                ));
             }
-        }
 
-        // Set the id if there isn't one yet, and make sure that a
-        // previously set id agrees with the one in the `key`
-        match entity.get("id") {
-            Some(s::Value::String(s)) => check_id(&key, s)?,
-            Some(s::Value::Bytes(b)) => check_id(&key, &b.to_string())?,
-            Some(_) => {
-                // The validation will catch the type mismatch
-            }
-            None => {
-                let value = self.schema.id_value(&key)?;
-                entity.set("id", value);
-            }
+            *write_capacity_remaining -= weight;
         }
 
-        let is_valid = entity.validate(&self.schema, &key).is_ok();
+        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));
 
@@ -159,14 +388,14 @@ impl EntityCache {
         // 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)?.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,
                     key.entity_id
                 )
             })?;
-            entity.validate(&self.schema, &key)?;
+            entity.validate(&key)?;
         }
 
         Ok(())
@@ -216,7 +445,11 @@ impl EntityCache {
     /// to the current state is actually needed.
     ///
     /// Also returns the updated `LfuCache`.
-    pub fn as_modifications(mut self) -> Result<ModificationsAndCache, s::QueryExecutionError> {
+    pub async fn as_modifications(
+        mut self,
+        block: BlockNumber,
+        stopwatch: &StopwatchMetrics,
+    ) -> Result<ModificationsAndCache, StoreError> {
         assert!(!self.in_handler);
 
         // The first step is to make sure all entities being set are in `self.current`.
@@ -233,42 +466,66 @@ 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| !self.schema.is_immutable(&key.entity_type));
+        {
+            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();
         for (key, update) in self.updates {
-            use s::EntityModification::*;
+            use EntityModification::*;
 
             let current = self.current.remove(&key).and_then(|entity| entity);
             let modification = match (current, update) {
                 // Entity was created
-                (None, EntityOp::Update(updates)) | (None, EntityOp::Overwrite(updates)) => {
-                    // Merging with an empty entity removes null fields.
-                    let mut data = Entity::new();
-                    data.merge_remove_null_fields(updates);
-                    self.current.insert(key.clone(), Some(data.clone()));
-                    Some(Insert { key, data })
+                (None, EntityOp::Update(mut updates))
+                | (None, EntityOp::Overwrite(mut updates)) => {
+                    updates.remove_null_fields();
+                    let data = Arc::new(updates);
+                    self.current.insert(key.clone(), Some(data.cheap_clone()));
+                    Some(Insert {
+                        key,
+                        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);
-                    self.current.insert(key.clone(), Some(data.clone()));
-                    if current != data {
-                        Some(Overwrite { key, data })
+                    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))?;
+                    let data = Arc::new(data);
+                    self.current.insert(key.clone(), Some(data.cheap_clone()));
+                    if changed {
+                        Some(Overwrite {
+                            key,
+                            data,
+                            block,
+                            end: None,
+                        })
                     } else {
                         None
                     }
                 }
                 // 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, data })
+                        Some(Overwrite {
+                            key,
+                            data,
+                            block,
+                            end: None,
+                        })
                     } else {
                         None
                     }
@@ -276,7 +533,7 @@ impl EntityCache {
                 // Existing entity was deleted
                 (Some(_), EntityOp::Remove) => {
                     self.current.insert(key.clone(), None);
-                    Some(Remove { key })
+                    Some(Remove { key, block })
                 }
                 // Entity was deleted, but it doesn't exist in the store
                 (None, EntityOp::Remove) => None,
@@ -285,33 +542,14 @@ impl EntityCache {
                 mods.push(modification)
             }
         }
-        self.current.evict(ENV_VARS.mappings.entity_cache_size);
+        let evict_stats = self
+            .current
+            .evict_and_stats(ENV_VARS.mappings.entity_cache_size);
 
         Ok(ModificationsAndCache {
             modifications: mods,
             entity_lfu_cache: self.current,
+            evict_stats,
         })
     }
 }
-
-impl LfuCache<EntityKey, Option<Entity>> {
-    // Helper for cached lookup of an entity.
-    fn get_entity(
-        &mut self,
-        store: &(impl s::ReadStore + ?Sized),
-        key: &EntityKey,
-    ) -> Result<Option<Entity>, s::QueryExecutionError> {
-        match self.get(key) {
-            None => {
-                let mut entity = store.get(key)?;
-                if let Some(entity) = &mut entity {
-                    // `__typename` is for queries not for mappings.
-                    entity.remove("__typename");
-                }
-                self.insert(key.clone(), entity.clone());
-                Ok(entity)
-            }
-            Some(data) => Ok(data.clone()),
-        }
-    }
-}
diff --git a/graph/src/components/store/err.rs b/graph/src/components/store/err.rs
index 7187e6a687a..9e94342cb34 100644
--- a/graph/src/components/store/err.rs
+++ b/graph/src/components/store/err.rs
@@ -1,10 +1,14 @@
-use super::{BlockNumber, DeploymentHash, DeploymentSchemaVersion};
+use super::{BlockNumber, DeploymentSchemaVersion};
+use crate::prelude::DeploymentHash;
 use crate::prelude::QueryExecutionError;
-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:#}")]
@@ -14,14 +18,16 @@ pub enum StoreError {
          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("malformed directive '{0}'")]
-    MalformedDirective(String),
+    #[error("entity type '{0}' does not have an attribute '{0}'")]
+    UnknownAttribute(String, String),
     #[error("query execution failed: {0}")]
     QueryExecutionError(String),
+    #[error("Child filter nesting not supported by value `{0}`: `{1}`")]
+    ChildFilterNestingNotSupportedError(String, String),
     #[error("invalid identifier: {0}")]
     InvalidIdentifier(String),
     #[error(
@@ -32,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")]
@@ -53,39 +59,168 @@ 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) => {{
-        StoreError::ConstraintViolation(format!("{}", $msg))
+        $crate::prelude::StoreError::InternalError(format!("{}", $msg))
     }};
     ($fmt:expr, $($arg:tt)*) => {{
-        StoreError::ConstraintViolation(format!($fmt, $($arg)*))
+        $crate::prelude::StoreError::InternalError(format!($fmt, $($arg)*))
     }}
 }
 
-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;
+/// We can't derive `Clone` because some variants use non-cloneable data.
+/// For those cases, produce an `Unknown` error with some details about the
+/// original error
+impl Clone for StoreError {
+    fn clone(&self) -> Self {
+        match self {
+            Self::Unknown(arg0) => Self::Unknown(anyhow!("{}", arg0)),
+            Self::ConflictingId(arg0, arg1, arg2) => {
+                Self::ConflictingId(arg0.clone(), arg1.clone(), arg2.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::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)
+            }
+            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::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)
+            }
+            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,
         }
-        StoreError::Unknown(e.into())
+    }
+}
+
+impl From<DieselError> for StoreError {
+    fn from(e: DieselError) -> Self {
+        Self::from_diesel_error(&e).unwrap_or_else(|| StoreError::Unknown(e.into()))
     }
 }
 
@@ -115,6 +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 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 68aac1eaa85..a3a85b51cc2 100644
--- a/graph/src/components/store/mod.rs
+++ b/graph/src/components/store/mod.rs
@@ -1,110 +1,51 @@
 mod entity_cache;
 mod err;
 mod traits;
-
-pub use entity_cache::{EntityCache, ModificationsAndCache};
-
-use diesel::types::{FromSql, ToSql};
-pub use err::StoreError;
+pub mod write;
+
+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, 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 graphql_parser::schema as s;
 use serde::{Deserialize, Serialize};
-use std::borrow::Borrow;
 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 std::{fmt, io};
 
-use crate::blockchain::Block;
+use async_trait::async_trait;
+
+use crate::blockchain::{Block, BlockHash, BlockPtr};
+use crate::cheap_clone::CheapClone;
+use crate::components::store::write::EntityModification;
 use crate::data::store::scalar::Bytes;
-use crate::data::store::*;
+use crate::data::store::{Id, IdList, Value};
 use crate::data::value::Word;
 use crate::data_source::CausalityRegion;
-use crate::prelude::*;
-
-/// The type name of an entity. This is the string that is used in the
-/// subgraph's GraphQL schema as `type NAME @entity { .. }`
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct EntityType(Word);
-
-impl EntityType {
-    /// Construct a new entity type. Ideally, this is only called when
-    /// `entity_type` either comes from the GraphQL schema, or from
-    /// the database from fields that are known to contain a valid entity type
-    pub fn new(entity_type: String) -> Self {
-        Self(entity_type.into())
-    }
-
-    pub fn as_str(&self) -> &str {
-        self.0.as_str()
-    }
-
-    pub fn into_string(self) -> String {
-        self.0.to_string()
-    }
-
-    pub fn is_poi(&self) -> bool {
-        self.0.as_str() == "Poi$"
-    }
-}
-
-impl fmt::Display for EntityType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl<'a> From<&s::ObjectType<'a, String>> for EntityType {
-    fn from(object_type: &s::ObjectType<'a, String>) -> Self {
-        EntityType::new(object_type.name.clone())
-    }
-}
-
-impl<'a> From<&s::InterfaceType<'a, String>> for EntityType {
-    fn from(interface_type: &s::InterfaceType<'a, String>) -> Self {
-        EntityType::new(interface_type.name.clone())
-    }
-}
-
-impl Borrow<str> for EntityType {
-    fn borrow(&self) -> &str {
-        &self.0
-    }
-}
-
-// This conversion should only be used in tests since it makes it too
-// easy to convert random strings into entity types
-#[cfg(debug_assertions)]
-impl From<&str> for EntityType {
-    fn from(s: &str) -> Self {
-        EntityType::new(s.to_owned())
-    }
-}
-
-impl CheapClone for EntityType {}
-
-impl FromSql<diesel::sql_types::Text, diesel::pg::Pg> for EntityType {
-    fn from_sql(bytes: Option<&[u8]>) -> diesel::deserialize::Result<Self> {
-        let s = <String as FromSql<_, diesel::pg::Pg>>::from_sql(bytes)?;
-        Ok(EntityType::new(s))
-    }
-}
-
-impl ToSql<diesel::sql_types::Text, diesel::pg::Pg> for EntityType {
-    fn to_sql<W: io::Write>(
-        &self,
-        out: &mut diesel::serialize::Output<W, diesel::pg::Pg>,
-    ) -> diesel::serialize::Result {
-        <str as ToSql<diesel::sql_types::Text, diesel::pg::Pg>>::to_sql(self.0.as_str(), out)
-    }
-}
+use crate::derive::CheapClone;
+use crate::env::ENV_VARS;
+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);
@@ -119,15 +60,14 @@ impl EntityFilterDerivative {
     }
 }
 
-/// 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, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct EntityKey {
+#[derive(Debug, Clone)]
+pub struct LoadRelatedRequest {
     /// Name of the entity type.
     pub entity_type: EntityType,
-
     /// ID of the individual entity.
-    pub entity_id: Word,
+    pub entity_id: Id,
+    /// Field the shall be loaded
+    pub entity_field: Word,
 
     /// This is the causality region of the data source that created the entity.
     ///
@@ -137,15 +77,32 @@ pub struct EntityKey {
     pub causality_region: CausalityRegion,
 }
 
-impl EntityKey {
-    // For use in tests only
-    #[cfg(debug_assertions)]
-    pub fn data(entity_type: impl Into<String>, entity_id: impl Into<String>) -> Self {
-        Self {
-            entity_type: EntityType::new(entity_type.into()),
-            entity_id: entity_id.into().into(),
-            causality_region: CausalityRegion::ONCHAIN,
-        }
+#[derive(Debug)]
+pub struct DerivedEntityQuery {
+    /// Name of the entity to search
+    pub entity_type: EntityType,
+    /// The field to check
+    pub entity_field: Word,
+    /// The value to compare against
+    pub value: Id,
+
+    /// This is the causality region of the data source that created the entity.
+    ///
+    /// In the case of an entity lookup, this is the causality region of the data source that is
+    /// 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,
+}
+
+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)
+                .unwrap_or(false)
     }
 }
 
@@ -184,6 +141,7 @@ pub enum EntityFilter {
     NotEndsWithNoCase(Attribute, Value),
     ChangeBlockGte(BlockNumber),
     Child(Child),
+    Fulltext(Attribute, Value),
 }
 
 // A somewhat concise string representation of a filter
@@ -198,7 +156,7 @@ impl fmt::Display for EntityFilter {
             Or(fs) => {
                 write!(f, "{}", fs.iter().map(|f| f.to_string()).join(" or "))
             }
-            Equal(a, v) => write!(f, "{a} = {v}"),
+            Equal(a, v) | Fulltext(a, v) => write!(f, "{a} = {v}"),
             Not(a, v) => write!(f, "{a} != {v}"),
             GreaterThan(a, v) => write!(f, "{a} > {v}"),
             LessThan(a, v) => write!(f, "{a} < {v}"),
@@ -321,6 +279,10 @@ pub struct EntityRange {
 }
 
 impl EntityRange {
+    /// The default value for `first` that we use when the user doesn't
+    /// specify one
+    pub const FIRST: u32 = 100;
+
     /// Query for the first `n` entities.
     pub fn first(n: u32) -> Self {
         Self {
@@ -330,6 +292,15 @@ impl EntityRange {
     }
 }
 
+impl std::default::Default for EntityRange {
+    fn default() -> Self {
+        Self {
+            first: Some(Self::FIRST),
+            skip: 0,
+        }
+    }
+}
+
 /// The attribute we want to window by in an `EntityWindow`. We have to
 /// distinguish between scalar and list attributes since we need to use
 /// different queries for them, and the JSONB storage scheme can not
@@ -355,11 +326,11 @@ impl WindowAttribute {
 pub enum ParentLink {
     /// The parent stores a list of child ids. The ith entry in the outer
     /// vector contains the id of the children for `EntityWindow.ids[i]`
-    List(Vec<Vec<String>>),
+    List(Vec<IdList>),
     /// The parent stores the id of one child. The ith entry in the
     /// vector contains the id of the child of the parent with id
     /// `EntityWindow.ids[i]`
-    Scalar(Vec<String>),
+    Scalar(IdList),
 }
 
 /// How many children a parent can have when the child stores
@@ -370,6 +341,16 @@ pub enum ChildMultiplicity {
     Many,
 }
 
+impl ChildMultiplicity {
+    pub fn new(field: &s::Field) -> Self {
+        if sast::is_list_or_non_null_list_field(field) {
+            ChildMultiplicity::Many
+        } else {
+            ChildMultiplicity::Single
+        }
+    }
+}
+
 /// How to select children for their parents depending on whether the
 /// child stores parent ids (`Direct`) or the parent
 /// stores child ids (`Parent`)
@@ -395,7 +376,7 @@ pub struct EntityWindow {
     /// The entity type for this window
     pub child_type: EntityType,
     /// The ids of parents that should be considered for this window
-    pub ids: Vec<String>,
+    pub ids: IdList,
     /// How to get the parent id
     pub link: EntityLink,
     pub column_names: AttributeNames,
@@ -449,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,
@@ -487,7 +469,7 @@ pub struct EntityQuery {
 
     pub trace: bool,
 
-    _force_use_of_new: (),
+    pub aggregation_current: Option<AggregationCurrent>,
 }
 
 impl EntityQuery {
@@ -502,11 +484,11 @@ impl EntityQuery {
             collection,
             filter: None,
             order: EntityOrder::Default,
-            range: EntityRange::first(100),
+            range: EntityRange::default(),
             logger: None,
             query_id: None,
             trace: false,
-            _force_use_of_new: (),
+            aggregation_current: None,
         }
     }
 
@@ -539,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");
-                    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(),
+                    )]);
                 }
             }
         }
@@ -566,55 +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: EntityType,
-    },
-    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,
-        }
-    }
+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) -> SubscriptionFilter {
-        use EntityChange::*;
-        match self {
-            Data {
-                subgraph_id,
-                entity_type,
-                ..
-            } => SubscriptionFilter::Entities(subgraph_id.clone(), entity_type.clone()),
-            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)
     }
 }
 
@@ -631,57 +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 {
-        static NEXT_TAG: AtomicUsize = AtomicUsize::new(0);
-
-        let tag = NEXT_TAG.fetch_add(1, Ordering::Relaxed);
+    pub fn new(changes: Vec<AssignmentChange>) -> StoreEvent {
         let changes = changes.into_iter().collect();
-        StoreEvent { tag, changes }
+        StoreEvent::from_set(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 self::EntityModification::*;
-                match op {
-                    Insert { key, .. } | Overwrite { key, .. } | Remove { key } => {
-                        EntityChange::for_data(subgraph_id.clone(), key.clone())
-                    }
-                }
-            })
-            .collect();
-        StoreEvent::new(changes)
-    }
+    fn from_set(changes: HashSet<AssignmentChange>) -> StoreEvent {
+        static NEXT_TAG: AtomicUsize = AtomicUsize::new(0);
 
-    /// 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);
-        }
+        let tag = NEXT_TAG.fetch_add(1, Ordering::Relaxed);
+        StoreEvent { tag, changes }
     }
 
     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 {
@@ -702,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)]
@@ -844,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)]
@@ -862,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 {
@@ -877,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,
@@ -913,86 +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>>;
-
-/// An entity operation that can be transacted into the store; as opposed to
-/// `EntityOperation`, we already know whether a `Set` should be an `Insert`
-/// or `Update`
-#[derive(Clone, Debug, PartialEq, Eq)]
-pub enum EntityModification {
-    /// Insert the entity
-    Insert { key: EntityKey, data: Entity },
-    /// Update the entity by overwriting it
-    Overwrite { key: EntityKey, data: Entity },
-    /// Remove the entity
-    Remove { key: EntityKey },
-}
-
-impl EntityModification {
-    pub fn entity_ref(&self) -> &EntityKey {
-        use EntityModification::*;
-        match self {
-            Insert { key, .. } | Overwrite { key, .. } | Remove { key } => key,
-        }
-    }
-
-    pub fn entity(&self) -> Option<&Entity> {
-        match self {
-            EntityModification::Insert { data, .. }
-            | EntityModification::Overwrite { data, .. } => Some(data),
-            EntityModification::Remove { .. } => None,
-        }
-    }
-
-    pub fn is_remove(&self) -> bool {
-        match self {
-            EntityModification::Remove { .. } => true,
-            _ => false,
-        }
-    }
-}
-
-/// A representation of entity operations that can be accumulated.
-#[derive(Debug, Clone)]
-enum EntityOp {
-    Remove,
-    Update(Entity),
-    Overwrite(Entity),
-}
-
-impl EntityOp {
-    fn apply_to(self, entity: Option<Entity>) -> Option<Entity> {
-        use EntityOp::*;
-        match (self, entity) {
-            (Remove, _) => None,
-            (Overwrite(new), _) | (Update(new), None) => Some(new),
-            (Update(updates), Some(mut entity)) => {
-                entity.merge_remove_null_fields(updates);
-                Some(entity)
-            }
-        }
-    }
-
-    fn accumulate(&mut self, next: EntityOp) {
-        use EntityOp::*;
-        let update = match next {
-            // Remove and Overwrite ignore the current value.
-            Remove | Overwrite(_) => {
-                *self = next;
-                return;
-            }
-            Update(update) => update,
-        };
-
-        // We have an update, apply it.
-        match self {
-            // This is how `Overwrite` is constructed, by accumulating `Update` onto `Remove`.
-            Remove => *self = Overwrite(update),
-            Update(current) | Overwrite(current) => current.merge(update),
-        }
-    }
-}
+// 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)]
@@ -1107,25 +881,36 @@ impl fmt::Display for DeploymentSchemaVersion {
 
 /// A `ReadStore` that is always empty.
 pub struct EmptyStore {
-    schema: Arc<Schema>,
+    schema: InputSchema,
 }
 
 impl EmptyStore {
-    pub fn new(schema: Arc<Schema>) -> Self {
+    pub fn new(schema: InputSchema) -> Self {
         EmptyStore { schema }
     }
 }
 
+#[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 input_schema(&self) -> Arc<Schema> {
+    async fn get_derived(
+        &self,
+        _query: &DerivedEntityQuery,
+    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
+        Ok(BTreeMap::new())
+    }
+
+    fn input_schema(&self) -> InputSchema {
         self.schema.cheap_clone()
     }
 }
@@ -1134,33 +919,313 @@ 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
+pub enum PrunePhase {
+    /// Handling final entities
+    CopyFinal,
+    /// Handling nonfinal entities
+    CopyNonfinal,
+    /// Delete unneeded entity versions
+    Delete,
+}
+
+impl PrunePhase {
+    pub fn strategy(&self) -> PruningStrategy {
+        match self {
+            PrunePhase::CopyFinal | PrunePhase::CopyNonfinal => PruningStrategy::Rebuild,
+            PrunePhase::Delete => PruningStrategy::Delete,
+        }
+    }
 }
 
 /// Callbacks for `SubgraphStore.prune` so that callers can report progress
 /// of the pruning procedure to users
 #[allow(unused_variables)]
 pub trait PruneReporter: Send + 'static {
+    /// A pruning run has started. It will use the given `strategy` and
+    /// remove `history_frac` part of the blocks of the deployment, which
+    /// amounts to `history_blocks` many blocks.
+    ///
+    /// Before pruning, the subgraph has data for blocks from
+    /// `earliest_block` to `latest_block`
+    fn start(&mut self, req: &PruneRequest) {}
+
     fn start_analyze(&mut self) {}
     fn start_analyze_table(&mut self, table: &str) {}
     fn finish_analyze_table(&mut self, table: &str) {}
-    fn finish_analyze(&mut self, stats: &[VersionStats]) {}
 
-    fn copy_final_start(&mut self, earliest_block: BlockNumber, final_block: BlockNumber) {}
-    fn copy_final_batch(&mut self, table: &str, rows: usize, total_rows: usize, finished: bool) {}
-    fn copy_final_finish(&mut self) {}
+    /// Analyzing tables has finished. `stats` are the stats for all tables
+    /// in the deployment, `analyzed ` are the names of the tables that were
+    /// actually analyzed
+    fn finish_analyze(&mut self, stats: &[VersionStats], analyzed: &[&str]) {}
 
+    fn start_table(&mut self, table: &str) {}
+    fn prune_batch(&mut self, table: &str, rows: usize, phase: PrunePhase, finished: bool) {}
     fn start_switch(&mut self) {}
-    fn copy_nonfinal_start(&mut self, table: &str) {}
-    fn copy_nonfinal_batch(&mut self, table: &str, rows: usize, total_rows: usize, finished: bool) {
-    }
     fn finish_switch(&mut self) {}
+    fn finish_table(&mut self, table: &str) {}
+
+    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) {}
 
-    fn finish_prune(&mut self) {}
+    /// 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 {
+    /// Rebuild by copying the data we want to keep to new tables and swap
+    /// them out for the existing tables
+    Rebuild,
+    /// Delete unneeded data from the existing tables
+    Delete,
+}
+
+#[derive(Copy, Clone)]
+/// A request to prune a deployment. This struct encapsulates decision
+/// making around the best strategy for pruning (deleting historical
+/// entities or copying current ones) It needs to be filled with accurate
+/// information about the deployment that should be pruned.
+pub struct PruneRequest {
+    /// How many blocks of history to keep
+    pub history_blocks: BlockNumber,
+    /// The reorg threshold for the chain the deployment is on
+    pub reorg_threshold: BlockNumber,
+    /// The earliest block pruning should preserve
+    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
+    /// history. Initialized from `ENV_VARS.store.rebuild_threshold`, but
+    /// can be modified after construction
+    pub rebuild_threshold: f64,
+    /// Use the delete strategy when removing more than this fraction of
+    /// history but less than `rebuild_threshold`. Initialized from
+    /// `ENV_VARS.store.delete_threshold`, but can be modified after
+    /// construction
+    pub delete_threshold: f64,
+}
+
+impl PruneRequest {
+    /// Create a `PruneRequest` for a deployment that currently contains
+    /// entities for blocks from `first_block` to `latest_block` that should
+    /// retain only `history_blocks` blocks of history and is subject to a
+    /// reorg threshold of `reorg_threshold`.
+    pub fn new(
+        deployment: &DeploymentLocator,
+        history_blocks: BlockNumber,
+        reorg_threshold: BlockNumber,
+        first_block: BlockNumber,
+        latest_block: BlockNumber,
+    ) -> Result<Self, StoreError> {
+        let rebuild_threshold = ENV_VARS.store.rebuild_threshold;
+        let delete_threshold = ENV_VARS.store.delete_threshold;
+        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 !(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(internal_error!(
+                "the deployment {} needs to keep at least {} blocks \
+                   of history and can't be pruned to only {} blocks of history",
+                deployment,
+                reorg_threshold + 1,
+                history_blocks
+            ));
+        }
+        if first_block >= latest_block {
+            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;
+
+        Ok(Self {
+            history_blocks,
+            reorg_threshold,
+            earliest_block,
+            final_block,
+            latest_block,
+            first_block,
+            rebuild_threshold,
+            delete_threshold,
+        })
+    }
+
+    /// Determine what strategy to use for pruning
+    ///
+    /// We are pruning `history_pct` of the blocks from a table that has a
+    /// ratio of `version_ratio` entities to versions. If we are removing
+    /// more than `rebuild_threshold` percent of the versions, we prune by
+    /// rebuilding, and if we are removing more than `delete_threshold`
+    /// percent of the versions, we prune by deleting. If we would remove
+    /// less than `delete_threshold` percent of the versions, we don't
+    /// prune.
+    pub fn strategy(&self, stats: &VersionStats) -> Option<PruningStrategy> {
+        // If the deployment doesn't have enough history to cover the reorg
+        // threshold, do not prune
+        if self.earliest_block >= self.final_block {
+            return None;
+        }
+
+        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 {
+            Some(PruningStrategy::Delete)
+        } else {
+            None
+        }
+    }
+
+    /// Return an estimate of the fraction of the entities that are
+    /// historical in the table whose `stats` we are given
+    fn history_pct(&self, stats: &VersionStats) -> f64 {
+        let total_blocks = self.latest_block - stats.last_pruned_block.unwrap_or(0);
+        if total_blocks <= 0 || total_blocks < self.history_blocks {
+            // Something has gone very wrong; this could happen if the
+            // subgraph is ever rewound to before the last_pruned_block or
+            // if this is called when the subgraph has fewer blocks than
+            // history_blocks. In both cases, which should be transient,
+            // pretend that we would not delete any history
+            0.0
+        } else {
+            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
@@ -1174,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 7c54f05d28d..0249e999da6 100644
--- a/graph/src/components/store/traits.rs
+++ b/graph/src/components/store/traits.rs
@@ -1,51 +1,65 @@
-use web3::types::{Address, H256};
+use std::collections::HashMap;
+use std::ops::Range;
+
+use anyhow::Error;
+use async_trait::async_trait;
 
 use super::*;
-use crate::blockchain::block_stream::FirehoseCursor;
+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::subgraph::status;
-use crate::data::value::Word;
+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,
+    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>;
 }
@@ -58,64 +72,106 @@ 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,
+        deployment: &DeploymentHash,
+    ) -> Result<Option<DeploymentFeatures>, StoreError>;
 
     /// Create a new deployment for the subgraph `name`. If the deployment
     /// 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: &Schema,
+        schema: &InputSchema,
         deployment: DeploymentCreate,
         node_id: NodeId,
         network: String,
         mode: SubgraphVersionSwitchingMode,
     ) -> Result<DeploymentLocator, StoreError>;
 
+    /// Create a subgraph_feature record in the database
+    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>;
 
-    fn assignments(&self, node: &NodeId) -> Result<Vec<DeploymentLocator>, 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.
+    async fn assignment_status(
+        &self,
+        deployment: &DeploymentLocator,
+    ) -> Result<Option<(NodeId, bool)>, StoreError>;
+
+    /// Returns assignments that are not paused
+    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<Arc<Schema>, 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
+    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,
@@ -123,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,
@@ -138,12 +194,21 @@ pub trait SubgraphStore: Send + Sync + 'static {
     /// assumptions about the in-memory state of writing has been made; in
     /// particular, no assumptions about whether previous writes have
     /// actually been committed or not.
+    ///
+    /// The `manifest_idx_and_name` lists the correspondence between data
+    /// source or template position in the manifest and name.
     async fn writable(
         self: Arc<Self>,
         logger: Logger,
         deployment: DeploymentId,
+        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>;
@@ -154,67 +219,162 @@ 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>;
 
-    /// This migrates subgraphs that existed before the raw_yaml column was added.
-    async fn set_manifest_raw_yaml(
+    /// 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>;
+
+    /// 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>;
+
+    /// 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>;
 
-    fn input_schema(&self) -> Arc<Schema>;
+    /// Reverse lookup
+    async fn get_derived(
+        &self,
+        query_derived: &DerivedEntityQuery,
+    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError>;
+
+    fn input_schema(&self) -> InputSchema;
 }
 
 // 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 input_schema(&self) -> Arc<Schema> {
+    async fn get_derived(
+        &self,
+        entity_derived: &DerivedEntityQuery,
+    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
+        (**self).get_derived(entity_derived).await
+    }
+
+    fn input_schema(&self) -> InputSchema {
         (**self).input_schema()
     }
 }
 
-/// 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
-/// operation indefinitely until it succeeds.
-#[async_trait]
-pub trait WritableStore: ReadStore {
+pub trait DeploymentCursorTracker: Sync + Send + 'static {
+    fn input_schema(&self) -> InputSchema;
+
     /// Get a pointer to the most recently processed block in the subgraph.
     fn block_ptr(&self) -> Option<BlockPtr>;
 
     /// Returns the Firehose `cursor` this deployment is currently at in the block stream of events. This
     /// is used when re-connecting a Firehose stream to start back exactly where we left off.
-    fn block_cursor(&self) -> FirehoseCursor;
+    fn firehose_cursor(&self) -> FirehoseCursor;
+}
+
+// This silly impl is needed until https://github.com/rust-lang/rust/issues/65991 is stable.
+impl<T: ?Sized + DeploymentCursorTracker> DeploymentCursorTracker for Arc<T> {
+    fn block_ptr(&self) -> Option<BlockPtr> {
+        (**self).block_ptr()
+    }
+
+    fn firehose_cursor(&self) -> FirehoseCursor {
+        (**self).firehose_cursor()
+    }
+
+    fn input_schema(&self) -> InputSchema {
+        (**self).input_schema()
+    }
+}
+
+#[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
+/// operation indefinitely until it succeeds.
+#[async_trait]
+pub trait WritableStore: ReadStore + DeploymentCursorTracker {
     /// Start an existing subgraph deployment.
     async fn start_subgraph_deployment(&self, logger: &Logger) -> Result<(), StoreError>;
 
@@ -238,7 +398,7 @@ pub trait WritableStore: ReadStore {
 
     /// 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>;
@@ -246,34 +406,37 @@ pub trait WritableStore: ReadStore {
     /// 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,
+        block_time: BlockTime,
         firehose_cursor: FirehoseCursor,
         mods: Vec<EntityModification>,
         stopwatch: &StopwatchMetrics,
         data_sources: Vec<StoredDynamicDataSource>,
         deterministic_errors: Vec<SubgraphError>,
-        manifest_idx_and_name: Vec<(u32, String)>,
         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(
@@ -290,8 +453,26 @@ pub trait WritableStore: ReadStore {
 
     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>;
+
+    /// Restart the `WritableStore`. This will clear any errors that have
+    /// been encountered. Code that calls this must not make any assumptions
+    /// about what has been written already, as the write queue might
+    /// contain unprocessed write requests that will be discarded by this
+    /// call.
+    ///
+    /// This call returns `None` if a restart was not needed because `self`
+    /// had no errors. If it returns `Some`, `self` should not be used
+    /// anymore, as it will continue to produce errors for any write
+    /// requests, and instead, the returned `WritableStore` should be used.
+    async fn restart(self: Arc<Self>) -> Result<Option<Arc<dyn WritableStore>>, StoreError>;
 }
 
 #[async_trait]
@@ -303,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.
     ///
@@ -348,144 +584,210 @@ pub trait ChainStore: Send + Sync + 'static {
     async fn attempt_chain_head_update(
         self: Arc<Self>,
         ancestor_count: BlockNumber,
-    ) -> Result<Option<H256>, 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>;
+    ) -> Result<Option<B256>, Error>;
 
-    /// In-memory time cached version of `chain_head_ptr`.
-    async fn cached_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>;
+    /// 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>;
 
-    /// 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(
+    /// Returns the blocks present in the store for the given block numbers.
+    async fn block_ptrs_by_numbers(
         self: Arc<Self>,
-        block: Arc<dyn Block>,
-        cursor: String,
-    ) -> Result<(), Error>;
-
-    /// Returns the blocks present in the store.
-    fn blocks(&self, hashes: &[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>;
 }
 
+pub struct QueryPermit {
+    pub permit: tokio::sync::OwnedSemaphorePermit,
+    pub wait: Duration,
+}
+
 /// 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<BTreeMap<Word, r::Value>>, Trace), QueryExecutionError>;
+    ) -> 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>;
+    ) -> Result<Option<(BlockNumber, Option<u64>, Option<BlockHash>)>, StoreError>;
 
-    fn wait_stats(&self) -> Result<PoolWaitStats, 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>;
+
+    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<tokio::sync::OwnedSemaphorePermit, 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
+    fn shard(&self) -> &str;
+
+    /// Return the deployment id that is queried by this `QueryStore`
+    fn deployment_id(&self) -> DeploymentId;
 }
 
 /// A view of the store that can provide information about the indexing status
@@ -493,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<tokio::sync::OwnedSemaphorePermit, 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>;
@@ -535,5 +837,15 @@ pub trait StatusStore: Send + Sync + 'static {
         &self,
         subgraph_id: &DeploymentHash,
         block_number: BlockNumber,
+        fetch_block_ptr: &dyn BlockPtrForNumber,
     ) -> Result<Option<(PartialBlockPtr, [u8; 32])>, StoreError>;
 }
+
+#[async_trait]
+pub trait BlockPtrForNumber: Send + Sync {
+    async fn block_ptr_for_number(
+        &self,
+        network: String,
+        number: BlockNumber,
+    ) -> Result<Option<BlockPtr>, Error>;
+}
diff --git a/graph/src/components/store/write.rs b/graph/src/components/store/write.rs
new file mode 100644
index 00000000000..1a29714e51e
--- /dev/null
+++ b/graph/src/components/store/write.rs
@@ -0,0 +1,1386 @@
+//! Data structures and helpers for writing subgraph changes to the store
+use std::{
+    collections::{HashMap, HashSet},
+    sync::Arc,
+};
+
+use slog::Logger;
+
+use crate::{
+    blockchain::{BlockPtr, BlockTime, block_stream::FirehoseCursor},
+    cheap_clone::CheapClone,
+    components::subgraph::Entity,
+    data::{store::Id, subgraph::schema::SubgraphError},
+    data_source::CausalityRegion,
+    derive::CacheWeight,
+    env::ENV_VARS,
+    internal_error,
+    util::cache_weight::CacheWeight,
+};
+
+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
+/// until the dust settles, we'll keep them separate.
+///
+/// This is geared towards how we persist entity changes: there are only
+/// ever two operations we perform on them, clamping the range of an
+/// existing entity version, and writing a new entity version.
+///
+/// The difference between `Insert` and `Overwrite` is that `Overwrite`
+/// requires that we clamp an existing prior version of the entity at
+/// `block`. We only ever get an `Overwrite` if such a version actually
+/// exists. `Insert` simply inserts a new row into the underlying table,
+/// assuming that there is no need to fix up any prior version.
+///
+/// The `end` field for `Insert` and `Overwrite` indicates whether the
+/// entity exists now: if it is `None`, the entity currently exists, but if
+/// it is `Some(_)`, it was deleted, for example, by folding a `Remove` or
+/// `Overwrite` into this operation. The entity version will only be visible
+/// before `end`, excluding `end`. This folding, which happens in
+/// `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, CacheWeight, Debug, PartialEq, Eq)]
+pub enum EntityModification {
+    /// Insert the entity
+    Insert {
+        key: EntityKey,
+        data: Arc<Entity>,
+        block: BlockNumber,
+        end: Option<BlockNumber>,
+    },
+    /// Update the entity by overwriting it
+    Overwrite {
+        key: EntityKey,
+        data: Arc<Entity>,
+        block: BlockNumber,
+        end: Option<BlockNumber>,
+    },
+    /// Remove the entity
+    Remove { key: EntityKey, block: BlockNumber },
+}
+
+/// A helper struct for passing entity writes to the outside world, viz. the
+/// SQL query generation that inserts rows
+pub struct EntityWrite<'a> {
+    pub id: &'a Id,
+    pub entity: &'a Entity,
+    pub causality_region: CausalityRegion,
+    pub block: BlockNumber,
+    // The end of the block range for which this write is valid. The value
+    // of `end` itself is not included in the range
+    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 = ();
+
+    fn try_from(emod: &'a EntityModification) -> Result<Self, Self::Error> {
+        match emod {
+            EntityModification::Insert {
+                key,
+                data,
+                block,
+                end,
+            } => Ok(EntityWrite {
+                id: &key.entity_id,
+                entity: data,
+                causality_region: key.causality_region,
+                block: *block,
+                end: *end,
+            }),
+            EntityModification::Overwrite {
+                key,
+                data,
+                block,
+                end,
+            } => Ok(EntityWrite {
+                id: &key.entity_id,
+                entity: data,
+                causality_region: key.causality_region,
+                block: *block,
+                end: *end,
+            }),
+
+            EntityModification::Remove { .. } => Err(()),
+        }
+    }
+}
+
+impl EntityModification {
+    pub fn id(&self) -> &Id {
+        match self {
+            EntityModification::Insert { key, .. }
+            | EntityModification::Overwrite { key, .. }
+            | EntityModification::Remove { key, .. } => &key.entity_id,
+        }
+    }
+
+    fn block(&self) -> BlockNumber {
+        match self {
+            EntityModification::Insert { block, .. }
+            | EntityModification::Overwrite { block, .. }
+            | EntityModification::Remove { block, .. } => *block,
+        }
+    }
+
+    /// Return `true` if `self` requires a write operation, i.e.,insert of a
+    /// new row, for either a new or an existing entity
+    fn is_write(&self) -> bool {
+        match self {
+            EntityModification::Insert { .. } | EntityModification::Overwrite { .. } => true,
+            EntityModification::Remove { .. } => false,
+        }
+    }
+
+    /// 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<'_>> {
+        EntityWrite::try_from(self).ok()
+    }
+
+    /// Return `true` if `self` requires clamping of an existing version
+    fn is_clamp(&self) -> bool {
+        match self {
+            EntityModification::Insert { .. } => false,
+            EntityModification::Overwrite { .. } | EntityModification::Remove { .. } => true,
+        }
+    }
+
+    pub fn creates_entity(&self) -> bool {
+        use EntityModification::*;
+        match self {
+            Insert { .. } => true,
+            Overwrite { .. } | Remove { .. } => false,
+        }
+    }
+
+    fn entity_count_change(&self) -> i32 {
+        match self {
+            EntityModification::Insert { end: None, .. } => 1,
+            EntityModification::Insert { end: Some(_), .. } => {
+                // Insert followed by a remove
+                0
+            }
+            EntityModification::Overwrite { end: None, .. } => 0,
+            EntityModification::Overwrite { end: Some(_), .. } => {
+                // Overwrite followed by a remove
+                -1
+            }
+            EntityModification::Remove { .. } => -1,
+        }
+    }
+
+    fn clamp(&mut self, block: BlockNumber) -> Result<(), StoreError> {
+        use EntityModification::*;
+
+        match self {
+            Insert { end, .. } | Overwrite { end, .. } => {
+                if end.is_some() {
+                    return Err(internal_error!(
+                        "can not clamp {:?} to block {}",
+                        self,
+                        block
+                    ));
+                }
+                *end = Some(block);
+            }
+            Remove { .. } => {
+                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 into_insert(self, entity_type: &EntityType) -> Result<Self, StoreError> {
+        use EntityModification::*;
+
+        match self {
+            Insert { .. } => Ok(self),
+            Overwrite {
+                key,
+                data,
+                block,
+                end,
+            } => Ok(Insert {
+                key,
+                data,
+                block,
+                end,
+            }),
+            Remove { key, .. } => Err(internal_error!(
+                "a remove for {}[{}] can not be converted into an insert",
+                entity_type,
+                key.entity_id
+            )),
+        }
+    }
+
+    fn as_entity_op(&self, at: BlockNumber) -> EntityOp<'_> {
+        debug_assert!(self.block() <= at);
+
+        use EntityModification::*;
+
+        match self {
+            Insert {
+                data,
+                key,
+                end: None,
+                ..
+            }
+            | Overwrite {
+                data,
+                key,
+                end: None,
+                ..
+            } => EntityOp::Write { key, entity: data },
+            Insert {
+                data,
+                key,
+                end: Some(end),
+                ..
+            }
+            | Overwrite {
+                data,
+                key,
+                end: Some(end),
+                ..
+            } if at < *end => EntityOp::Write { key, entity: data },
+            Insert {
+                key, end: Some(_), ..
+            }
+            | Overwrite {
+                key, end: Some(_), ..
+            }
+            | Remove { key, .. } => EntityOp::Remove { key },
+        }
+    }
+}
+
+impl EntityModification {
+    pub fn insert(key: EntityKey, data: Entity, block: BlockNumber) -> Self {
+        EntityModification::Insert {
+            key,
+            data: Arc::new(data),
+            block,
+            end: None,
+        }
+    }
+
+    pub fn overwrite(key: EntityKey, data: Entity, block: BlockNumber) -> Self {
+        EntityModification::Overwrite {
+            key,
+            data: Arc::new(data),
+            block,
+            end: None,
+        }
+    }
+
+    pub fn remove(key: EntityKey, block: BlockNumber) -> Self {
+        EntityModification::Remove { key, block }
+    }
+
+    pub fn key(&self) -> &EntityKey {
+        use EntityModification::*;
+        match self {
+            Insert { key, .. } | Overwrite { key, .. } | Remove { key, .. } => key,
+        }
+    }
+}
+
+/// 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, 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>,
+
+    /// 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) -> Self {
+        Self {
+            entity_type,
+            rows: Vec::new(),
+            last_mod: LastMod::new(),
+        }
+    }
+
+    pub fn push(&mut self, emod: EntityModification, block: BlockNumber) -> Result<(), StoreError> {
+        let is_forward = self
+            .rows
+            .last()
+            .map(|emod| emod.block() <= block)
+            .unwrap_or(true);
+        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(internal_error!(
+                "we already have a modification for block {}, can not append {:?}",
+                last_block,
+                emod
+            ));
+        }
+
+        self.append_row(emod)
+    }
+
+    fn row_count(&self) -> usize {
+        self.rows.len()
+    }
+
+    /// Return the change in entity count that will result from applying
+    /// writing this row group to the database
+    pub fn entity_count_change(&self) -> i32 {
+        self.rows.iter().map(|row| row.entity_count_change()).sum()
+    }
+
+    /// Iterate over all changes that need clamping of the block range of an
+    /// existing entity version
+    pub fn clamps_by_block(&self) -> impl Iterator<Item = (BlockNumber, &[EntityModification])> {
+        ClampsByBlockIterator::new(self)
+    }
+
+    /// Iterate over all changes that require writing a new entity version
+    pub fn writes(&self) -> impl Iterator<Item = &EntityModification> {
+        self.rows.iter().filter(|row| row.is_write())
+    }
+
+    /// Return an iterator over all writes in chunks. The returned
+    /// `WriteChunker` is an iterator that produces `WriteChunk`s, which are
+    /// the iterators over the writes. Each `WriteChunk` has `chunk_size`
+    /// elements, except for the last one which might have fewer
+    pub fn write_chunks<'a>(&'a self, chunk_size: usize) -> WriteChunker<'a> {
+        WriteChunker::new(self, chunk_size)
+    }
+
+    pub fn has_clamps(&self) -> bool {
+        self.rows.iter().any(|row| row.is_clamp())
+    }
+
+    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
+            // `emod.block()`. Therefore, the first `emod` we encounter
+            // whose block is before `at` is the one in effect
+            .rfind(|emod| emod.key() == key && emod.block() <= at)
+            .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()
+            .rev()
+            .filter(move |emod| {
+                if emod.block() <= at {
+                    seen.insert(emod.id())
+                } else {
+                    false
+                }
+            })
+            .map(move |emod| emod.as_entity_op(at))
+    }
+
+    /// 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.entity_type.is_immutable() {
+            match row {
+                EntityModification::Insert { .. } => {
+                    // 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 { .. } => {
+                    if self.entity_type.skip_duplicates() {
+                        return Ok(());
+                    }
+                    return Err(internal_error!(
+                        "immutable entity type {} only allows inserts, not {:?}",
+                        self.entity_type,
+                        row
+                    ));
+                }
+            }
+            return Ok(());
+        }
+
+        if let Some(prev_row) = self.prev_row_mut(row.id()) {
+            use EntityModification::*;
+
+            if row.block() <= prev_row.block() {
+                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 { .. })
+                | (
+                    Insert { end: Some(_), .. } | Overwrite { end: Some(_), .. },
+                    Overwrite { .. } | Remove { .. },
+                ) => {
+                    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.push_row(row);
+                }
+                (
+                    Insert { end: None, .. } | Overwrite { end: None, .. },
+                    Overwrite { block, .. },
+                ) => {
+                    prev_row.clamp(*block)?;
+                    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.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(internal_error!(
+                "Can not append a row group for {} to a row group for {}",
+                group.entity_type,
+                self.entity_type
+            ));
+        }
+
+        self.rows.reserve(group.rows.len());
+        for row in group.rows {
+            self.append_row(row)?;
+        }
+
+        Ok(())
+    }
+
+    pub fn ids(&self) -> impl Iterator<Item = &Id> {
+        self.rows.iter().map(|emod| emod.id())
+    }
+}
+
+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],
+}
+
+impl<'a> ClampsByBlockIterator<'a> {
+    fn new(group: &'a RowGroup) -> Self {
+        ClampsByBlockIterator {
+            position: 0,
+            rows: &group.rows,
+        }
+    }
+}
+
+impl<'a> Iterator for ClampsByBlockIterator<'a> {
+    type Item = (BlockNumber, &'a [EntityModification]);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // Make sure we start on a clamp
+        while self.position < self.rows.len() && !self.rows[self.position].is_clamp() {
+            self.position += 1;
+        }
+        if self.position >= self.rows.len() {
+            return None;
+        }
+        let block = self.rows[self.position].block();
+        let mut next = self.position;
+        // Collect consecutive clamps
+        while next < self.rows.len()
+            && self.rows[next].block() == block
+            && self.rows[next].is_clamp()
+        {
+            next += 1;
+        }
+        let res = Some((block, &self.rows[self.position..next]));
+        self.position = next;
+        res
+    }
+}
+
+/// A list of entity changes with one group per entity type
+#[derive(Debug, CacheWeight)]
+pub struct RowGroups {
+    pub groups: Vec<RowGroup>,
+    logger: Logger,
+}
+
+impl RowGroups {
+    fn new(logger: Logger) -> Self {
+        Self {
+            groups: Vec::new(),
+            logger,
+        }
+    }
+
+    fn group(&self, entity_type: &EntityType) -> Option<&RowGroup> {
+        self.groups
+            .iter()
+            .find(|group| &group.entity_type == entity_type)
+    }
+
+    /// Return a mutable reference to an existing group, or create a new one
+    /// if there isn't one yet and return a reference to that
+    fn group_entry(&mut self, entity_type: &EntityType) -> &mut RowGroup {
+        let pos = self
+            .groups
+            .iter()
+            .position(|group| &group.entity_type == entity_type);
+        match pos {
+            Some(pos) => &mut self.groups[pos],
+            None => {
+                self.groups.push(RowGroup::new(entity_type.clone()));
+                // unwrap: we just pushed an entry
+                self.groups.last_mut().unwrap()
+            }
+        }
+    }
+
+    fn entity_count(&self) -> usize {
+        self.groups.iter().map(|group| group.row_count()).sum()
+    }
+
+    fn append(&mut self, other: RowGroups) -> Result<(), StoreError> {
+        for group in other.groups {
+            self.group_entry(&group.entity_type).append(group)?;
+        }
+        Ok(())
+    }
+}
+
+/// Data sources data grouped by block
+#[derive(Debug)]
+pub struct DataSources {
+    pub entries: Vec<(BlockPtr, Vec<StoredDynamicDataSource>)>,
+}
+
+impl DataSources {
+    fn new(ptr: BlockPtr, entries: Vec<StoredDynamicDataSource>) -> Self {
+        let entries = if entries.is_empty() {
+            Vec::new()
+        } else {
+            vec![(ptr, entries)]
+        };
+        DataSources { entries }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.entries.iter().all(|(_, dss)| dss.is_empty())
+    }
+
+    fn append(&mut self, mut other: DataSources) {
+        self.entries.append(&mut other.entries);
+    }
+}
+
+/// Indicate to code that looks up entities from the in-memory batch whether
+/// the entity in question will be written or removed at the block of the
+/// lookup
+#[derive(Debug, PartialEq)]
+pub enum EntityOp<'a> {
+    /// There is a new version of the entity that will be written
+    Write {
+        key: &'a EntityKey,
+        entity: &'a Entity,
+    },
+    /// The entity has been removed
+    Remove { key: &'a EntityKey },
+}
+
+/// A write batch. This data structure encapsulates all the things that need
+/// to be changed to persist the output of mappings up to a certain block.
+#[derive(Debug)]
+pub struct Batch {
+    /// The last block for which this batch contains changes
+    pub block_ptr: BlockPtr,
+    /// The timestamp for each block number we've seen as batches have been
+    /// appended to this one. This will have one entry for each block where
+    /// the subgraph performed a write. Entries are in ascending order of
+    /// block number
+    pub block_times: Vec<(BlockNumber, BlockTime)>,
+    /// The first block for which this batch contains changes
+    pub first_block: BlockNumber,
+    /// The firehose cursor corresponding to `block_ptr`
+    pub firehose_cursor: FirehoseCursor,
+    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 {
+    pub fn new(
+        block_ptr: BlockPtr,
+        block_time: BlockTime,
+        firehose_cursor: FirehoseCursor,
+        mut raw_mods: Vec<EntityModification>,
+        data_sources: Vec<StoredDynamicDataSource>,
+        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;
+
+        // Sort the modifications such that writes and clamps are
+        // consecutive. It's not needed for correctness but helps with some
+        // of the iterations, especially when we iterate with
+        // `clamps_by_block` so we get only one run for each block
+        raw_mods.sort_unstable_by_key(|emod| match emod {
+            EntityModification::Insert { .. } => 2,
+            EntityModification::Overwrite { .. } => 1,
+            EntityModification::Remove { .. } => 0,
+        });
+
+        let mut mods = RowGroups::new(logger);
+
+        for m in raw_mods {
+            mods.group_entry(&m.key().entity_type).push(m, block)?;
+        }
+
+        let data_sources = DataSources::new(block_ptr.cheap_clone(), data_sources);
+        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)];
+        let mut batch = Self {
+            block_ptr,
+            first_block,
+            block_times,
+            firehose_cursor,
+            mods,
+            data_sources,
+            deterministic_errors,
+            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(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;
+        self.block_times.append(&mut batch.block_times);
+        self.firehose_cursor = batch.firehose_cursor;
+        self.mods.append(batch.mods)?;
+        self.data_sources.append(batch.data_sources);
+        self.deterministic_errors
+            .append(&mut batch.deterministic_errors);
+        self.offchain_to_remove.append(batch.offchain_to_remove);
+        Ok(())
+    }
+
+    /// Append `batch` to `self` so that writing `self` afterwards has the
+    /// same effect as writing `self` first and then `batch` in separate
+    /// transactions.
+    ///
+    /// When this method returns an `Err`, the batch is marked as not
+    /// healthy by setting `self.error` to `Some(_)` and must not be written
+    /// as it will be in an indeterminate state.
+    pub fn append(&mut self, batch: Batch) -> Result<(), StoreError> {
+        let res = self.append_inner(batch);
+        if let Err(e) = &res {
+            self.error = Some(e.clone());
+        }
+        self.weigh();
+        res
+    }
+
+    pub fn entity_count(&self) -> usize {
+        self.mods.entity_count()
+    }
+
+    /// Find out whether the latest operation for the entity with type
+    /// `entity_type` and `id` is going to write that entity, i.e., insert
+    /// or overwrite it, or if it is going to remove it. If no change will
+    /// be made to the entity, return `None`
+    pub fn last_op(&self, key: &EntityKey, block: BlockNumber) -> Option<EntityOp<'_>> {
+        self.mods.group(&key.entity_type)?.last_op(key, block)
+    }
+
+    pub fn effective_ops(
+        &self,
+        entity_type: &EntityType,
+        at: BlockNumber,
+    ) -> impl Iterator<Item = EntityOp<'_>> {
+        self.mods
+            .group(entity_type)
+            .map(|group| group.effective_ops(at))
+            .into_iter()
+            .flatten()
+    }
+
+    pub fn new_data_sources(
+        &self,
+        at: BlockNumber,
+    ) -> impl Iterator<Item = &StoredDynamicDataSource> {
+        self.data_sources
+            .entries
+            .iter()
+            .filter(move |(ptr, _)| ptr.number <= at)
+            .flat_map(|(_, ds)| ds)
+            .filter(|ds| {
+                !self
+                    .offchain_to_remove
+                    .entries
+                    .iter()
+                    .any(|(_, entries)| entries.contains(ds))
+            })
+    }
+
+    pub fn groups(&self) -> impl Iterator<Item = &RowGroup> {
+        self.mods.groups.iter()
+    }
+
+    fn weigh(&mut self) {
+        self.indirect_weight = self.mods.indirect_weight();
+    }
+}
+
+impl CacheWeight for Batch {
+    fn indirect_weight(&self) -> usize {
+        self.indirect_weight
+    }
+}
+
+pub struct WriteChunker<'a> {
+    group: &'a RowGroup,
+    chunk_size: usize,
+    position: usize,
+}
+
+impl<'a> WriteChunker<'a> {
+    fn new(group: &'a RowGroup, chunk_size: usize) -> Self {
+        Self {
+            group,
+            chunk_size,
+            position: 0,
+        }
+    }
+}
+
+impl<'a> Iterator for WriteChunker<'a> {
+    type Item = WriteChunk<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // Produce a chunk according to the current `self.position`
+        let res = if self.position < self.group.rows.len() {
+            Some(WriteChunk {
+                group: self.group,
+                chunk_size: self.chunk_size,
+                position: self.position,
+            })
+        } else {
+            None
+        };
+
+        // Advance `self.position` to the start of the next chunk
+        let mut count = 0;
+        while count < self.chunk_size && self.position < self.group.rows.len() {
+            if self.group.rows[self.position].is_write() {
+                count += 1;
+            }
+            self.position += 1;
+        }
+
+        res
+    }
+}
+
+#[derive(Debug)]
+pub struct WriteChunk<'a> {
+    group: &'a RowGroup,
+    chunk_size: usize,
+    position: usize,
+}
+
+impl<'a> WriteChunk<'a> {
+    pub fn is_empty(&'a self) -> bool {
+        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,
+            chunk_size: self.chunk_size,
+            position: self.position,
+            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> {
+    type Item = EntityWrite<'a>;
+
+    type IntoIter = WriteChunkIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        WriteChunkIter {
+            group: self.group,
+            chunk_size: self.chunk_size,
+            position: self.position,
+            count: 0,
+        }
+    }
+}
+
+pub struct WriteChunkIter<'a> {
+    group: &'a RowGroup,
+    chunk_size: usize,
+    position: usize,
+    count: usize,
+}
+
+impl<'a> Iterator for WriteChunkIter<'a> {
+    type Item = EntityWrite<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.count < self.chunk_size && self.position < self.group.rows.len() {
+            let insert = self.group.rows[self.position].as_write();
+            self.position += 1;
+            if insert.is_some() {
+                self.count += 1;
+                return insert;
+            }
+        }
+        None
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::collections::HashMap;
+    use std::sync::Arc;
+
+    use crate::{
+        components::store::{
+            BlockNumber, EntityType, StoreError, write::EntityModification, write::EntityOp,
+        },
+        data::{store::Id, value::Word},
+        entity,
+        prelude::DeploymentHash,
+        schema::InputSchema,
+    };
+    use lazy_static::lazy_static;
+
+    use super::{LastMod, RowGroup};
+
+    #[track_caller]
+    fn check_runs(values: &[usize], blocks: &[BlockNumber], exp: &[(BlockNumber, &[usize])]) {
+        fn as_id(n: &usize) -> Id {
+            Id::String(Word::from(n.to_string()))
+        }
+
+        assert_eq!(values.len(), blocks.len());
+
+        let rows: Vec<_> = values
+            .iter()
+            .zip(blocks.iter())
+            .map(|(value, block)| EntityModification::Remove {
+                key: ROW_GROUP_TYPE.key(Id::String(Word::from(value.to_string()))),
+                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,
+            last_mod,
+        };
+        let act = group
+            .clamps_by_block()
+            .map(|(block, entries)| {
+                (
+                    block,
+                    entries
+                        .iter()
+                        .map(|entry| entry.id().clone())
+                        .collect::<Vec<_>>(),
+                )
+            })
+            .collect::<Vec<_>>();
+        let exp = Vec::from_iter(
+            exp.iter()
+                .map(|(block, values)| (*block, Vec::from_iter(values.iter().map(as_id)))),
+        );
+        assert_eq!(exp, act);
+    }
+
+    #[test]
+    fn run_iterator() {
+        type RunList<'a> = &'a [(i32, &'a [usize])];
+
+        let exp: RunList<'_> = &[(1, &[10, 11, 12])];
+        check_runs(&[10, 11, 12], &[1, 1, 1], exp);
+
+        let exp: RunList<'_> = &[(1, &[10, 11, 12]), (2, &[20, 21])];
+        check_runs(&[10, 11, 12, 20, 21], &[1, 1, 1, 2, 2], exp);
+
+        let exp: RunList<'_> = &[(1, &[10]), (2, &[20]), (1, &[11])];
+        check_runs(&[10, 20, 11], &[1, 2, 1], exp);
+    }
+
+    // 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! }
+      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();
+        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();
+        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
+    #[derive(Clone, Debug)]
+    enum Mod {
+        Ins(BlockNumber),
+        Ovw(BlockNumber),
+        Rem(BlockNumber),
+        // clamped insert
+        InsC(BlockNumber, BlockNumber),
+        // clamped overwrite
+        OvwC(BlockNumber, BlockNumber),
+    }
+
+    impl From<&Mod> for EntityModification {
+        fn from(value: &Mod) -> Self {
+            use Mod::*;
+
+            let value = value.clone();
+            let key = THING_TYPE.parse_key("one").unwrap();
+            match value {
+                Ins(block) => EntityModification::Insert {
+                    key,
+                    data: Arc::new(entity! { SCHEMA => id: "one", count: block }),
+                    block,
+                    end: None,
+                },
+                Ovw(block) => EntityModification::Overwrite {
+                    key,
+                    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: Arc::new(entity! { SCHEMA => id: "one", count: block }),
+                    block,
+                    end: Some(end),
+                },
+                OvwC(block, end) => EntityModification::Overwrite {
+                    key,
+                    data: Arc::new(entity! { SCHEMA => id: "one", count: block }),
+                    block,
+                    end: Some(end),
+                },
+            }
+        }
+    }
+
+    /// Helper to construct a `RowGroup`
+    #[derive(Debug)]
+    struct Group {
+        group: RowGroup,
+    }
+
+    impl Group {
+        fn new() -> Self {
+            Self {
+                group: RowGroup::new(THING_TYPE.clone()),
+            }
+        }
+
+        fn append(&mut self, mods: &[Mod]) -> Result<(), StoreError> {
+            for m in mods {
+                self.group.append_row(EntityModification::from(m))?
+            }
+            Ok(())
+        }
+
+        fn with(mods: &[Mod]) -> Result<Group, StoreError> {
+            let mut group = Self::new();
+            group.append(mods)?;
+            Ok(group)
+        }
+    }
+
+    impl PartialEq<&[Mod]> for Group {
+        fn eq(&self, mods: &&[Mod]) -> bool {
+            let mods: Vec<_> = mods.iter().map(EntityModification::from).collect();
+            self.group.rows == mods
+        }
+    }
+
+    #[test]
+    fn append() {
+        use Mod::*;
+
+        let res = Group::with(&[Ins(1), Ins(2)]);
+        assert!(res.is_err());
+
+        let res = Group::with(&[Ovw(1), Ins(2)]);
+        assert!(res.is_err());
+
+        let res = Group::with(&[Ins(1), Rem(2), Rem(3)]);
+        assert!(res.is_err());
+
+        let res = Group::with(&[Ovw(1), Rem(2), Rem(3)]);
+        assert!(res.is_err());
+
+        let res = Group::with(&[Ovw(1), Rem(2), Ovw(3)]);
+        assert!(res.is_err());
+
+        let group = Group::with(&[Ins(1), Ovw(2), Rem(3)]).unwrap();
+        assert_eq!(group, &[InsC(1, 2), InsC(2, 3)]);
+
+        let group = Group::with(&[Ovw(1), Rem(4)]).unwrap();
+        assert_eq!(group, &[OvwC(1, 4)]);
+
+        let group = Group::with(&[Ins(1), Rem(4)]).unwrap();
+        assert_eq!(group, &[InsC(1, 4)]);
+
+        let group = Group::with(&[Ins(1), Rem(2), Ins(3)]).unwrap();
+        assert_eq!(group, &[InsC(1, 2), Ins(3)]);
+
+        let group = Group::with(&[Ovw(1), Rem(2), Ins(3)]).unwrap();
+        assert_eq!(group, &[OvwC(1, 2), Ins(3)]);
+    }
+
+    #[test]
+    fn last_op() {
+        #[track_caller]
+        fn is_remove(group: &RowGroup, at: BlockNumber) {
+            let key = THING_TYPE.parse_key("one").unwrap();
+            let op = group.last_op(&key, at).unwrap();
+
+            assert!(
+                matches!(op, EntityOp::Remove { .. }),
+                "op must be a remove at {} but is {:?}",
+                at,
+                op
+            );
+        }
+        #[track_caller]
+        fn is_write(group: &RowGroup, at: BlockNumber) {
+            let key = THING_TYPE.parse_key("one").unwrap();
+            let op = group.last_op(&key, at).unwrap();
+
+            assert!(
+                matches!(op, EntityOp::Write { .. }),
+                "op must be a write at {} but is {:?}",
+                at,
+                op
+            );
+        }
+
+        use Mod::*;
+
+        let key = THING_TYPE.parse_key("one").unwrap();
+
+        // This will result in two mods int the group:
+        //   [ InsC(1,2), InsC(2,3) ]
+        let group = Group::with(&[Ins(1), Ovw(2), Rem(3)]).unwrap().group;
+
+        is_remove(&group, 5);
+        is_remove(&group, 4);
+        is_remove(&group, 3);
+
+        is_write(&group, 2);
+        is_write(&group, 1);
+
+        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 72af7800c66..40bdc10f8eb 100644
--- a/graph/src/components/subgraph/host.rs
+++ b/graph/src/components/subgraph/host.rs
@@ -4,15 +4,16 @@ use std::time::Instant;
 
 use anyhow::Error;
 use async_trait::async_trait;
-use futures::sync::mpsc;
+use futures01::sync::mpsc;
 
+use crate::components::metrics::gas::GasMetrics;
 use crate::components::store::SubgraphFork;
 use crate::data_source::{
     DataSource, DataSourceTemplate, MappingTrigger, TriggerData, TriggerWithHandler,
 };
 use crate::prelude::*;
+use crate::runtime::HostExportError;
 use crate::{blockchain::Blockchain, components::subgraph::SharedProofOfIndexing};
-use crate::{components::metrics::HistogramVec, runtime::DeterministicHostError};
 
 #[derive(Debug)]
 pub enum MappingError {
@@ -27,9 +28,14 @@ impl From<anyhow::Error> for MappingError {
     }
 }
 
-impl From<DeterministicHostError> for MappingError {
-    fn from(value: DeterministicHostError) -> MappingError {
-        MappingError::Unknown(value.inner())
+impl From<HostExportError> for MappingError {
+    fn from(value: HostExportError) -> MappingError {
+        match value {
+            HostExportError::PossibleReorg(e) => MappingError::PossibleReorg(e),
+            HostExportError::Deterministic(e) | HostExportError::Unknown(e) => {
+                MappingError::Unknown(e)
+            }
+        }
     }
 }
 
@@ -41,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.
@@ -58,12 +73,12 @@ pub trait RuntimeHost<C: Blockchain>: Send + Sync + 'static {
     async fn process_mapping_trigger(
         &self,
         logger: &Logger,
-        block_ptr: BlockPtr,
         trigger: TriggerWithHandler<MappingTrigger<C>>,
-        state: BlockState<C>,
+        state: BlockState,
         proof_of_indexing: SharedProofOfIndexing,
         debug_fork: &Option<Arc<dyn SubgraphFork>>,
-    ) -> Result<BlockState<C>, MappingError>;
+        instrument: bool,
+    ) -> Result<BlockState, MappingError>;
 
     /// Block number in which this host was created.
     /// Returns `None` for static data sources.
@@ -76,19 +91,25 @@ 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 {
     handler_execution_time: Box<HistogramVec>,
     host_fn_execution_time: Box<HistogramVec>,
+    eth_call_execution_time: Box<HistogramVec>,
+    pub gas_metrics: GasMetrics,
     pub stopwatch: StopwatchMetrics,
 }
 
 impl HostMetrics {
     pub fn new(
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
         subgraph: &str,
         stopwatch: StopwatchMetrics,
+        gas_metrics: GasMetrics,
     ) -> Self {
         let handler_execution_time = registry
             .new_deployment_histogram_vec(
@@ -99,6 +120,16 @@ impl HostMetrics {
                 vec![0.1, 0.5, 1.0, 10.0, 100.0],
             )
             .expect("failed to create `deployment_handler_execution_time` histogram");
+        let eth_call_execution_time = registry
+            .new_deployment_histogram_vec(
+                "deployment_eth_call_execution_time",
+                "Measures the execution time for eth_call",
+                subgraph,
+                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");
+
         let host_fn_execution_time = registry
             .new_deployment_histogram_vec(
                 "deployment_host_fn_execution_time",
@@ -112,6 +143,8 @@ impl HostMetrics {
             handler_execution_time,
             host_fn_execution_time,
             stopwatch,
+            gas_metrics,
+            eth_call_execution_time,
         }
     }
 
@@ -127,6 +160,17 @@ impl HostMetrics {
             .observe(duration);
     }
 
+    pub fn observe_eth_call_execution_time(
+        &self,
+        duration: f64,
+        contract_name: &str,
+        method: &str,
+    ) {
+        self.eth_call_execution_time
+            .with_label_values(&[contract_name, method][..])
+            .observe(duration);
+    }
+
     pub fn time_host_fn_execution_region(
         self: Arc<HostMetrics>,
         fn_name: &'static str,
diff --git a/graph/src/components/subgraph/instance.rs b/graph/src/components/subgraph/instance.rs
index f3df2c672e4..ae4a91ed540 100644
--- a/graph/src/components/subgraph/instance.rs
+++ b/graph/src/components/subgraph/instance.rs
@@ -1,53 +1,113 @@
 use crate::{
-    blockchain::Blockchain,
-    components::store::{EntityKey, 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::*,
-    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 {
@@ -58,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 {
@@ -68,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 {
@@ -79,7 +140,14 @@ impl<C: Blockchain> BlockState<C> {
         !self.created_data_sources.is_empty()
     }
 
-    pub fn drain_created_data_sources(&mut self) -> Vec<DataSourceTemplateInfo<C>> {
+    pub fn has_created_on_chain_data_sources(&self) -> bool {
+        assert!(!self.in_handler);
+        self.created_data_sources
+            .iter()
+            .any(|ds| matches!(ds.template, InstanceDSTemplate::Onchain(_)))
+    }
+
+    pub fn drain_created_data_sources(&mut self) -> Vec<InstanceDSTemplateInfo> {
         assert!(!self.in_handler);
         std::mem::take(&mut self.created_data_sources)
     }
@@ -106,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);
     }
@@ -114,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 6976de1e2d2..45ab3b16ac4 100644
--- a/graph/src/components/subgraph/mod.rs
+++ b/graph/src/components/subgraph/mod.rs
@@ -2,17 +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 06d4e9f41e8..227a7a6c561 100644
--- a/graph/src/components/subgraph/proof_of_indexing/event.rs
+++ b/graph/src/components/subgraph/proof_of_indexing/event.rs
@@ -1,11 +1,11 @@
-use crate::prelude::{impl_slog_value, Value};
+use crate::components::subgraph::Entity;
+use crate::prelude::impl_slog_value;
 use stable_hash_legacy::StableHasher;
-use std::collections::{BTreeMap, HashMap};
+use std::collections::BTreeMap;
 use std::fmt;
-use strum::AsStaticRef as _;
-use strum_macros::AsStaticStr;
+use strum_macros::IntoStaticStr;
 
-#[derive(AsStaticStr)]
+#[derive(IntoStaticStr)]
 pub enum ProofOfIndexingEvent<'a> {
     /// For when an entity is removed from the store.
     RemoveEntity { entity_type: &'a str, id: &'a str },
@@ -13,7 +13,7 @@ pub enum ProofOfIndexingEvent<'a> {
     SetEntity {
         entity_type: &'a str,
         id: &'a str,
-        data: &'a HashMap<String, Value>,
+        data: &'a Entity,
     },
     /// For when a deterministic error has happened.
     ///
@@ -60,11 +60,11 @@ 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::*;
 
-        self.as_static()
-            .stable_hash(sequence_number.next_child(), state);
+        let str: &'static str = self.into();
+        str.stable_hash(sequence_number.next_child(), state);
         match self {
             RemoveEntity { entity_type, id } => {
                 entity_type.stable_hash(sequence_number.next_child(), state);
@@ -77,7 +77,9 @@ impl stable_hash_legacy::StableHash for ProofOfIndexingEvent<'_> {
             } => {
                 entity_type.stable_hash(sequence_number.next_child(), state);
                 id.stable_hash(sequence_number.next_child(), state);
-                data.stable_hash(sequence_number.next_child(), state);
+
+                stable_hash_legacy::utils::AsUnorderedSet(*data)
+                    .stable_hash(sequence_number.next_child(), state);
             }
             DeterministicError { redacted_events } => {
                 redacted_events.stable_hash(sequence_number.next_child(), state)
@@ -103,7 +105,8 @@ impl stable_hash::StableHash for ProofOfIndexingEvent<'_> {
             } => {
                 entity_type.stable_hash(field_address.child(0), state);
                 id.stable_hash(field_address.child(1), state);
-                data.stable_hash(field_address.child(2), state);
+                stable_hash::utils::AsUnorderedSet(*data)
+                    .stable_hash::<_>(field_address.child(2), state);
                 2
             }
             Self::DeterministicError { redacted_events } => {
@@ -122,7 +125,7 @@ impl stable_hash::StableHash for ProofOfIndexingEvent<'_> {
 /// sorted.
 impl fmt::Debug for ProofOfIndexingEvent<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut builder = f.debug_struct(self.as_static());
+        let mut builder = f.debug_struct(self.into());
         match self {
             Self::RemoveEntity { entity_type, id } => {
                 builder.field("entity_type", entity_type);
@@ -135,7 +138,14 @@ impl fmt::Debug for ProofOfIndexingEvent<'_> {
             } => {
                 builder.field("entity_type", entity_type);
                 builder.field("id", id);
-                builder.field("data", &data.iter().collect::<BTreeMap<_, _>>());
+                builder.field(
+                    "data",
+                    &data
+                        .sorted_ref()
+                        .iter()
+                        .cloned()
+                        .collect::<BTreeMap<_, _>>(),
+                );
             }
             Self::DeterministicError { redacted_events } => {
                 builder.field("redacted_events", redacted_events);
diff --git a/graph/src/components/subgraph/proof_of_indexing/mod.rs b/graph/src/components/subgraph/proof_of_indexing/mod.rs
index 90562d37595..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,30 +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::prelude::{BlockPtr, DeploymentHash, Value};
+    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>) {
@@ -56,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 [
@@ -68,13 +147,12 @@ mod tests {
             // pretty foolproof so that the actual usage will also match.
 
             // Create a database which stores intermediate PoIs
-            let mut db = HashMap::<String, Vec<u8>>::new();
+            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);
@@ -110,8 +188,8 @@ mod tests {
 
             let online = hex::encode(finisher.finish());
             let offline = hex::encode(offline);
-            assert_eq!(&online, &offline);
-            assert_eq!(&online, hardcoded);
+            assert_eq!(&online, &offline, "case: {}", case.name);
+            assert_eq!(&online, hardcoded, "case: {}", case.name);
 
             if let Some(prev) = cache.insert(offline, case.name) {
                 panic!("Found conflict for case: {} == {}", case.name, prev);
@@ -130,14 +208,36 @@ mod tests {
     /// in each case the reference and online versions match
     #[test]
     fn online_vs_reference() {
-        let data = hashmap! {
-            "val".to_owned() => Value::Int(1)
-        };
-        let data_empty = hashmap! {};
-        let data2 = hashmap! {
-            "key".to_owned() => Value::String("s".to_owned()),
-            "null".to_owned() => Value::Null,
-        };
+        let id = DeploymentHash::new("Qm123").unwrap();
+
+        let data_schema =
+            InputSchema::parse_latest("type User @entity { id: String!, val: Int }", id.clone())
+                .unwrap();
+        let data = data_schema
+            .make_entity(hashmap! {
+                "id".into() => Value::String("id".to_owned()),
+                "val".into() => Value::Int(1)
+            })
+            .unwrap();
+
+        let empty_schema =
+            InputSchema::parse_latest("type User @entity { id: String! }", id.clone()).unwrap();
+        let data_empty = empty_schema
+            .make_entity(hashmap! { "id".into() => Value::String("id".into())})
+            .unwrap();
+
+        let data2_schema = InputSchema::parse_latest(
+            "type User @entity { id: String!, key: String!, null: String }",
+            id,
+        )
+        .unwrap();
+        let data2 = data2_schema
+            .make_entity(hashmap! {
+                "id".into() => Value::String("id".to_owned()),
+                "key".into() => Value::String("s".to_owned()),
+                "null".into() => Value::Null,
+            })
+            .unwrap();
 
         let mut cases = vec![
             // Simple case of basically nothing
@@ -147,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,
                 },
@@ -155,11 +255,11 @@ mod tests {
             // Add an event
             Case {
                 name: "one_event",
-                legacy: "9241634bfc8a9a12c796a0de6f326326a74967cd477ee7ce78fbac20a9e9c303",
-                fast: "bb3c37659d4bc799b9dcf3d17b1b1e93847f5fc0b2c50ee6a27f13b5c07f7e97",
+                legacy: "96640d7a35405524bb21da8d86f7a51140634f44568cf9f7df439d0b2b01a435",
+                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! [
@@ -182,11 +282,11 @@ mod tests {
             // Try adding a couple more blocks, including an empty block on the end
             Case {
                 name: "multiple_blocks",
-                legacy: "775fa30bbaef2a8659456a317923a36f46e3715e6c9cf43203dd3486af4e361f",
-                fast: "3bb882049e8f4a11cd4a7a005c6ce3b3c779a0e90057a9556c595660e626268d",
+                legacy: "a0346ee0d7e0518f73098b6f9dc020f1cf564fb88e09779abfdf5da736de5e82",
+                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! [
@@ -220,11 +320,11 @@ mod tests {
             // Try adding another causality region
             Case {
                 name: "causality_regions",
-                legacy: "13e6fd2b581911c80d935d4f098b40ef3d87cbc564b5a635c81b06091a381e54",
-                fast: "b2cb70acd4a1337a67df810fe4c5c2fb3d3a3b2b8eb137dbb592bd6014869362",
+                legacy: "cc9449860e5b19b76aa39d6e05c5a560d1cb37a93d4bf64669feb47cfeb452fa",
+                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! [
@@ -282,11 +382,11 @@ mod tests {
             // Back to the one event case, but try adding some data.
             Case {
                 name: "data",
-                legacy: "cd3020511cf4c88dd2be542aca4f95bb2a67b06e29f444bcdf44009933b8ff31",
-                fast: "a992ba24702615a3f591014f7351acf85a35b75e1f8646fc8d77509c4b5d31ed",
+                legacy: "d304672a249293ee928d99d9cb0576403bdc4b6dbadeb49b98f527277297cdcc",
+                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 f9d93151c34..b3043e12473 100644
--- a/graph/src/components/subgraph/proof_of_indexing/online.rs
+++ b/graph/src/components/subgraph/proof_of_indexing/online.rs
@@ -5,10 +5,13 @@
 use super::{ProofOfIndexingEvent, ProofOfIndexingVersion};
 use crate::{
     blockchain::BlockPtr,
-    prelude::{debug, BlockNumber, DeploymentHash, Logger, ENV_VARS},
+    data::store::Id,
+    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, *,
@@ -16,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,
@@ -30,6 +32,8 @@ enum Hashers {
     Legacy(SetHasher),
 }
 
+const STABLE_HASH_LEN: usize = 32;
+
 impl Hashers {
     fn new(version: ProofOfIndexingVersion) -> Self {
         match version {
@@ -131,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);
                 }
@@ -145,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,
         ];
@@ -166,7 +175,7 @@ pub struct ProofOfIndexing {
     /// some data sources (eg: IPFS files) may be unreliable and therefore cannot mix
     /// state with other data sources. This may also give us some freedom to change
     /// the order of triggers in the future.
-    per_causality_region: HashMap<String, BlockEventStream>,
+    per_causality_region: HashMap<Id, BlockEventStream>,
 }
 
 impl fmt::Debug for ProofOfIndexing {
@@ -210,7 +219,8 @@ impl ProofOfIndexing {
                 logger,
                 "Proof of indexing event";
                 "event" => &event,
-                "causality_region" => causality_region
+                "causality_region" => causality_region,
+                "block_number" => self.block_number
             );
         }
 
@@ -226,20 +236,24 @@ impl ProofOfIndexing {
     where
         F: FnOnce(&mut BlockEventStream) -> T,
     {
-        if let Some(causality_region) = self.per_causality_region.get_mut(causality_region) {
+        let causality_region = Id::String(causality_region.to_owned().into());
+        if let Some(causality_region) = self.per_causality_region.get_mut(&causality_region) {
             f(causality_region)
         } else {
             let mut entry = BlockEventStream::new(self.block_number, self.version);
             let result = f(&mut entry);
-            self.per_causality_region
-                .insert(causality_region.to_owned(), entry);
+            self.per_causality_region.insert(causality_region, entry);
             result
         }
     }
 
-    pub fn take(self) -> HashMap<String, BlockEventStream> {
+    pub fn take(self) -> HashMap<Id, BlockEventStream> {
         self.per_causality_region
     }
+
+    pub fn get_block(&self) -> BlockNumber {
+        self.block_number
+    }
 }
 
 pub struct ProofOfIndexingFinisher {
@@ -264,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,
@@ -273,7 +287,7 @@ impl ProofOfIndexingFinisher {
         }
     }
 
-    pub fn add_causality_region(&mut self, name: &str, region: &[u8]) {
+    pub fn add_causality_region(&mut self, name: &Id, region: &[u8]) {
         let mut state = Hashers::from_bytes(region);
 
         // Finish the blocks vec by writing kvp[v], PoICausalityRegion.blocks.len()
@@ -310,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 cfb2c2ffa2c..361a704e754 100644
--- a/graph/src/components/subgraph/registrar.rs
+++ b/graph/src/components/subgraph/registrar.rs
@@ -44,6 +44,8 @@ pub trait SubgraphRegistrar: Send + Sync + 'static {
         debug_fork: Option<DeploymentHash>,
         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>;
@@ -53,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
new file mode 100644
index 00000000000..3e4db56c9ed
--- /dev/null
+++ b/graph/src/components/subgraph/settings.rs
@@ -0,0 +1,88 @@
+//! Facilities for dealing with subgraph-specific settings
+use std::fs::read_to_string;
+
+use crate::{
+    anyhow,
+    prelude::{SubgraphName, regex::Regex},
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub enum Predicate {
+    #[serde(alias = "name", with = "serde_regex")]
+    Name(Regex),
+}
+
+impl Predicate {
+    fn matches(&self, name: &SubgraphName) -> bool {
+        match self {
+            Predicate::Name(rx) => rx.is_match(name.as_str()),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+pub struct Setting {
+    #[serde(alias = "match")]
+    pred: Predicate,
+    pub history_blocks: i32,
+}
+
+impl Setting {
+    fn matches(&self, name: &SubgraphName) -> bool {
+        self.pred.matches(name)
+    }
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Serialize)]
+pub struct Settings {
+    #[serde(alias = "setting")]
+    settings: Vec<Setting>,
+}
+
+impl Settings {
+    pub fn from_file(path: &str) -> Result<Self, anyhow::Error> {
+        Self::from_str(&read_to_string(path)?)
+    }
+
+    fn from_str(toml: &str) -> Result<Self, anyhow::Error> {
+        toml::from_str::<Self>(toml).map_err(anyhow::Error::from)
+    }
+
+    pub fn for_name(&self, name: &SubgraphName) -> Option<&Setting> {
+        self.settings.iter().find(|setting| setting.matches(name))
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::{Predicate, Settings};
+
+    #[test]
+    fn parses_correctly() {
+        let content = r#"
+        [[setting]]
+        match = { name = ".*" }
+        history_blocks = 10000
+
+        [[setting]]
+        match = { name = "xxxxx" }
+        history_blocks = 10000
+
+        [[setting]]
+        match = { name = ".*!$" }
+        history_blocks = 10000
+        "#;
+
+        let section = Settings::from_str(content).unwrap();
+        assert_eq!(section.settings.len(), 3);
+
+        let Predicate::Name(rule1) = &section.settings[0].pred;
+        assert_eq!(rule1.as_str(), ".*");
+
+        let Predicate::Name(rule2) = &section.settings[1].pred;
+        assert_eq!(rule2.as_str(), "xxxxx");
+        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 ce02a212a6c..f21fe5b7894 100644
--- a/graph/src/components/trigger_processor.rs
+++ b/graph/src/components/trigger_processor.rs
@@ -3,29 +3,94 @@ 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
     C: Blockchain,
     T: RuntimeHostBuilder<C>,
 {
-    async fn process_trigger(
-        &self,
+    async fn process_trigger<'a>(
+        &'a self,
         logger: &Logger,
-        hosts: &[Arc<T::Host>],
+        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>,
-    ) -> Result<BlockState<C>, MappingError>;
+        instrument: bool,
+    ) -> 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 c25cdbc0e88..4177da59eae 100644
--- a/graph/src/data/graphql/ext.rs
+++ b/graph/src/data/graphql/ext.rs
@@ -1,16 +1,18 @@
+use anyhow::Error;
+use inflector::Inflector;
+
 use super::ObjectOrInterface;
-use crate::data::schema::{META_FIELD_TYPE, SCHEMA_TYPE_NAME};
 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::ENV_VARS;
+use crate::prelude::{ENV_VARS, ValueType};
+use crate::schema::{META_FIELD_TYPE, SCHEMA_TYPE_NAME};
 use std::collections::{BTreeMap, HashMap};
 
 pub trait ObjectTypeExt {
     fn field(&self, name: &str) -> Option<&Field>;
     fn is_meta(&self) -> bool;
-    fn is_immutable(&self) -> bool;
 }
 
 impl ObjectTypeExt for ObjectType {
@@ -21,16 +23,6 @@ impl ObjectTypeExt for ObjectType {
     fn is_meta(&self) -> bool {
         self.name == META_FIELD_TYPE
     }
-
-    fn is_immutable(&self) -> bool {
-        self.find_directive("entity")
-            .and_then(|dir| dir.argument("immutable"))
-            .map(|value| match value {
-                Value::Boolean(b) => *b,
-                _ => false,
-            })
-            .unwrap_or(false)
-    }
 }
 
 impl ObjectTypeExt for InterfaceType {
@@ -41,10 +33,6 @@ impl ObjectTypeExt for InterfaceType {
     fn is_meta(&self) -> bool {
         false
     }
-
-    fn is_immutable(&self) -> bool {
-        false
-    }
 }
 
 pub trait DocumentExt {
@@ -64,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>;
@@ -171,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()),
@@ -225,10 +196,26 @@ impl DocumentExt for Document {
     }
 }
 
+pub trait DefinitionExt {
+    fn is_root_query_type(&self) -> bool;
+}
+
+impl DefinitionExt for Definition {
+    fn is_root_query_type(&self) -> bool {
+        match self {
+            Definition::TypeDefinition(TypeDefinition::Object(t)) => t.name == "Query",
+            _ => false,
+        }
+    }
+}
+
 pub trait TypeExt {
     fn get_base_type(&self) -> &str;
     fn is_list(&self) -> bool;
     fn is_non_null(&self) -> bool;
+    fn value_type(&self) -> Result<ValueType, Error> {
+        self.get_base_type().parse()
+    }
 }
 
 impl TypeExt for Type {
@@ -250,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(_))
     }
 }
 
@@ -309,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 {
@@ -318,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 {
@@ -332,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> {
@@ -375,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 = "
@@ -402,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];
@@ -425,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/effort.rs b/graph/src/data/graphql/load_manager.rs
similarity index 76%
rename from graph/src/data/graphql/effort.rs
rename to graph/src/data/graphql/load_manager.rs
index b345d5e8c7b..79655e25629 100644
--- a/graph/src/data/graphql/effort.rs
+++ b/graph/src/data/graphql/load_manager.rs
@@ -1,52 +1,69 @@
 //! 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::components::metrics::{Counter, Gauge, MetricsRegistry};
-use crate::components::store::PoolWaitStats;
+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::{async_trait, debug, info, o, warn, Logger, QueryLoadManager, ENV_VARS};
+use crate::prelude::{ENV_VARS, Logger, debug, info, o, warn};
 use crate::util::stats::MovingStats;
 
-struct QueryEffort {
-    inner: Arc<RwLock<QueryEffortInner>>,
+const SHARD_LABEL: [&str; 1] = ["shard"];
+
+#[derive(PartialEq, Eq, Hash, Debug)]
+struct QueryRef {
+    id: DeploymentId,
+    shape_hash: u64,
+}
+
+impl QueryRef {
+    fn new(id: DeploymentId, shape_hash: u64) -> Self {
+        QueryRef { id, shape_hash }
+    }
+}
+
+/// Statistics about the query effort for a single database shard
+struct ShardEffort {
+    inner: Arc<RwLock<ShardEffortInner>>,
 }
 
-/// Track the effort for queries (identified by their ShapeHash) over a
-/// time window.
-struct QueryEffortInner {
-    window_size: Duration,
-    bin_size: Duration,
-    effort: HashMap<u64, MovingStats>,
+/// Track the effort for queries (identified by their deployment id and
+/// shape hash) over a time window.
+struct ShardEffortInner {
+    effort: HashMap<QueryRef, MovingStats>,
     total: MovingStats,
 }
 
 /// Create a `QueryEffort` that uses the window and bin sizes configured in
 /// the environment
-impl Default for QueryEffort {
+impl Default for ShardEffort {
     fn default() -> Self {
         Self::new(ENV_VARS.load_window_size, ENV_VARS.load_bin_size)
     }
 }
 
-impl QueryEffort {
+impl ShardEffort {
     pub fn new(window_size: Duration, bin_size: Duration) -> Self {
         Self {
-            inner: Arc::new(RwLock::new(QueryEffortInner::new(window_size, bin_size))),
+            inner: Arc::new(RwLock::new(ShardEffortInner::new(window_size, bin_size))),
         }
     }
 
-    pub fn add(&self, shape_hash: u64, duration: Duration, gauge: &Gauge) {
-        let mut inner = self.inner.write().unwrap();
-        inner.add(shape_hash, duration);
-        gauge.set(inner.total.average().unwrap_or(Duration::ZERO).as_millis() as f64);
+    pub fn add(&self, shard: &str, qref: QueryRef, duration: Duration, gauge: &GaugeVec) {
+        let mut inner = self.inner.write();
+        inner.add(qref, duration);
+        gauge
+            .with_label_values(&[shard])
+            .set(inner.total.average().unwrap_or(Duration::ZERO).as_millis() as f64);
     }
 
     /// Return what we know right now about the effort for the query
@@ -54,30 +71,28 @@ impl QueryEffort {
     /// at all, return `ZERO_DURATION` as the total effort. If we have no
     /// data for the particular query, return `None` as the effort
     /// for the query
-    pub fn current_effort(&self, shape_hash: u64) -> (Option<Duration>, Duration) {
-        let inner = self.inner.read().unwrap();
+    pub fn current_effort(&self, qref: &QueryRef) -> (Option<Duration>, Duration) {
+        let inner = self.inner.read();
         let total_effort = inner.total.duration();
-        let query_effort = inner.effort.get(&shape_hash).map(|stats| stats.duration());
+        let query_effort = inner.effort.get(qref).map(|stats| stats.duration());
         (query_effort, total_effort)
     }
 }
 
-impl QueryEffortInner {
+impl ShardEffortInner {
     fn new(window_size: Duration, bin_size: Duration) -> Self {
         Self {
-            window_size,
-            bin_size,
             effort: HashMap::default(),
             total: MovingStats::new(window_size, bin_size),
         }
     }
 
-    fn add(&mut self, shape_hash: u64, duration: Duration) {
-        let window_size = self.window_size;
-        let bin_size = self.bin_size;
+    fn add(&mut self, qref: QueryRef, duration: Duration) {
+        let window_size = self.total.window_size;
+        let bin_size = self.total.bin_size;
         let now = Instant::now();
         self.effort
-            .entry(shape_hash)
+            .entry(qref)
             .or_insert_with(|| MovingStats::new(window_size, bin_size))
             .add_at(now, duration);
         self.total.add_at(now, duration);
@@ -188,26 +203,30 @@ impl Decision {
 
 pub struct LoadManager {
     logger: Logger,
-    effort: QueryEffort,
+    effort: HashMap<String, ShardEffort>,
     /// List of query shapes that have been statically blocked through
-    /// configuration
+    /// configuration. We should really also include the deployment, but
+    /// that would require a change to the format of the file from which
+    /// these queries are read
     blocked_queries: HashSet<u64>,
     /// List of query shapes that have caused more than `JAIL_THRESHOLD`
     /// proportion of the work while the system was overloaded. Currently,
     /// there is no way for a query to get out of jail other than
     /// restarting the process
-    jailed_queries: RwLock<HashSet<u64>>,
-    kill_state: RwLock<KillState>,
-    effort_gauge: Box<Gauge>,
+    jailed_queries: RwLock<HashSet<QueryRef>>,
+    /// Per shard state of whether we are killing queries or not
+    kill_state: HashMap<String, RwLock<KillState>>,
+    effort_gauge: Box<GaugeVec>,
     query_counters: HashMap<CacheStatus, Counter>,
-    kill_rate_gauge: Box<Gauge>,
+    kill_rate_gauge: Box<GaugeVec>,
 }
 
 impl LoadManager {
     pub fn new(
         logger: &Logger,
+        shards: Vec<String>,
         blocked_queries: Vec<Arc<q::Document>>,
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
     ) -> Self {
         let logger = logger.new(o!("component" => "LoadManager"));
         let blocked_queries = blocked_queries
@@ -224,18 +243,19 @@ impl LoadManager {
         };
         info!(logger, "Creating LoadManager in {} mode", mode,);
 
+        let shard_label: Vec<_> = SHARD_LABEL.into_iter().map(String::from).collect();
         let effort_gauge = registry
-            .new_gauge(
+            .new_gauge_vec(
                 "query_effort_ms",
                 "Moving average of time spent running queries",
-                HashMap::new(),
+                shard_label.clone(),
             )
             .expect("failed to create `query_effort_ms` counter");
         let kill_rate_gauge = registry
-            .new_gauge(
+            .new_gauge_vec(
                 "query_kill_rate",
                 "The rate at which the load manager kills queries",
-                HashMap::new(),
+                shard_label,
             )
             .expect("failed to create `query_kill_rate` counter");
         let query_counters = CacheStatus::iter()
@@ -252,12 +272,24 @@ impl LoadManager {
             })
             .collect::<HashMap<_, _>>();
 
+        let effort = HashMap::from_iter(
+            shards
+                .iter()
+                .map(|shard| (shard.clone(), ShardEffort::default())),
+        );
+
+        let kill_state = HashMap::from_iter(
+            shards
+                .into_iter()
+                .map(|shard| (shard, RwLock::new(KillState::new()))),
+        );
+
         Self {
             logger,
-            effort: QueryEffort::default(),
+            effort,
             blocked_queries,
             jailed_queries: RwLock::new(HashSet::new()),
-            kill_state: RwLock::new(KillState::new()),
+            kill_state,
             effort_gauge,
             query_counters,
             kill_rate_gauge,
@@ -267,12 +299,22 @@ impl LoadManager {
     /// Record that we spent `duration` amount of work for the query
     /// `shape_hash`, where `cache_status` indicates whether the query
     /// was cached or had to actually run
-    pub fn record_work(&self, shape_hash: u64, duration: Duration, cache_status: CacheStatus) {
+    pub fn record_work(
+        &self,
+        shard: &str,
+        deployment: DeploymentId,
+        shape_hash: u64,
+        duration: Duration,
+        cache_status: CacheStatus,
+    ) {
         self.query_counters
             .get(&cache_status)
             .map(GenericCounter::inc);
         if !ENV_VARS.load_management_is_disabled() {
-            self.effort.add(shape_hash, duration, &self.effort_gauge);
+            let qref = QueryRef::new(deployment, shape_hash);
+            if let Some(effort) = self.effort.get(shard) {
+                effort.add(shard, qref, duration, &self.effort_gauge)
+            }
         }
     }
 
@@ -322,7 +364,14 @@ impl LoadManager {
     /// case, we also do not take any locks when asked to update statistics,
     /// or to check whether we are overloaded; these operations amount to
     /// noops.
-    pub fn decide(&self, wait_stats: &PoolWaitStats, shape_hash: u64, query: &str) -> Decision {
+    pub fn decide(
+        &self,
+        wait_stats: &PoolWaitStats,
+        shard: &str,
+        deployment: DeploymentId,
+        shape_hash: u64,
+        query: &str,
+    ) -> Decision {
         use Decision::*;
 
         if self.blocked_queries.contains(&shape_hash) {
@@ -332,7 +381,9 @@ impl LoadManager {
             return Proceed;
         }
 
-        if self.jailed_queries.read().unwrap().contains(&shape_hash) {
+        let qref = QueryRef::new(deployment, shape_hash);
+
+        if self.jailed_queries.read().contains(&qref) {
             return if ENV_VARS.load_simulate {
                 Proceed
             } else {
@@ -341,12 +392,16 @@ impl LoadManager {
         }
 
         let (overloaded, wait_ms) = self.overloaded(wait_stats);
-        let (kill_rate, last_update) = self.kill_state();
+        let (kill_rate, last_update) = self.kill_state(shard);
         if !overloaded && kill_rate == 0.0 {
             return Proceed;
         }
 
-        let (query_effort, total_effort) = self.effort.current_effort(shape_hash);
+        let (query_effort, total_effort) = self
+            .effort
+            .get(shard)
+            .map(|effort| effort.current_effort(&qref))
+            .unwrap_or((None, Duration::ZERO));
         // When `total_effort` is `Duratino::ZERO`, we haven't done any work. All are
         // welcome
         if total_effort.is_zero() {
@@ -362,34 +417,36 @@ 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(shape_hash);
-                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(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 kill_rate = self.update_kill_rate(shard, kill_rate, last_update, overloaded, wait_ms);
+        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";
                     "query" => query,
+                    "sgd" => format!("sgd{}", qref.id),
                     "wait_ms" => wait_ms.as_millis(),
                     "query_weight" => format!("{:.2}", query_effort / total_effort),
                     "kill_rate" => format!("{:.4}", kill_rate),
@@ -403,20 +460,21 @@ 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);
         (overloaded, store_avg.unwrap_or(Duration::ZERO))
     }
 
-    fn kill_state(&self) -> (f64, Instant) {
-        let state = self.kill_state.read().unwrap();
+    fn kill_state(&self, shard: &str) -> (f64, Instant) {
+        let state = self.kill_state.get(shard).unwrap().read();
         (state.kill_rate, state.last_update)
     }
 
     fn update_kill_rate(
         &self,
+        shard: &str,
         mut kill_rate: f64,
         last_update: Instant,
         overloaded: bool,
@@ -450,7 +508,7 @@ impl LoadManager {
                 kill_rate = (kill_rate - KILL_RATE_STEP_DOWN).max(0.0);
             }
             let event = {
-                let mut state = self.kill_state.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)
@@ -486,19 +544,9 @@ impl LoadManager {
                 Skip => { /* do nothing */ }
             }
         }
-        self.kill_rate_gauge.set(kill_rate);
+        self.kill_rate_gauge
+            .with_label_values(&[shard])
+            .set(kill_rate);
         kill_rate
     }
 }
-
-#[async_trait]
-impl QueryLoadManager for LoadManager {
-    fn record_work(&self, shape_hash: u64, duration: Duration, cache_status: CacheStatus) {
-        if let Some(counter) = self.query_counters.get(&cache_status) {
-            counter.inc()
-        }
-        if !ENV_VARS.load_management_is_disabled() {
-            self.effort.add(shape_hash, duration, &self.effort_gauge);
-        }
-    }
-}
diff --git a/graph/src/data/graphql/mod.rs b/graph/src/data/graphql/mod.rs
index b41df572f0d..fe6b6d8707d 100644
--- a/graph/src/data/graphql/mod.rs
+++ b/graph/src/data/graphql/mod.rs
@@ -23,11 +23,11 @@ pub use self::values::{
 
 pub mod shape_hash;
 
-pub mod effort;
+pub mod load_manager;
 
 pub mod object_or_interface;
 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_macro.rs b/graph/src/data/graphql/object_macro.rs
index 8af3bbc55ab..bbecab075ec 100644
--- a/graph/src/data/graphql/object_macro.rs
+++ b/graph/src/data/graphql/object_macro.rs
@@ -1,4 +1,5 @@
 use crate::data::value::Object;
+use crate::data::value::Word;
 use crate::prelude::q;
 use crate::prelude::r;
 use std::iter::FromIterator;
@@ -8,7 +9,7 @@ use std::iter::FromIterator;
 /// consider using the `object! {}` macro instead.
 pub fn object_value(data: Vec<(&str, r::Value)>) -> r::Value {
     r::Value::Object(Object::from_iter(
-        data.into_iter().map(|(k, v)| (k.to_string(), v)),
+        data.into_iter().map(|(k, v)| (Word::from(k), v)),
     ))
 }
 
@@ -102,10 +103,11 @@ impl_into_values![(String, String), (f64, Float), (bool, Boolean)];
 macro_rules! object {
     ($($name:ident: $value:expr,)*) => {
         {
+            use $crate::data::value::Word;
             let mut result = Vec::new();
             $(
                 let value = $crate::data::graphql::object_macro::IntoValue::into_value($value);
-                result.push((stringify!($name).to_string(), value));
+                result.push((Word::from(stringify!($name)), value));
             )*
             $crate::prelude::r::Value::Object($crate::data::value::Object::from_iter(result))
         }
diff --git a/graph/src/data/graphql/object_or_interface.rs b/graph/src/data/graphql/object_or_interface.rs
index 7764769a1a0..b86764bbdc5 100644
--- a/graph/src/data/graphql/object_or_interface.rs
+++ b/graph/src/data/graphql/object_or_interface.rs
@@ -1,5 +1,5 @@
-use crate::prelude::Schema;
-use crate::{components::store::EntityType, prelude::s};
+use crate::prelude::s;
+use crate::schema::{EntityType, Schema};
 use std::cmp::Ordering;
 use std::collections::BTreeMap;
 use std::hash::{Hash, Hasher};
@@ -63,15 +63,6 @@ impl<'a> From<&'a s::InterfaceType> for ObjectOrInterface<'a> {
     }
 }
 
-impl<'a> From<ObjectOrInterface<'a>> for EntityType {
-    fn from(ooi: ObjectOrInterface) -> Self {
-        match ooi {
-            ObjectOrInterface::Object(ty) => EntityType::from(ty),
-            ObjectOrInterface::Interface(ty) => EntityType::from(ty),
-        }
-    }
-}
-
 impl<'a> ObjectOrInterface<'a> {
     pub fn is_object(self) -> bool {
         match self {
@@ -109,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 7db68d7a484..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, Entity};
-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
@@ -127,19 +122,6 @@ where
     }
 }
 
-/// Assumes the entity is stored as a JSON string.
-impl TryFromValue for Entity {
-    fn try_from_value(value: &r::Value) -> Result<Self, Error> {
-        match value {
-            r::Value::String(s) => serde_json::from_str(s).map_err(Into::into),
-            _ => Err(anyhow!(
-                "Cannot parse entity, value is not a string: {:?}",
-                value
-            )),
-        }
-    }
-}
-
 pub trait ValueMap {
     fn get_required<T: TryFromValue>(&self, key: &str) -> Result<T, Error>;
     fn get_optional<T: TryFromValue>(&self, key: &str) -> Result<Option<T>, Error>;
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 b308c75bb29..246d4cdba12 100644
--- a/graph/src/data/mod.rs
+++ b/graph/src/data/mod.rs
@@ -4,15 +4,9 @@ pub mod subgraph;
 /// Data types for dealing with GraphQL queries.
 pub mod query;
 
-/// Data types for dealing with GraphQL schemas.
-pub mod schema;
-
 /// 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 3e64d37e5c4..aa6f84b2591 100644
--- a/graph/src/data/query/error.rs
+++ b/graph/src/data/query/error.rs
@@ -1,6 +1,4 @@
-use graphql_parser::Pos;
 use hex::FromHexError;
-use num_bigint;
 use serde::ser::*;
 use std::collections::HashMap;
 use std::error::Error;
@@ -27,39 +25,39 @@ 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,
     EntityFieldError(String, String),
     ListTypesError(String, Vec<String>),
     ListFilterError(String),
+    ChildFilterNestingNotSupportedError(String, String),
     ValueParseError(String, String),
     AttributeTypeError(String, String),
     EntityParseError(String),
     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,6 +72,10 @@ pub enum QueryExecutionError {
     InvalidSubgraphManifest,
     ResultTooBig(usize, usize),
     DeploymentNotFound(String),
+    SqlError(String),
+    IdMissing,
+    IdNotString,
+    InternalError(String),
 }
 
 impl QueryExecutionError {
@@ -84,7 +85,6 @@ impl QueryExecutionError {
             OperationNameRequired
             | OperationNotFound(_)
             | NotSupported(_)
-            | NoRootSubscriptionObjectType
             | NonNullError(_, _)
             | NamedTypeError(_)
             | AbstractTypeError(_)
@@ -95,9 +95,10 @@ impl QueryExecutionError {
             | OrderByNotSupportedError(_, _)
             | OrderByNotSupportedForType(_)
             | FilterNotSupportedError(_, _)
+            | ChildFilterNestingNotSupportedError(_, _)
             | UnknownField(_, _, _)
             | EmptyQuery
-            | MultipleSubscriptionFields
+            | InvalidOrFilterStructure(_, _)
             | SubgraphDeploymentIdError(_)
             | InvalidFilterError
             | EntityFieldError(_, _)
@@ -123,7 +124,6 @@ impl QueryExecutionError {
             | TooComplex(_, _)
             | TooDeep(_)
             | Panic(_)
-            | EventStreamError
             | TooExpensive
             | Throttled
             | DeploymentReverted
@@ -131,7 +131,11 @@ impl QueryExecutionError {
             | InvalidSubgraphManifest
             | ValidationError(_, _)
             | ResultTooBig(_, _)
-            | DeploymentNotFound(_) => false,
+            | DeploymentNotFound(_)
+            | IdMissing
+            | IdNotString
+            | InternalError(_) => false,
+            SqlError(_) => false,
         }
     }
 }
@@ -159,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)
             }
@@ -190,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)
@@ -198,21 +203,36 @@ impl fmt::Display for QueryExecutionError {
             FilterNotSupportedError(value, filter) => {
                 write!(f, "Filter not supported by value `{}`: `{}`", value, filter)
             }
+            ChildFilterNestingNotSupportedError(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)
             }
@@ -230,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)
@@ -243,39 +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),
         }
     }
 }
@@ -292,14 +359,8 @@ impl From<FromHexError> for QueryExecutionError {
     }
 }
 
-impl From<num_bigint::ParseBigIntError> for QueryExecutionError {
-    fn from(e: num_bigint::ParseBigIntError) -> Self {
-        QueryExecutionError::ValueParseError("BigInt".to_string(), format!("{}", e))
-    }
-}
-
-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))
     }
 }
@@ -310,6 +371,10 @@ impl From<StoreError> for QueryExecutionError {
             StoreError::DeploymentNotFound(id_or_name) => {
                 QueryExecutionError::DeploymentNotFound(id_or_name)
             }
+            StoreError::ChildFilterNestingNotSupportedError(attr, filter) => {
+                QueryExecutionError::ChildFilterNestingNotSupportedError(attr, filter)
+            }
+            StoreError::InternalError(msg) => QueryExecutionError::InternalError(msg),
             _ => QueryExecutionError::StoreError(CloneableAnyhowError(Arc::new(e.into()))),
         }
     }
@@ -321,6 +386,18 @@ impl From<SubgraphManifestResolveError> for QueryExecutionError {
     }
 }
 
+impl From<anyhow::Error> for QueryExecutionError {
+    fn from(e: anyhow::Error) -> Self {
+        QueryExecutionError::Panic(e.to_string())
+    }
+}
+
+impl From<QueryExecutionError> for diesel::result::Error {
+    fn from(e: QueryExecutionError) -> Self {
+        diesel::result::Error::QueryBuilderError(Box::new(e))
+    }
+}
+
 /// Error caused while processing a [Query](struct.Query.html) request.
 #[derive(Clone, Debug)]
 pub enum QueryError {
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 acf5accf57a..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,36 +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",
@@ -220,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 {
@@ -229,7 +264,7 @@ impl QueryResult {
             data: Some(data),
             errors: Vec::new(),
             deployment: None,
-            trace: Trace::None,
+            trace: TRACE_NONE.cheap_clone(),
         }
     }
 
@@ -241,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(),
         }
     }
 
@@ -297,7 +332,7 @@ impl From<QueryExecutionError> for QueryResult {
             data: None,
             errors: vec![e.into()],
             deployment: None,
-            trace: Trace::None,
+            trace: TRACE_NONE.cheap_clone(),
         }
     }
 }
@@ -308,7 +343,7 @@ impl From<QueryError> for QueryResult {
             data: None,
             errors: vec![e],
             deployment: None,
-            trace: Trace::None,
+            trace: TRACE_NONE.cheap_clone(),
         }
     }
 }
@@ -319,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(),
         }
     }
 }
@@ -333,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
     }
 }
@@ -358,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]
@@ -371,16 +400,19 @@ fn multiple_data_items() {
     use serde_json::json;
 
     fn make_obj(key: &str, value: &str) -> Arc<QueryResult> {
-        let obj = Object::from_iter([(key.to_owned(), r::Value::String(value.to_owned()))]);
+        let obj = Object::from_iter([(
+            crate::data::value::Word::from(key),
+            r::Value::String(value.to_owned()),
+        )]);
         Arc::new(obj.into())
     }
 
     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 d7ca979489c..369c36a5435 100644
--- a/graph/src/data/query/trace.rs
+++ b/graph/src/data/query/trace.rs
@@ -1,44 +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>,
+        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 {
@@ -46,8 +90,22 @@ 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)),
+                elapsed: Duration::from_millis(0),
+                permit_wait: Duration::from_millis(0),
                 children: Vec::new(),
             }
         } else {
@@ -55,17 +113,56 @@ 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),
             entity_count,
             children: Vec::new(),
         }
@@ -73,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 { .. }) => {
@@ -90,9 +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 { .. } | 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, res: &Result<QueryPermit, QueryExecutionError>) {
+        let time = match res {
+            Ok(permit) => permit.wait,
+            Err(_) => {
+                return;
+            }
+        };
+        match self {
+            Trace::None => { /* nothing to do  */ }
+            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 {
@@ -106,32 +325,53 @@ impl Serialize for Trace {
                 query,
                 variables,
                 query_id,
-                block,
                 elapsed,
-                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("permit_wait_ms", &permit_wait.as_millis())?;
                 map.end()
             }
             Trace::Query {
                 query,
                 elapsed,
+                conn_wait,
+                permit_wait,
                 entity_count,
                 children,
             } => {
                 let mut map = ser.serialize_map(Some(children.len() + 3))?;
                 map.serialize_entry("query", query)?;
                 map.serialize_entry("elapsed_ms", &elapsed.as_millis())?;
+                map.serialize_entry("conn_wait_ms", &conn_wait.as_millis())?;
+                map.serialize_entry("permit_wait_ms", &permit_wait.as_millis())?;
                 map.serialize_entry("entity_count", entity_count)?;
                 for (child, trace) in children {
                     map.serialize_entry(child, trace)?;
@@ -141,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/schema.rs b/graph/src/data/schema.rs
deleted file mode 100644
index 91d5afe9b23..00000000000
--- a/graph/src/data/schema.rs
+++ /dev/null
@@ -1,1956 +0,0 @@
-use crate::cheap_clone::CheapClone;
-use crate::components::store::{EntityKey, EntityType, SubgraphStore};
-use crate::data::graphql::ext::{DirectiveExt, DirectiveFinder, DocumentExt, TypeExt, ValueExt};
-use crate::data::graphql::ObjectTypeExt;
-use crate::data::store::{self, ValueType};
-use crate::data::subgraph::{DeploymentHash, SubgraphName};
-use crate::prelude::{
-    anyhow, lazy_static,
-    q::Value,
-    s::{self, Definition, InterfaceType, ObjectType, TypeDefinition, *},
-};
-
-use anyhow::{Context, Error};
-use graphql_parser::{self, Pos};
-use inflector::Inflector;
-use itertools::Itertools;
-use serde::{Deserialize, Serialize};
-use thiserror::Error;
-
-use std::collections::{BTreeMap, HashMap, HashSet};
-use std::convert::TryFrom;
-use std::fmt;
-use std::hash::Hash;
-use std::iter::FromIterator;
-use std::str::FromStr;
-use std::sync::Arc;
-
-use super::graphql::ObjectOrInterface;
-use super::store::scalar;
-
-pub const SCHEMA_TYPE_NAME: &str = "_Schema_";
-
-pub const META_FIELD_TYPE: &str = "_Meta_";
-pub const META_FIELD_NAME: &str = "_meta";
-
-pub const BLOCK_FIELD_TYPE: &str = "_Block_";
-
-#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
-pub struct Strings(Vec<String>);
-
-impl fmt::Display for Strings {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        let s = self.0.join(", ");
-        write!(f, "{}", s)
-    }
-}
-
-#[derive(Debug, Error, PartialEq, Eq)]
-pub enum SchemaValidationError {
-    #[error("Interface `{0}` not defined")]
-    InterfaceUndefined(String),
-
-    #[error("@entity directive missing on the following types: `{0}`")]
-    EntityDirectivesMissing(Strings),
-
-    #[error(
-        "Entity type `{0}` does not satisfy interface `{1}` because it is missing \
-         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")]
-    InterfaceImplementorsMixId(String, String),
-    #[error("Field `{1}` in type `{0}` has invalid @derivedFrom: {2}")]
-    InvalidDerivedFrom(String, String, String), // (type, field, reason)
-    #[error("The following type names are reserved: `{0}`")]
-    UsageOfReservedTypes(Strings),
-    #[error("_Schema_ type is only for @imports and must not have any fields")]
-    SchemaTypeWithFields,
-    #[error("Imported subgraph name `{0}` is invalid")]
-    ImportedSubgraphNameInvalid(String),
-    #[error("Imported subgraph id `{0}` is invalid")]
-    ImportedSubgraphIdInvalid(String),
-    #[error("The _Schema_ type only allows @import directives")]
-    InvalidSchemaTypeDirectives,
-    #[error(
-        r#"@import directives must have the form \
-@import(types: ["A", {{ name: "B", as: "C"}}], from: {{ name: "org/subgraph"}}) or \
-@import(types: ["A", {{ name: "B", as: "C"}}], from: {{ id: "Qm..."}})"#
-    )]
-    ImportDirectiveInvalid,
-    #[error("Type `{0}`, field `{1}`: type `{2}` is neither defined nor imported")]
-    FieldTypeUnknown(String, String, String), // (type_name, field_name, field_type)
-    #[error("Imported type `{0}` does not exist in the `{1}` schema")]
-    ImportedTypeUndefined(String, String), // (type_name, schema)
-    #[error("Fulltext directive name undefined")]
-    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}")]
-    FulltextNameCollision(String),
-    #[error("Fulltext language is undefined")]
-    FulltextLanguageUndefined,
-    #[error("Fulltext language is invalid: {0}")]
-    FulltextLanguageInvalid(String),
-    #[error("Fulltext algorithm is undefined")]
-    FulltextAlgorithmUndefined,
-    #[error("Fulltext algorithm is invalid: {0}")]
-    FulltextAlgorithmInvalid(String),
-    #[error("Fulltext include is invalid")]
-    FulltextIncludeInvalid,
-    #[error("Fulltext directive requires an 'include' list")]
-    FulltextIncludeUndefined,
-    #[error("Fulltext 'include' list must contain an object")]
-    FulltextIncludeObjectMissing,
-    #[error(
-        "Fulltext 'include' object must contain 'entity' (String) and 'fields' (List) attributes"
-    )]
-    FulltextIncludeEntityMissingOrIncorrectAttributes,
-    #[error("Fulltext directive includes an entity not found on the subgraph schema")]
-    FulltextIncludedEntityNotFound,
-    #[error("Fulltext include field must have a 'name' attribute")]
-    FulltextIncludedFieldMissingRequiredProperty,
-    #[error("Fulltext entity field, {0}, not found or not a string")]
-    FulltextIncludedFieldInvalid(String),
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum FulltextLanguage {
-    Simple,
-    Danish,
-    Dutch,
-    English,
-    Finnish,
-    French,
-    German,
-    Hungarian,
-    Italian,
-    Norwegian,
-    Portugese,
-    Romanian,
-    Russian,
-    Spanish,
-    Swedish,
-    Turkish,
-}
-
-impl TryFrom<&str> for FulltextLanguage {
-    type Error = String;
-    fn try_from(language: &str) -> Result<Self, Self::Error> {
-        match language {
-            "simple" => Ok(FulltextLanguage::Simple),
-            "da" => Ok(FulltextLanguage::Danish),
-            "nl" => Ok(FulltextLanguage::Dutch),
-            "en" => Ok(FulltextLanguage::English),
-            "fi" => Ok(FulltextLanguage::Finnish),
-            "fr" => Ok(FulltextLanguage::French),
-            "de" => Ok(FulltextLanguage::German),
-            "hu" => Ok(FulltextLanguage::Hungarian),
-            "it" => Ok(FulltextLanguage::Italian),
-            "no" => Ok(FulltextLanguage::Norwegian),
-            "pt" => Ok(FulltextLanguage::Portugese),
-            "ro" => Ok(FulltextLanguage::Romanian),
-            "ru" => Ok(FulltextLanguage::Russian),
-            "es" => Ok(FulltextLanguage::Spanish),
-            "sv" => Ok(FulltextLanguage::Swedish),
-            "tr" => Ok(FulltextLanguage::Turkish),
-            invalid => Err(format!(
-                "Provided language for fulltext search is invalid: {}",
-                invalid
-            )),
-        }
-    }
-}
-
-impl FulltextLanguage {
-    /// Return the language as a valid SQL string. The string is safe to
-    /// directly use verbatim in a query, i.e., doesn't require being passed
-    /// through a bind variable
-    pub fn as_sql(&self) -> &'static str {
-        match self {
-            Self::Simple => "'simple'",
-            Self::Danish => "'danish'",
-            Self::Dutch => "'dutch'",
-            Self::English => "'english'",
-            Self::Finnish => "'finnish'",
-            Self::French => "'french'",
-            Self::German => "'german'",
-            Self::Hungarian => "'hungarian'",
-            Self::Italian => "'italian'",
-            Self::Norwegian => "'norwegian'",
-            Self::Portugese => "'portugese'",
-            Self::Romanian => "'romanian'",
-            Self::Russian => "'russian'",
-            Self::Spanish => "'spanish'",
-            Self::Swedish => "'swedish'",
-            Self::Turkish => "'turkish'",
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum FulltextAlgorithm {
-    Rank,
-    ProximityRank,
-}
-
-impl TryFrom<&str> for FulltextAlgorithm {
-    type Error = String;
-    fn try_from(algorithm: &str) -> Result<Self, Self::Error> {
-        match algorithm {
-            "rank" => Ok(FulltextAlgorithm::Rank),
-            "proximityRank" => Ok(FulltextAlgorithm::ProximityRank),
-            invalid => Err(format!(
-                "The provided fulltext search algorithm {} is invalid. It must be one of: rank, proximityRank",
-                invalid,
-            )),
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq)]
-pub struct FulltextConfig {
-    pub language: FulltextLanguage,
-    pub algorithm: FulltextAlgorithm,
-}
-
-pub struct FulltextDefinition {
-    pub config: FulltextConfig,
-    pub included_fields: HashSet<String>,
-    pub name: String,
-}
-
-impl From<&s::Directive> for FulltextDefinition {
-    // Assumes the input is a Fulltext Directive that has already been validated because it makes
-    // liberal use of unwrap() where specific types are expected
-    fn from(directive: &Directive) -> Self {
-        let name = directive.argument("name").unwrap().as_str().unwrap();
-
-        let algorithm = FulltextAlgorithm::try_from(
-            directive.argument("algorithm").unwrap().as_enum().unwrap(),
-        )
-        .unwrap();
-
-        let language =
-            FulltextLanguage::try_from(directive.argument("language").unwrap().as_enum().unwrap())
-                .unwrap();
-
-        let included_entity_list = directive.argument("include").unwrap().as_list().unwrap();
-        // Currently fulltext query fields are limited to 1 entity, so we just take the first (and only) included Entity
-        let included_entity = included_entity_list.first().unwrap().as_object().unwrap();
-        let included_field_values = included_entity.get("fields").unwrap().as_list().unwrap();
-        let included_fields: HashSet<String> = included_field_values
-            .iter()
-            .map(|field| {
-                field
-                    .as_object()
-                    .unwrap()
-                    .get("name")
-                    .unwrap()
-                    .as_str()
-                    .unwrap()
-                    .into()
-            })
-            .collect();
-
-        FulltextDefinition {
-            config: FulltextConfig {
-                language,
-                algorithm,
-            },
-            included_fields,
-            name: name.into(),
-        }
-    }
-}
-#[derive(Debug, Error, PartialEq, Eq, Clone)]
-pub enum SchemaImportError {
-    #[error("Schema for imported subgraph `{0}` was not found")]
-    ImportedSchemaNotFound(SchemaReference),
-    #[error("Subgraph for imported schema `{0}` is not deployed")]
-    ImportedSubgraphNotFound(SchemaReference),
-}
-
-/// The representation of a single type from an import statement. This
-/// corresponds either to a string `"Thing"` or an object
-/// `{name: "Thing", as: "Stuff"}`. The first form is equivalent to
-/// `{name: "Thing", as: "Thing"}`
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct ImportedType {
-    /// The 'name'
-    name: String,
-    /// The 'as' alias or a copy of `name` if the user did not specify an alias
-    alias: String,
-    /// Whether the alias was explicitly given or is just a copy of the name
-    explicit: bool,
-}
-
-impl fmt::Display for ImportedType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        if self.explicit {
-            write!(f, "name: {}, as: {}", self.name, self.alias)
-        } else {
-            write!(f, "{}", self.name)
-        }
-    }
-}
-
-impl ImportedType {
-    fn parse(type_import: &Value) -> Option<Self> {
-        match type_import {
-            Value::String(type_name) => Some(ImportedType {
-                name: type_name.to_string(),
-                alias: type_name.to_string(),
-                explicit: false,
-            }),
-            Value::Object(type_name_as) => {
-                match (type_name_as.get("name"), type_name_as.get("as")) {
-                    (Some(name), Some(az)) => Some(ImportedType {
-                        name: name.to_string(),
-                        alias: az.to_string(),
-                        explicit: true,
-                    }),
-                    _ => None,
-                }
-            }
-            _ => None,
-        }
-    }
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, Hash)]
-pub struct SchemaReference {
-    subgraph: DeploymentHash,
-}
-
-impl fmt::Display for SchemaReference {
-    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
-        write!(f, "{}", self.subgraph)
-    }
-}
-
-impl SchemaReference {
-    fn new(subgraph: DeploymentHash) -> Self {
-        SchemaReference { subgraph }
-    }
-
-    pub fn resolve<S: SubgraphStore>(
-        &self,
-        store: Arc<S>,
-    ) -> Result<Arc<Schema>, SchemaImportError> {
-        store
-            .input_schema(&self.subgraph)
-            .map_err(|_| SchemaImportError::ImportedSchemaNotFound(self.clone()))
-    }
-
-    fn parse(value: &Value) -> Option<Self> {
-        match value {
-            Value::Object(map) => match map.get("id") {
-                Some(Value::String(id)) => match DeploymentHash::new(id) {
-                    Ok(id) => Some(SchemaReference::new(id)),
-                    _ => None,
-                },
-                _ => None,
-            },
-            _ => None,
-        }
-    }
-}
-
-#[derive(Debug)]
-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>>,
-}
-
-impl ApiSchema {
-    /// `api_schema` will typically come from `fn api_schema` in the graphql
-    /// crate.
-    ///
-    /// In addition, the API schema has an introspection schema mixed into
-    /// `api_schema`. In particular, the `Query` type has fields called
-    /// `__schema` and `__type`
-    pub fn from_api_schema(mut api_schema: Schema) -> Result<Self, anyhow::Error> {
-        add_introspection_schema(&mut api_schema.document);
-
-        let query_type = api_schema
-            .document
-            .get_root_query_type()
-            .context("no root `Query` in the schema")?
-            .clone();
-        let subscription_type = api_schema
-            .document
-            .get_root_subscription_type()
-            .cloned()
-            .map(Arc::new);
-
-        let object_types = HashMap::from_iter(
-            api_schema
-                .document
-                .get_object_type_definitions()
-                .into_iter()
-                .map(|obj_type| (obj_type.name.clone(), Arc::new(obj_type.clone()))),
-        );
-
-        Ok(Self {
-            schema: api_schema,
-            query_type: Arc::new(query_type),
-            subscription_type,
-            object_types,
-        })
-    }
-
-    pub fn document(&self) -> &s::Document {
-        &self.schema.document
-    }
-
-    pub fn id(&self) -> &DeploymentHash {
-        &self.schema.id
-    }
-
-    pub fn schema(&self) -> &Schema {
-        &self.schema
-    }
-
-    pub fn types_for_interface(&self) -> &BTreeMap<EntityType, Vec<ObjectType>> {
-        &self.schema.types_for_interface
-    }
-
-    /// Returns `None` if the type implements no interfaces.
-    pub fn interfaces_for_type(&self, type_name: &EntityType) -> Option<&Vec<InterfaceType>> {
-        self.schema.interfaces_for_type(type_name)
-    }
-
-    /// Return an `Arc` around the `ObjectType` from our internal cache
-    ///
-    /// # Panics
-    /// If `obj_type` is not part of this schema, this function panics
-    pub fn object_type(&self, obj_type: &ObjectType) -> Arc<ObjectType> {
-        self.object_types
-            .get(&obj_type.name)
-            .expect("ApiSchema.object_type is only used with existing types")
-            .cheap_clone()
-    }
-
-    pub fn get_named_type(&self, name: &str) -> Option<&TypeDefinition> {
-        self.schema.document.get_named_type(name)
-    }
-
-    /// Returns true if the given type is an input type.
-    ///
-    /// Uses the algorithm outlined on
-    /// https://facebook.github.io/graphql/draft/#IsInputType().
-    pub fn is_input_type(&self, t: &s::Type) -> bool {
-        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,
-                })
-            }
-            s::Type::ListType(inner) => self.is_input_type(inner),
-            s::Type::NonNullType(inner) => self.is_input_type(inner),
-        }
-    }
-
-    pub fn get_root_query_type_def(&self) -> Option<&s::TypeDefinition> {
-        self.schema
-            .document
-            .definitions
-            .iter()
-            .find_map(|d| match d {
-                s::Definition::TypeDefinition(def @ s::TypeDefinition::Object(_)) => match def {
-                    s::TypeDefinition::Object(t) if t.name == "Query" => Some(def),
-                    _ => None,
-                },
-                _ => None,
-            })
-    }
-
-    pub fn object_or_interface(&self, name: &str) -> Option<ObjectOrInterface<'_>> {
-        if name.starts_with("__") {
-            INTROSPECTION_SCHEMA.object_or_interface(name)
-        } else {
-            self.schema.document.object_or_interface(name)
-        }
-    }
-
-    /// Returns the type definition that a field type corresponds to.
-    pub fn get_type_definition_from_field<'a>(
-        &'a self,
-        field: &s::Field,
-    ) -> Option<&'a s::TypeDefinition> {
-        self.get_type_definition_from_type(&field.field_type)
-    }
-
-    /// Returns the type definition for a type.
-    pub fn get_type_definition_from_type<'a>(
-        &'a self,
-        t: &s::Type,
-    ) -> Option<&'a s::TypeDefinition> {
-        match t {
-            s::Type::NamedType(name) => self.get_named_type(name),
-            s::Type::ListType(inner) => self.get_type_definition_from_type(inner),
-            s::Type::NonNullType(inner) => self.get_type_definition_from_type(inner),
-        }
-    }
-
-    #[cfg(debug_assertions)]
-    pub fn definitions(&self) -> impl Iterator<Item = &s::Definition<'static, String>> {
-        self.schema.document.definitions.iter()
-    }
-}
-
-lazy_static! {
-    static ref INTROSPECTION_SCHEMA: Document = {
-        let schema = include_str!("introspection.graphql");
-        parse_schema(schema).expect("the schema `introspection.graphql` is invalid")
-    };
-}
-
-fn add_introspection_schema(schema: &mut Document) {
-    fn introspection_fields() -> Vec<Field> {
-        // Generate fields for the root query fields in an introspection schema,
-        // the equivalent of the fields of the `Query` type:
-        //
-        // type Query {
-        //   __schema: __Schema!
-        //   __type(name: String!): __Type
-        // }
-
-        let type_args = vec![InputValue {
-            position: Pos::default(),
-            description: None,
-            name: "name".to_string(),
-            value_type: Type::NonNullType(Box::new(Type::NamedType("String".to_string()))),
-            default_value: None,
-            directives: vec![],
-        }];
-
-        vec![
-            Field {
-                position: Pos::default(),
-                description: None,
-                name: "__schema".to_string(),
-                arguments: vec![],
-                field_type: Type::NonNullType(Box::new(Type::NamedType("__Schema".to_string()))),
-                directives: vec![],
-            },
-            Field {
-                position: Pos::default(),
-                description: None,
-                name: "__type".to_string(),
-                arguments: type_args,
-                field_type: Type::NamedType("__Type".to_string()),
-                directives: vec![],
-            },
-        ]
-    }
-
-    schema
-        .definitions
-        .extend(INTROSPECTION_SCHEMA.definitions.iter().cloned());
-
-    let query_type = schema
-        .definitions
-        .iter_mut()
-        .filter_map(|d| match d {
-            Definition::TypeDefinition(TypeDefinition::Object(t)) if t.name == "Query" => Some(t),
-            _ => None,
-        })
-        .peekable()
-        .next()
-        .expect("no root `Query` in the schema");
-    query_type.fields.append(&mut introspection_fields());
-}
-
-/// A validated and preprocessed GraphQL schema for a subgraph.
-#[derive(Clone, Debug, PartialEq)]
-pub struct Schema {
-    pub id: DeploymentHash,
-    pub document: s::Document,
-
-    // Maps type name to implemented interfaces.
-    pub interfaces_for_type: BTreeMap<EntityType, Vec<InterfaceType>>,
-
-    // Maps an interface name to the list of entities that implement it.
-    pub types_for_interface: BTreeMap<EntityType, Vec<ObjectType>>,
-
-    immutable_types: HashSet<EntityType>,
-}
-
-impl Schema {
-    /// Create a new schema. The document must already have been validated
-    //
-    // TODO: The way some validation is expected to be done beforehand, and
-    // some is done here makes it incredibly murky whether a `Schema` is
-    // fully validated. The code should be changed to make sure that a
-    // `Schema` is always fully valid
-    pub fn new(id: DeploymentHash, document: s::Document) -> Result<Self, SchemaValidationError> {
-        let (interfaces_for_type, types_for_interface) = Self::collect_interfaces(&document)?;
-        let immutable_types = Self::collect_immutable_types(&document);
-
-        let mut schema = Schema {
-            id: id.clone(),
-            document,
-            interfaces_for_type,
-            types_for_interface,
-            immutable_types,
-        };
-
-        schema.add_subgraph_id_directives(id);
-
-        Ok(schema)
-    }
-
-    /// Construct a value for the entity type's id attribute
-    pub fn id_value(&self, key: &EntityKey) -> Result<store::Value, Error> {
-        let base_type = self
-            .document
-            .get_object_type_definition(key.entity_type.as_str())
-            .ok_or_else(|| {
-                anyhow!(
-                    "Entity {}[{}]: unknown entity type `{}`",
-                    key.entity_type,
-                    key.entity_id,
-                    key.entity_type
-                )
-            })?
-            .field("id")
-            .unwrap()
-            .field_type
-            .get_base_type();
-
-        match base_type {
-            "ID" | "String" => Ok(store::Value::String(key.entity_id.to_string())),
-            "Bytes" => Ok(store::Value::Bytes(scalar::Bytes::from_str(
-                &key.entity_id,
-            )?)),
-            s => {
-                return Err(anyhow!(
-                    "Entity type {} uses illegal type {} for id column",
-                    key.entity_type,
-                    s
-                ))
-            }
-        }
-    }
-
-    pub fn is_immutable(&self, entity_type: &EntityType) -> bool {
-        self.immutable_types.contains(entity_type)
-    }
-
-    pub fn resolve_schema_references<S: SubgraphStore>(
-        &self,
-        store: Arc<S>,
-    ) -> (
-        HashMap<SchemaReference, Arc<Schema>>,
-        Vec<SchemaImportError>,
-    ) {
-        let mut schemas = HashMap::new();
-        let mut visit_log = HashSet::new();
-        let import_errors = self.resolve_import_graph(store, &mut schemas, &mut visit_log);
-        (schemas, import_errors)
-    }
-
-    fn resolve_import_graph<S: SubgraphStore>(
-        &self,
-        store: Arc<S>,
-        schemas: &mut HashMap<SchemaReference, Arc<Schema>>,
-        visit_log: &mut HashSet<DeploymentHash>,
-    ) -> Vec<SchemaImportError> {
-        // Use the visit log to detect cycles in the import graph
-        self.imported_schemas()
-            .into_iter()
-            .fold(vec![], |mut errors, schema_ref| {
-                match schema_ref.resolve(store.clone()) {
-                    Ok(schema) => {
-                        schemas.insert(schema_ref, schema.clone());
-                        // If this node in the graph has already been visited stop traversing
-                        if !visit_log.contains(&schema.id) {
-                            visit_log.insert(schema.id.clone());
-                            errors.extend(schema.resolve_import_graph(
-                                store.clone(),
-                                schemas,
-                                visit_log,
-                            ));
-                        }
-                    }
-                    Err(err) => {
-                        errors.push(err);
-                    }
-                }
-                errors
-            })
-    }
-
-    fn collect_interfaces(
-        document: &s::Document,
-    ) -> Result<
-        (
-            BTreeMap<EntityType, Vec<InterfaceType>>,
-            BTreeMap<EntityType, Vec<ObjectType>>,
-        ),
-        SchemaValidationError,
-    > {
-        // Initialize with an empty vec for each interface, so we don't
-        // miss interfaces that have no implementors.
-        let mut types_for_interface =
-            BTreeMap::from_iter(document.definitions.iter().filter_map(|d| match d {
-                Definition::TypeDefinition(TypeDefinition::Interface(t)) => {
-                    Some((EntityType::from(t), vec![]))
-                }
-                _ => None,
-            }));
-        let mut interfaces_for_type = BTreeMap::<_, Vec<_>>::new();
-
-        for object_type in document.get_object_type_definitions() {
-            for implemented_interface in object_type.implements_interfaces.clone() {
-                let interface_type = document
-                    .definitions
-                    .iter()
-                    .find_map(|def| match def {
-                        Definition::TypeDefinition(TypeDefinition::Interface(i))
-                            if i.name.eq(&implemented_interface) =>
-                        {
-                            Some(i.clone())
-                        }
-                        _ => None,
-                    })
-                    .ok_or_else(|| {
-                        SchemaValidationError::InterfaceUndefined(implemented_interface.clone())
-                    })?;
-
-                Self::validate_interface_implementation(object_type, &interface_type)?;
-
-                interfaces_for_type
-                    .entry(EntityType::from(object_type))
-                    .or_default()
-                    .push(interface_type);
-                types_for_interface
-                    .get_mut(&EntityType::new(implemented_interface))
-                    .unwrap()
-                    .push(object_type.clone());
-            }
-        }
-
-        Ok((interfaces_for_type, types_for_interface))
-    }
-
-    fn collect_immutable_types(document: &s::Document) -> HashSet<EntityType> {
-        HashSet::from_iter(
-            document
-                .get_object_type_definitions()
-                .into_iter()
-                .filter(|obj_type| obj_type.is_immutable())
-                .map(Into::into),
-        )
-    }
-
-    pub fn parse(raw: &str, id: DeploymentHash) -> Result<Self, Error> {
-        let document = graphql_parser::parse_schema(raw)?.into_static();
-
-        Schema::new(id, document).map_err(Into::into)
-    }
-
-    fn imported_types(&self) -> HashMap<ImportedType, SchemaReference> {
-        fn parse_types(import: &Directive) -> Vec<ImportedType> {
-            import
-                .argument("types")
-                .map_or(vec![], |value| match value {
-                    Value::List(types) => types.iter().filter_map(ImportedType::parse).collect(),
-                    _ => vec![],
-                })
-        }
-
-        self.subgraph_schema_object_type()
-            .map_or(HashMap::new(), |object| {
-                object
-                    .directives
-                    .iter()
-                    .filter(|directive| directive.name.eq("import"))
-                    .flat_map(|import| {
-                        import.argument("from").map_or(vec![], |from| {
-                            SchemaReference::parse(from).map_or(vec![], |schema_ref| {
-                                parse_types(import)
-                                    .into_iter()
-                                    .map(|imported_type| (imported_type, schema_ref.clone()))
-                                    .collect()
-                            })
-                        })
-                    })
-                    .collect::<HashMap<ImportedType, SchemaReference>>()
-            })
-    }
-
-    pub fn imported_schemas(&self) -> Vec<SchemaReference> {
-        self.subgraph_schema_object_type().map_or(vec![], |object| {
-            object
-                .directives
-                .iter()
-                .filter(|directive| directive.name.eq("import"))
-                .filter_map(|directive| directive.argument("from"))
-                .filter_map(SchemaReference::parse)
-                .collect()
-        })
-    }
-
-    pub fn name_argument_value_from_directive(directive: &Directive) -> Value {
-        directive
-            .argument("name")
-            .expect("fulltext directive must have name argument")
-            .clone()
-    }
-
-    /// Returned map has one an entry for each interface in the schema.
-    pub fn types_for_interface(&self) -> &BTreeMap<EntityType, Vec<ObjectType>> {
-        &self.types_for_interface
-    }
-
-    /// Returns `None` if the type implements no interfaces.
-    pub fn interfaces_for_type(&self, type_name: &EntityType) -> Option<&Vec<InterfaceType>> {
-        self.interfaces_for_type.get(type_name)
-    }
-
-    // Adds a @subgraphId(id: ...) directive to object/interface/enum types in the schema.
-    pub fn add_subgraph_id_directives(&mut self, id: DeploymentHash) {
-        for definition in self.document.definitions.iter_mut() {
-            let subgraph_id_argument = (String::from("id"), s::Value::String(id.to_string()));
-
-            let subgraph_id_directive = s::Directive {
-                name: "subgraphId".to_string(),
-                position: Pos::default(),
-                arguments: vec![subgraph_id_argument],
-            };
-
-            if let Definition::TypeDefinition(ref mut type_definition) = definition {
-                let (name, directives) = match type_definition {
-                    TypeDefinition::Object(object_type) => {
-                        (&object_type.name, &mut object_type.directives)
-                    }
-                    TypeDefinition::Interface(interface_type) => {
-                        (&interface_type.name, &mut interface_type.directives)
-                    }
-                    TypeDefinition::Enum(enum_type) => (&enum_type.name, &mut enum_type.directives),
-                    TypeDefinition::Scalar(scalar_type) => {
-                        (&scalar_type.name, &mut scalar_type.directives)
-                    }
-                    TypeDefinition::InputObject(input_object_type) => {
-                        (&input_object_type.name, &mut input_object_type.directives)
-                    }
-                    TypeDefinition::Union(union_type) => {
-                        (&union_type.name, &mut union_type.directives)
-                    }
-                };
-
-                if !name.eq(SCHEMA_TYPE_NAME)
-                    && !directives
-                        .iter()
-                        .any(|directive| directive.name.eq("subgraphId"))
-                {
-                    directives.push(subgraph_id_directive);
-                }
-            };
-        }
-    }
-
-    pub fn validate(
-        &self,
-        schemas: &HashMap<SchemaReference, Arc<Schema>>,
-    ) -> Result<(), Vec<SchemaValidationError>> {
-        let mut errors: Vec<SchemaValidationError> = [
-            self.validate_schema_types(),
-            self.validate_derived_from(),
-            self.validate_schema_type_has_no_fields(),
-            self.validate_directives_on_schema_type(),
-            self.validate_reserved_types_usage(),
-            self.validate_interface_id_type(),
-        ]
-        .into_iter()
-        .filter(Result::is_err)
-        // Safe unwrap due to the filter above
-        .map(Result::unwrap_err)
-        .collect();
-
-        errors.append(&mut self.validate_fields());
-        errors.append(&mut self.validate_import_directives());
-        errors.append(&mut self.validate_fulltext_directives());
-        errors.append(&mut self.validate_imported_types(schemas));
-
-        if errors.is_empty() {
-            Ok(())
-        } else {
-            Err(errors)
-        }
-    }
-
-    fn validate_schema_type_has_no_fields(&self) -> Result<(), SchemaValidationError> {
-        match self
-            .subgraph_schema_object_type()
-            .and_then(|subgraph_schema_type| {
-                if !subgraph_schema_type.fields.is_empty() {
-                    Some(SchemaValidationError::SchemaTypeWithFields)
-                } else {
-                    None
-                }
-            }) {
-            Some(err) => Err(err),
-            None => Ok(()),
-        }
-    }
-
-    fn validate_directives_on_schema_type(&self) -> Result<(), SchemaValidationError> {
-        match self
-            .subgraph_schema_object_type()
-            .and_then(|subgraph_schema_type| {
-                if subgraph_schema_type
-                    .directives
-                    .iter()
-                    .filter(|directive| {
-                        !directive.name.eq("import") && !directive.name.eq("fulltext")
-                    })
-                    .next()
-                    .is_some()
-                {
-                    Some(SchemaValidationError::InvalidSchemaTypeDirectives)
-                } else {
-                    None
-                }
-            }) {
-            Some(err) => Err(err),
-            None => Ok(()),
-        }
-    }
-
-    /// Check the syntax of a single `@import` directive
-    fn validate_import_directive_arguments(import: &Directive) -> Option<SchemaValidationError> {
-        fn validate_import_type(typ: &Value) -> Result<(), ()> {
-            match typ {
-                Value::String(_) => Ok(()),
-                Value::Object(typ) => match (typ.get("name"), typ.get("as")) {
-                    (Some(Value::String(_)), Some(Value::String(_))) => Ok(()),
-                    _ => Err(()),
-                },
-                _ => Err(()),
-            }
-        }
-
-        fn types_are_valid(types: Option<&Value>) -> bool {
-            // All of the elements in the `types` field are valid: either
-            // a string or an object with keys `name` and `as` which are strings
-            if let Some(Value::List(types)) = types {
-                types
-                    .iter()
-                    .try_for_each(validate_import_type)
-                    .err()
-                    .is_none()
-            } else {
-                false
-            }
-        }
-
-        fn from_is_valid(from: Option<&Value>) -> bool {
-            if let Some(Value::Object(from)) = from {
-                let has_id = matches!(from.get("id"), Some(Value::String(_)));
-
-                let has_name = matches!(from.get("name"), Some(Value::String(_)));
-                has_id ^ has_name
-            } else {
-                false
-            }
-        }
-
-        if from_is_valid(import.argument("from")) && types_are_valid(import.argument("types")) {
-            None
-        } else {
-            Some(SchemaValidationError::ImportDirectiveInvalid)
-        }
-    }
-
-    fn validate_import_directive_schema_reference_parses(
-        directive: &Directive,
-    ) -> Option<SchemaValidationError> {
-        directive.argument("from").and_then(|from| match from {
-            Value::Object(from) => {
-                let id_parse_error = match from.get("id") {
-                    Some(Value::String(id)) => match DeploymentHash::new(id) {
-                        Err(_) => {
-                            Some(SchemaValidationError::ImportedSubgraphIdInvalid(id.clone()))
-                        }
-                        _ => None,
-                    },
-                    _ => None,
-                };
-                let name_parse_error = match from.get("name") {
-                    Some(Value::String(name)) => match SubgraphName::new(name) {
-                        Err(_) => Some(SchemaValidationError::ImportedSubgraphNameInvalid(
-                            name.clone(),
-                        )),
-                        _ => None,
-                    },
-                    _ => None,
-                };
-                id_parse_error.or(name_parse_error)
-            }
-            _ => None,
-        })
-    }
-
-    fn validate_fulltext_directives(&self) -> Vec<SchemaValidationError> {
-        self.subgraph_schema_object_type()
-            .map_or(vec![], |subgraph_schema_type| {
-                subgraph_schema_type
-                    .directives
-                    .iter()
-                    .filter(|directives| directives.name.eq("fulltext"))
-                    .fold(vec![], |mut errors, fulltext| {
-                        errors.extend(self.validate_fulltext_directive_name(fulltext).into_iter());
-                        errors.extend(
-                            self.validate_fulltext_directive_language(fulltext)
-                                .into_iter(),
-                        );
-                        errors.extend(
-                            self.validate_fulltext_directive_algorithm(fulltext)
-                                .into_iter(),
-                        );
-                        errors.extend(
-                            self.validate_fulltext_directive_includes(fulltext)
-                                .into_iter(),
-                        );
-                        errors
-                    })
-            })
-    }
-
-    fn validate_fulltext_directive_name(&self, fulltext: &Directive) -> Vec<SchemaValidationError> {
-        let name = match fulltext.argument("name") {
-            Some(Value::String(name)) => name,
-            _ => return vec![SchemaValidationError::FulltextNameUndefined],
-        };
-
-        let local_types: Vec<&ObjectType> = self
-            .document
-            .get_object_type_definitions()
-            .into_iter()
-            .collect();
-
-        // Validate that the fulltext field doesn't collide with any top-level Query fields
-        // generated for entity types. The field name conversions should always align with those used
-        // to create the field names in `graphql::schema::api::query_fields_for_type()`.
-        if local_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)
-            })
-        }) {
-            return vec![SchemaValidationError::FulltextNameCollision(
-                name.to_string(),
-            )];
-        }
-
-        // Validate that each fulltext directive has a distinct name
-        if self
-            .subgraph_schema_object_type()
-            .unwrap()
-            .directives
-            .iter()
-            .filter(|directive| directive.name.eq("fulltext"))
-            .filter_map(|fulltext| {
-                // Collect all @fulltext directives with the same name
-                match fulltext.argument("name") {
-                    Some(Value::String(n)) if name.eq(n) => Some(n.as_str()),
-                    _ => None,
-                }
-            })
-            .count()
-            > 1
-        {
-            vec![SchemaValidationError::FulltextNameConflict(
-                name.to_string(),
-            )]
-        } else {
-            vec![]
-        }
-    }
-
-    fn validate_fulltext_directive_language(
-        &self,
-        fulltext: &Directive,
-    ) -> Vec<SchemaValidationError> {
-        let language = match fulltext.argument("language") {
-            Some(Value::Enum(language)) => language,
-            _ => return vec![SchemaValidationError::FulltextLanguageUndefined],
-        };
-        match FulltextLanguage::try_from(language.as_str()) {
-            Ok(_) => vec![],
-            Err(_) => vec![SchemaValidationError::FulltextLanguageInvalid(
-                language.to_string(),
-            )],
-        }
-    }
-
-    fn validate_fulltext_directive_algorithm(
-        &self,
-        fulltext: &Directive,
-    ) -> Vec<SchemaValidationError> {
-        let algorithm = match fulltext.argument("algorithm") {
-            Some(Value::Enum(algorithm)) => algorithm,
-            _ => return vec![SchemaValidationError::FulltextAlgorithmUndefined],
-        };
-        match FulltextAlgorithm::try_from(algorithm.as_str()) {
-            Ok(_) => vec![],
-            Err(_) => vec![SchemaValidationError::FulltextAlgorithmInvalid(
-                algorithm.to_string(),
-            )],
-        }
-    }
-
-    fn validate_fulltext_directive_includes(
-        &self,
-        fulltext: &Directive,
-    ) -> Vec<SchemaValidationError> {
-        // Only allow fulltext directive on local types
-        let local_types: Vec<&ObjectType> = self
-            .document
-            .get_object_type_definitions()
-            .into_iter()
-            .collect();
-
-        // Validate that each entity in fulltext.include exists
-        let includes = match fulltext.argument("include") {
-            Some(Value::List(includes)) if !includes.is_empty() => includes,
-            _ => return vec![SchemaValidationError::FulltextIncludeUndefined],
-        };
-
-        for include in includes {
-            match include.as_object() {
-                None => return vec![SchemaValidationError::FulltextIncludeObjectMissing],
-                Some(include_entity) => {
-                    let (entity, fields) =
-                        match (include_entity.get("entity"), include_entity.get("fields")) {
-                            (Some(Value::String(entity)), Some(Value::List(fields))) => {
-                                (entity, fields)
-                            }
-                            _ => return vec![SchemaValidationError::FulltextIncludeEntityMissingOrIncorrectAttributes],
-                        };
-
-                    // Validate the included entity type is one of the local types
-                    let entity_type = match local_types
-                        .iter()
-                        .cloned()
-                        .find(|typ| typ.name[..].eq(entity))
-                    {
-                        None => return vec![SchemaValidationError::FulltextIncludedEntityNotFound],
-                        Some(t) => t.clone(),
-                    };
-
-                    for field_value in fields {
-                        let field_name = match field_value {
-                            Value::Object(field_map) => match field_map.get("name") {
-                                Some(Value::String(name)) => name,
-                                _ => return vec![SchemaValidationError::FulltextIncludedFieldMissingRequiredProperty],
-                            },
-                            _ => return vec![SchemaValidationError::FulltextIncludeEntityMissingOrIncorrectAttributes],
-                        };
-
-                        // Validate the included field is a String field on the local entity types specified
-                        if !&entity_type
-                            .fields
-                            .iter()
-                            .any(|field| {
-                                let base_type: &str = field.field_type.get_base_type();
-                                matches!(ValueType::from_str(base_type), Ok(ValueType::String) if field.name.eq(field_name))
-                            })
-                        {
-                            return vec![SchemaValidationError::FulltextIncludedFieldInvalid(
-                                field_name.clone(),
-                            )];
-                        };
-                    }
-                }
-            }
-        }
-        // Fulltext include validations all passed, so we return an empty vector
-        vec![]
-    }
-
-    fn validate_import_directives(&self) -> Vec<SchemaValidationError> {
-        self.subgraph_schema_object_type()
-            .map_or(vec![], |subgraph_schema_type| {
-                subgraph_schema_type
-                    .directives
-                    .iter()
-                    .filter(|directives| directives.name.eq("import"))
-                    .fold(vec![], |mut errors, import| {
-                        Self::validate_import_directive_arguments(import)
-                            .into_iter()
-                            .for_each(|err| errors.push(err));
-                        Self::validate_import_directive_schema_reference_parses(import)
-                            .into_iter()
-                            .for_each(|err| errors.push(err));
-                        errors
-                    })
-            })
-    }
-
-    fn validate_imported_types(
-        &self,
-        schemas: &HashMap<SchemaReference, Arc<Schema>>,
-    ) -> Vec<SchemaValidationError> {
-        self.imported_types()
-            .iter()
-            .fold(vec![], |mut errors, (imported_type, schema_ref)| {
-                schemas
-                    .get(schema_ref)
-                    .and_then(|schema| {
-                        let local_types = schema.document.get_object_type_definitions();
-                        let imported_types = schema.imported_types();
-
-                        // Ensure that the imported type is either local to
-                        // the respective schema or is itself imported
-                        // If the imported type is itself imported, do not
-                        // recursively check the schema
-                        let schema_handle = schema_ref.subgraph.to_string();
-                        let name = imported_type.name.as_str();
-
-                        let is_local = local_types.iter().any(|object| object.name == name);
-                        let is_imported = imported_types
-                            .iter()
-                            .any(|(import, _)| name == import.alias);
-                        if !is_local && !is_imported {
-                            Some(SchemaValidationError::ImportedTypeUndefined(
-                                name.to_string(),
-                                schema_handle,
-                            ))
-                        } else {
-                            None
-                        }
-                    })
-                    .into_iter()
-                    .for_each(|err| errors.push(err));
-                errors
-            })
-    }
-
-    fn validate_fields(&self) -> Vec<SchemaValidationError> {
-        let local_types = self.document.get_object_and_interface_type_fields();
-        let local_enums = self
-            .document
-            .get_enum_definitions()
-            .iter()
-            .map(|enu| enu.name.clone())
-            .collect::<Vec<String>>();
-        let imported_types = self.imported_types();
-        local_types
-            .iter()
-            .fold(vec![], |errors, (type_name, fields)| {
-                fields.iter().fold(errors, |mut errors, field| {
-                    let base = field.field_type.get_base_type();
-                    if ValueType::is_scalar(base) {
-                        return errors;
-                    }
-                    if local_types.contains_key(base) {
-                        return errors;
-                    }
-                    if imported_types
-                        .iter()
-                        .any(|(imported_type, _)| &imported_type.alias == base)
-                    {
-                        return errors;
-                    }
-                    if local_enums.iter().any(|enu| enu.eq(base)) {
-                        return errors;
-                    }
-                    errors.push(SchemaValidationError::FieldTypeUnknown(
-                        type_name.to_string(),
-                        field.name.to_string(),
-                        base.to_string(),
-                    ));
-                    errors
-                })
-            })
-    }
-
-    /// Checks if the schema is using types that are reserved
-    /// by `graph-node`
-    fn validate_reserved_types_usage(&self) -> Result<(), SchemaValidationError> {
-        let document = &self.document;
-        let object_types: Vec<_> = document
-            .get_object_type_definitions()
-            .into_iter()
-            .map(|obj_type| &obj_type.name)
-            .collect();
-
-        let interface_types: Vec<_> = document
-            .get_interface_type_definitions()
-            .into_iter()
-            .map(|iface_type| &iface_type.name)
-            .collect();
-
-        // TYPE_NAME_filter types for all object and interface types
-        let mut filter_types: Vec<String> = object_types
-            .iter()
-            .chain(interface_types.iter())
-            .map(|type_name| format!("{}_filter", type_name))
-            .collect();
-
-        // TYPE_NAME_orderBy types for all object and interface types
-        let mut order_by_types: Vec<_> = object_types
-            .iter()
-            .chain(interface_types.iter())
-            .map(|type_name| format!("{}_orderBy", type_name))
-            .collect();
-
-        let mut reserved_types: Vec<String> = vec![
-            // The built-in scalar types
-            "Boolean".into(),
-            "ID".into(),
-            "Int".into(),
-            "BigDecimal".into(),
-            "String".into(),
-            "Bytes".into(),
-            "BigInt".into(),
-            // Reserved Query and Subscription types
-            "Query".into(),
-            "Subscription".into(),
-        ];
-
-        reserved_types.append(&mut filter_types);
-        reserved_types.append(&mut order_by_types);
-
-        // `reserved_types` will now only contain
-        // the reserved types that the given schema *is* using.
-        //
-        // That is, if the schema is compliant and not using any reserved
-        // types, then it'll become an empty vector
-        reserved_types.retain(|reserved_type| document.get_named_type(reserved_type).is_some());
-
-        if reserved_types.is_empty() {
-            Ok(())
-        } else {
-            Err(SchemaValidationError::UsageOfReservedTypes(Strings(
-                reserved_types,
-            )))
-        }
-    }
-
-    fn validate_schema_types(&self) -> Result<(), SchemaValidationError> {
-        let types_without_entity_directive = self
-            .document
-            .get_object_type_definitions()
-            .iter()
-            .filter(|t| t.find_directive("entity").is_none() && !t.name.eq(SCHEMA_TYPE_NAME))
-            .map(|t| t.name.clone())
-            .collect::<Vec<_>>();
-        if types_without_entity_directive.is_empty() {
-            Ok(())
-        } else {
-            Err(SchemaValidationError::EntityDirectivesMissing(Strings(
-                types_without_entity_directive,
-            )))
-        }
-    }
-
-    fn validate_derived_from(&self) -> Result<(), SchemaValidationError> {
-        // Helper to construct a DerivedFromInvalid
-        fn invalid(
-            object_type: &ObjectType,
-            field_name: &str,
-            reason: &str,
-        ) -> SchemaValidationError {
-            SchemaValidationError::InvalidDerivedFrom(
-                object_type.name.clone(),
-                field_name.to_owned(),
-                reason.to_owned(),
-            )
-        }
-
-        let type_definitions = self.document.get_object_type_definitions();
-        let object_and_interface_type_fields = self.document.get_object_and_interface_type_fields();
-
-        // Iterate over all derived fields in all entity types; include the
-        // interface types that the entity with the `@derivedFrom` implements
-        // and the `field` argument of @derivedFrom directive
-        for (object_type, interface_types, field, target_field) in type_definitions
-            .clone()
-            .iter()
-            .flat_map(|object_type| {
-                object_type
-                    .fields
-                    .iter()
-                    .map(move |field| (object_type, field))
-            })
-            .filter_map(|(object_type, field)| {
-                field.find_directive("derivedFrom").map(|directive| {
-                    (
-                        object_type,
-                        object_type
-                            .implements_interfaces
-                            .iter()
-                            .filter(|iface| {
-                                // Any interface that has `field` can be used
-                                // as the type of the field
-                                self.document
-                                    .find_interface(iface)
-                                    .map(|iface| {
-                                        iface
-                                            .fields
-                                            .iter()
-                                            .any(|ifield| ifield.name.eq(&field.name))
-                                    })
-                                    .unwrap_or(false)
-                            })
-                            .collect::<Vec<_>>(),
-                        field,
-                        directive.argument("field"),
-                    )
-                })
-            })
-        {
-            // Turn `target_field` into the string name of the field
-            let target_field = target_field.ok_or_else(|| {
-                invalid(
-                    object_type,
-                    &field.name,
-                    "the @derivedFrom directive must have a `field` argument",
-                )
-            })?;
-            let target_field = match target_field {
-                Value::String(s) => s,
-                _ => {
-                    return Err(invalid(
-                        object_type,
-                        &field.name,
-                        "the @derivedFrom `field` argument must be a string",
-                    ))
-                }
-            };
-
-            // Check that the type we are deriving from exists
-            let target_type_name = field.field_type.get_base_type();
-            let target_fields = object_and_interface_type_fields
-                .get(target_type_name)
-                .ok_or_else(|| {
-                    invalid(
-                        object_type,
-                        &field.name,
-                        "type must be an existing entity or interface",
-                    )
-                })?;
-
-            // Check that the type we are deriving from has a field with the
-            // right name and type
-            let target_field = target_fields
-                .iter()
-                .find(|field| field.name.eq(target_field))
-                .ok_or_else(|| {
-                    let msg = format!(
-                        "field `{}` does not exist on type `{}`",
-                        target_field, target_type_name
-                    );
-                    invalid(object_type, &field.name, &msg)
-                })?;
-
-            // The field we are deriving from has to point back to us; as an
-            // exception, we allow deriving from the `id` of another type.
-            // For that, we will wind up comparing the `id`s of the two types
-            // 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_type != "ID"
-                && !interface_types
-                    .iter()
-                    .any(|iface| target_field_type.eq(iface.as_str()))
-            {
-                fn type_signatures(name: &str) -> Vec<String> {
-                    vec![
-                        format!("{}", name),
-                        format!("{}!", name),
-                        format!("[{}!]", name),
-                        format!("[{}!]!", name),
-                    ]
-                }
-
-                let mut valid_types = type_signatures(&object_type.name);
-                valid_types.extend(
-                    interface_types
-                        .iter()
-                        .flat_map(|iface| type_signatures(iface)),
-                );
-                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,
-                );
-                return Err(invalid(object_type, &field.name, &msg));
-            }
-        }
-        Ok(())
-    }
-
-    /// Validate that `object` implements `interface`.
-    fn validate_interface_implementation(
-        object: &ObjectType,
-        interface: &InterfaceType,
-    ) -> Result<(), SchemaValidationError> {
-        // Check that all fields in the interface exist in the object with same name and type.
-        let mut missing_fields = vec![];
-        for i in &interface.fields {
-            if !object
-                .fields
-                .iter()
-                .any(|o| o.name.eq(&i.name) && o.field_type.eq(&i.field_type))
-            {
-                missing_fields.push(i.to_string().trim().to_owned());
-            }
-        }
-        if !missing_fields.is_empty() {
-            Err(SchemaValidationError::InterfaceFieldsMissing(
-                object.name.clone(),
-                interface.name.clone(),
-                Strings(missing_fields),
-            ))
-        } else {
-            Ok(())
-        }
-    }
-
-    fn validate_interface_id_type(&self) -> Result<(), SchemaValidationError> {
-        for (intf, obj_types) in &self.types_for_interface {
-            let id_types: HashSet<&str> = HashSet::from_iter(
-                obj_types
-                    .iter()
-                    .filter_map(|obj_type| obj_type.field("id"))
-                    .map(|f| f.field_type.get_base_type())
-                    .map(|name| if name == "ID" { "String" } else { name }),
-            );
-            if id_types.len() > 1 {
-                return Err(SchemaValidationError::InterfaceImplementorsMixId(
-                    intf.to_string(),
-                    id_types.iter().join(", "),
-                ));
-            }
-        }
-        Ok(())
-    }
-
-    fn subgraph_schema_object_type(&self) -> Option<&ObjectType> {
-        self.document
-            .get_object_type_definitions()
-            .into_iter()
-            .find(|object_type| object_type.name.eq(SCHEMA_TYPE_NAME))
-    }
-
-    pub fn entity_fulltext_definitions(
-        entity: &str,
-        document: &Document,
-    ) -> Result<Vec<FulltextDefinition>, anyhow::Error> {
-        Ok(document
-            .get_fulltext_directives()?
-            .into_iter()
-            .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,
-                        },
-                        _ => false,
-                    })
-                }
-                _ => false,
-            })
-            .map(FulltextDefinition::from)
-            .collect())
-    }
-}
-
-#[test]
-fn non_existing_interface() {
-    let schema = "type Foo implements Bar @entity { foo: Int }";
-    let res = Schema::parse(schema, DeploymentHash::new("dummy").unwrap());
-    let error = res
-        .unwrap_err()
-        .downcast::<SchemaValidationError>()
-        .unwrap();
-    assert_eq!(
-        error,
-        SchemaValidationError::InterfaceUndefined("Bar".to_owned())
-    );
-}
-
-#[test]
-fn invalid_interface_implementation() {
-    let schema = "
-        interface Foo {
-            x: Int,
-            y: Int
-        }
-
-        type Bar implements Foo @entity {
-            x: Boolean
-        }
-    ";
-    let res = Schema::parse(schema, DeploymentHash::new("dummy").unwrap());
-    assert_eq!(
-        res.unwrap_err().to_string(),
-        "Entity type `Bar` does not satisfy interface `Foo` because it is missing \
-         the following fields: x: Int, y: Int",
-    );
-}
-
-#[test]
-fn interface_implementations_id_type() {
-    fn check_schema(bar_id: &str, baz_id: &str, ok: bool) {
-        let schema = format!(
-            "interface Foo {{ x: Int }}
-             type Bar implements Foo @entity {{
-                id: {bar_id}!
-                x: Int
-             }}
-
-             type Baz implements Foo @entity {{
-                id: {baz_id}!
-                x: Int
-            }}"
-        );
-        let schema = Schema::parse(&schema, DeploymentHash::new("dummy").unwrap()).unwrap();
-        let res = schema.validate(&HashMap::new());
-        if ok {
-            assert!(matches!(res, Ok(_)));
-        } else {
-            assert!(matches!(res, Err(_)));
-            assert!(matches!(
-                res.unwrap_err()[0],
-                SchemaValidationError::InterfaceImplementorsMixId(_, _)
-            ));
-        }
-    }
-    check_schema("ID", "ID", true);
-    check_schema("ID", "String", true);
-    check_schema("ID", "Bytes", false);
-    check_schema("Bytes", "String", false);
-}
-
-#[test]
-fn test_derived_from_validation() {
-    const OTHER_TYPES: &str = "
-type B @entity { id: ID! }
-type C @entity { id: ID! }
-type D @entity { id: ID! }
-type E @entity { id: ID! }
-type F @entity { id: ID! }
-type G @entity { id: ID! a: BigInt }
-type H @entity { id: ID! a: A! }
-# This sets up a situation where we need to allow `Transaction.from` to
-# point to an interface because of `Account.txn`
-type Transaction @entity { from: Address! }
-interface Address { txn: Transaction! @derivedFrom(field: \"from\") }
-type Account implements Address @entity { id: ID!, txn: Transaction! @derivedFrom(field: \"from\") }";
-
-    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)
-            .expect("Failed to parse raw schema")
-            .into_static();
-        let schema = Schema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
-        match schema.validate_derived_from() {
-            Err(ref e) => match e {
-                SchemaValidationError::InvalidDerivedFrom(_, _, msg) => assert_eq!(errmsg, msg),
-                _ => panic!("expected variant SchemaValidationError::DerivedFromInvalid"),
-            },
-            Ok(_) => {
-                if errmsg != "ok" {
-                    panic!("expected validation for `{}` to fail", field)
-                }
-            }
-        }
-    }
-
-    validate(
-        "b: B @derivedFrom(field: \"a\")",
-        "field `a` does not exist on type `B`",
-    );
-    validate(
-        "c: [C!]! @derivedFrom(field: \"a\")",
-        "field `a` does not exist on type `C`",
-    );
-    validate(
-        "d: D @derivedFrom",
-        "the @derivedFrom directive must have a `field` argument",
-    );
-    validate(
-        "e: E @derivedFrom(attr: \"a\")",
-        "the @derivedFrom directive must have a `field` argument",
-    );
-    validate(
-        "f: F @derivedFrom(field: 123)",
-        "the @derivedFrom `field` argument must be a string",
-    );
-    validate(
-        "g: G @derivedFrom(field: \"a\")",
-        "field `a` on type `G` must have one of the following types: A, A!, [A!], [A!]!",
-    );
-    validate("h: H @derivedFrom(field: \"a\")", "ok");
-    validate(
-        "i: NotAType @derivedFrom(field: \"a\")",
-        "type must be an existing entity or interface",
-    );
-    validate("j: B @derivedFrom(field: \"id\")", "ok");
-}
-
-#[test]
-fn test_reserved_type_with_fields() {
-    const ROOT_SCHEMA: &str = "
-type _Schema_ { id: ID! }";
-
-    let document = graphql_parser::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
-    let schema = Schema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
-    assert_eq!(
-        schema
-            .validate_schema_type_has_no_fields()
-            .expect_err("Expected validation to fail due to fields defined on the reserved type"),
-        SchemaValidationError::SchemaTypeWithFields
-    )
-}
-
-#[test]
-fn test_reserved_type_directives() {
-    const ROOT_SCHEMA: &str = "
-type _Schema_ @illegal";
-
-    let document = graphql_parser::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
-    let schema = Schema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
-    assert_eq!(
-        schema.validate_directives_on_schema_type().expect_err(
-            "Expected validation to fail due to extra imports defined on the reserved type"
-        ),
-        SchemaValidationError::InvalidSchemaTypeDirectives
-    )
-}
-
-#[test]
-fn test_imports_directive_from_argument() {
-    const ROOT_SCHEMA: &str = r#"
-type _Schema_ @import(types: ["T", "A", "C"])"#;
-
-    let document = graphql_parser::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
-    let schema = Schema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
-    match schema
-        .validate_import_directives()
-        .into_iter()
-        .find(|err| *err == SchemaValidationError::ImportDirectiveInvalid) {
-            None => panic!(
-                "Expected validation for `{}` to fail due to an @imports directive without a `from` argument",
-                ROOT_SCHEMA,
-            ),
-            _ => (),
-    }
-}
-
-#[test]
-fn test_enums_pass_field_validation() {
-    const ROOT_SCHEMA: &str = r#"
-enum Color {
-  RED
-  GREEN
-}
-
-type A @entity {
-  id: ID!
-  color: Color
-}"#;
-
-    let document = graphql_parser::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
-    let schema = Schema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
-    assert_eq!(schema.validate_fields().len(), 0);
-}
-
-#[test]
-fn test_recursively_imported_type_validates() {
-    const ROOT_SCHEMA: &str = r#"
-type _Schema_ @import(types: ["T"], from: { id: "c1id" })"#;
-    const CHILD_1_SCHEMA: &str = r#"
-type _Schema_ @import(types: ["T"], from: { id: "c2id" })"#;
-    const CHILD_2_SCHEMA: &str = r#"
-type T @entity { id: ID! }
-"#;
-
-    let root_document =
-        graphql_parser::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
-    let child_1_document =
-        graphql_parser::parse_schema(CHILD_1_SCHEMA).expect("Failed to parse child 1 schema");
-    let child_2_document =
-        graphql_parser::parse_schema(CHILD_2_SCHEMA).expect("Failed to parse child 2 schema");
-
-    let c1id = DeploymentHash::new("c1id").unwrap();
-    let c2id = DeploymentHash::new("c2id").unwrap();
-    let root_schema = Schema::new(DeploymentHash::new("rid").unwrap(), root_document).unwrap();
-    let child_1_schema = Schema::new(c1id.clone(), child_1_document).unwrap();
-    let child_2_schema = Schema::new(c2id.clone(), child_2_document).unwrap();
-
-    let mut schemas = HashMap::new();
-    schemas.insert(SchemaReference::new(c1id), Arc::new(child_1_schema));
-    schemas.insert(SchemaReference::new(c2id), Arc::new(child_2_schema));
-
-    match root_schema.validate_imported_types(&schemas).is_empty() {
-        false => panic!(
-            "Expected imported types validation for `{}` to suceed",
-            ROOT_SCHEMA,
-        ),
-        true => (),
-    }
-}
-
-#[test]
-fn test_recursively_imported_type_which_dne_fails_validation() {
-    const ROOT_SCHEMA: &str = r#"
-type _Schema_ @import(types: ["T"], from: { id:"c1id"})"#;
-    const CHILD_1_SCHEMA: &str = r#"
-type _Schema_ @import(types: [{name: "T", as: "A"}], from: { id:"c2id"})"#;
-    const CHILD_2_SCHEMA: &str = r#"
-type T @entity { id: ID! }
-"#;
-    let root_document =
-        graphql_parser::parse_schema(ROOT_SCHEMA).expect("Failed to parse root schema");
-    let child_1_document =
-        graphql_parser::parse_schema(CHILD_1_SCHEMA).expect("Failed to parse child 1 schema");
-    let child_2_document =
-        graphql_parser::parse_schema(CHILD_2_SCHEMA).expect("Failed to parse child 2 schema");
-
-    let c1id = DeploymentHash::new("c1id").unwrap();
-    let c2id = DeploymentHash::new("c2id").unwrap();
-    let root_schema = Schema::new(DeploymentHash::new("rid").unwrap(), root_document).unwrap();
-    let child_1_schema = Schema::new(c1id.clone(), child_1_document).unwrap();
-    let child_2_schema = Schema::new(c2id.clone(), child_2_document).unwrap();
-
-    let mut schemas = HashMap::new();
-    schemas.insert(SchemaReference::new(c1id), Arc::new(child_1_schema));
-    schemas.insert(SchemaReference::new(c2id), Arc::new(child_2_schema));
-
-    match root_schema.validate_imported_types(&schemas).into_iter().find(|err| match err {
-        SchemaValidationError::ImportedTypeUndefined(_, _) => true,
-        _ => false,
-    }) {
-        None => panic!(
-            "Expected imported types validation to fail because an imported type was missing in the target schema",
-        ),
-        _ => (),
-    }
-}
-
-#[test]
-fn test_reserved_types_validation() {
-    let reserved_types = [
-        // Built-in scalars
-        "Boolean",
-        "ID",
-        "Int",
-        "BigDecimal",
-        "String",
-        "Bytes",
-        "BigInt",
-        // Reserved keywords
-        "Query",
-        "Subscription",
-    ];
-
-    let dummy_hash = DeploymentHash::new("dummy").unwrap();
-
-    for reserved_type in reserved_types {
-        let schema = format!("type {} @entity {{ _: Boolean }}\n", reserved_type);
-
-        let schema = Schema::parse(&schema, dummy_hash.clone()).unwrap();
-
-        let errors = schema.validate(&HashMap::new()).unwrap_err();
-        for error in errors {
-            assert!(matches!(
-                error,
-                SchemaValidationError::UsageOfReservedTypes(_)
-            ))
-        }
-    }
-}
-
-#[test]
-fn test_reserved_filter_and_group_by_types_validation() {
-    const SCHEMA: &str = r#"
-    type Gravatar @entity {
-        _: Boolean
-      }
-    type Gravatar_filter @entity {
-        _: Boolean
-    }
-    type Gravatar_orderBy @entity {
-        _: Boolean
-    }
-    "#;
-
-    let dummy_hash = DeploymentHash::new("dummy").unwrap();
-
-    let schema = Schema::parse(SCHEMA, dummy_hash).unwrap();
-
-    let errors = schema.validate(&HashMap::new()).unwrap_err();
-
-    // The only problem in the schema is the usage of reserved types
-    assert_eq!(errors.len(), 1);
-
-    assert!(matches!(
-        &errors[0],
-        SchemaValidationError::UsageOfReservedTypes(Strings(_))
-    ));
-
-    // We know this will match due to the assertion above
-    match &errors[0] {
-        SchemaValidationError::UsageOfReservedTypes(Strings(reserved_types)) => {
-            let expected_types: Vec<String> =
-                vec!["Gravatar_filter".into(), "Gravatar_orderBy".into()];
-            assert_eq!(reserved_types, &expected_types);
-        }
-        _ => unreachable!(),
-    }
-}
-
-#[test]
-fn test_fulltext_directive_validation() {
-    const SCHEMA: &str = r#"
-type _Schema_ @fulltext(
-  name: "metadata"
-  language: en
-  algorithm: rank
-  include: [
-    {
-      entity: "Gravatar",
-      fields: [
-        { name: "displayName"},
-        { name: "imageUrl"},
-      ]
-    }
-  ]
-)
-type Gravatar @entity {
-  id: ID!
-  owner: Bytes!
-  displayName: String!
-  imageUrl: String!
-}"#;
-
-    let document = graphql_parser::parse_schema(SCHEMA).expect("Failed to parse schema");
-    let schema = Schema::new(DeploymentHash::new("id1").unwrap(), document).unwrap();
-
-    assert_eq!(schema.validate_fulltext_directives(), vec![]);
-}
diff --git a/graph/src/data/store/ethereum.rs b/graph/src/data/store/ethereum.rs
index ada156e36fb..29f4544c71c 100644
--- a/graph/src/data/store/ethereum.rs
+++ b/graph/src/data/store/ethereum.rs
@@ -1,12 +1,7 @@
 use super::scalar;
+use crate::derive::CheapClone;
 use crate::prelude::*;
-use web3::types::{Address, Bytes, H2048, H256, H64, U128, U256, U64};
-
-impl From<U128> for Value {
-    fn from(n: U128) -> Value {
-        Value::BigInt(scalar::BigInt::from_signed_u256(&n.into()))
-    }
-}
+use alloy::primitives::{Address, B64, B256, Bytes, U64, aliases::B2048};
 
 impl From<Address> for Value {
     fn from(address: Address) -> Value {
@@ -14,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()))
     }
 }
 
@@ -44,8 +39,119 @@ impl From<U64> for Value {
     }
 }
 
-impl From<U256> for Value {
-    fn from(n: U256) -> Value {
-        Value::BigInt(BigInt::from_unsigned_u256(&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
new file mode 100644
index 00000000000..8391da53b76
--- /dev/null
+++ b/graph/src/data/store/id.rs
@@ -0,0 +1,583 @@
+//! Types and helpers to deal with entity IDs which support a subset of the
+//! types that more general values support
+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;
+
+use crate::{
+    anyhow, bail,
+    components::store::BlockNumber,
+    data::graphql::{ObjectTypeExt, TypeExt},
+    prelude::s,
+};
+
+use crate::{
+    components::store::StoreError,
+    data::value::Word,
+    derive::CacheWeight,
+    internal_error,
+    prelude::QueryExecutionError,
+    runtime::gas::{Gas, GasSizeOf},
+};
+
+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)]
+pub enum IdType {
+    String,
+    Bytes,
+    Int8,
+}
+
+impl IdType {
+    /// Parse the given string into an ID of this type
+    pub fn parse(&self, s: Word) -> Result<Id, Error> {
+        match self {
+            IdType::String => Ok(Id::String(s)),
+            IdType::Bytes => {
+                Ok(Id::Bytes(s.parse().with_context(|| {
+                    format!("can not convert `{s}` to Id::Bytes")
+                })?))
+            }
+            IdType::Int8 => {
+                Ok(Id::Int8(s.parse().with_context(|| {
+                    format!("can not convert `{s}` to Id::Int8")
+                })?))
+            }
+        }
+    }
+
+    pub fn as_str(&self) -> &str {
+        match self {
+            IdType::String => "String",
+            IdType::Bytes => "Bytes",
+            IdType::Int8 => "Int8",
+        }
+    }
+
+    /// Generate an entity id from the block number and a sequence number.
+    ///
+    /// * Bytes: `[block:4, seq:4]`
+    /// * Int8: `[block:4, seq:4]`
+    /// * String: Always an error; users should use `Bytes` or `Int8`
+    ///   instead
+    pub fn generate_id(&self, block: BlockNumber, seq: u32) -> anyhow::Result<Id> {
+        match self {
+            IdType::String => bail!("String does not support generating ids"),
+            IdType::Bytes => {
+                let mut bytes = [0u8; 8];
+                bytes[0..4].copy_from_slice(&block.to_be_bytes());
+                bytes[4..8].copy_from_slice(&seq.to_be_bytes());
+                let bytes = scalar::Bytes::from(bytes);
+                Ok(Id::Bytes(bytes))
+            }
+            IdType::Int8 => {
+                let mut bytes = [0u8; 8];
+                bytes[0..4].copy_from_slice(&seq.to_le_bytes());
+                bytes[4..8].copy_from_slice(&block.to_le_bytes());
+                Ok(Id::Int8(i64::from_le_bytes(bytes)))
+            }
+        }
+    }
+}
+
+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)
+            .ok_or_else(|| anyhow!("Type {} does not have an `id` field", obj_type.name))?
+            .field_type
+            .get_base_type();
+
+        match base_type {
+            "ID" | "String" => Ok(IdType::String),
+            "Bytes" => Ok(IdType::Bytes),
+            "Int8" => Ok(IdType::Int8),
+            s => Err(anyhow!(
+                "Entity type {} uses illegal type {} for id column",
+                obj_type.name,
+                s
+            )),
+        }
+    }
+}
+
+impl TryFrom<&s::Type> for IdType {
+    type Error = StoreError;
+
+    fn try_from(field_type: &s::Type) -> Result<Self, Self::Error> {
+        let name = field_type.get_base_type();
+
+        match name.parse()? {
+            ValueType::String => Ok(IdType::String),
+            ValueType::Bytes => Ok(IdType::Bytes),
+            ValueType::Int8 => Ok(IdType::Int8),
+            _ => Err(anyhow!(
+                "The `id` field has type `{}` but only `String`, `Bytes`, `Int8`, and `ID` are allowed",
+                &name
+            )
+            .into()),
+        }
+    }
+}
+
+impl std::fmt::Display for IdType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+/// Values for the ids of entities
+#[derive(Clone, CacheWeight, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Id {
+    String(Word),
+    Bytes(scalar::Bytes),
+    Int8(i64),
+}
+
+impl Id {
+    pub fn id_type(&self) -> IdType {
+        match self {
+            Id::String(_) => IdType::String,
+            Id::Bytes(_) => IdType::Bytes,
+            Id::Int8(_) => IdType::Int8,
+        }
+    }
+}
+
+impl std::hash::Hash for Id {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        core::mem::discriminant(self).hash(state);
+        match self {
+            Id::String(s) => s.hash(state),
+            Id::Bytes(b) => b.hash(state),
+            Id::Int8(i) => i.hash(state),
+        }
+    }
+}
+
+impl PartialEq<Value> for Id {
+    fn eq(&self, other: &Value) -> bool {
+        match (self, other) {
+            (Id::String(s), Value::String(v)) => s.as_str() == v.as_str(),
+            (Id::Bytes(s), Value::Bytes(v)) => s == v,
+            (Id::Int8(s), Value::Int8(v)) => s == v,
+            _ => false,
+        }
+    }
+}
+
+impl PartialEq<Id> for Value {
+    fn eq(&self, other: &Id) -> bool {
+        other.eq(self)
+    }
+}
+
+impl TryFrom<Value> for Id {
+    type Error = Error;
+
+    fn try_from(value: Value) -> Result<Self, Self::Error> {
+        match value {
+            Value::String(s) => Ok(Id::String(Word::from(s))),
+            Value::Bytes(b) => Ok(Id::Bytes(b)),
+            Value::Int8(i) => Ok(Id::Int8(i)),
+            _ => Err(anyhow!(
+                "expected string or bytes for id but found {:?}",
+                value
+            )),
+        }
+    }
+}
+
+impl From<Id> for Value {
+    fn from(value: Id) -> Self {
+        match value {
+            Id::String(s) => Value::String(s.into()),
+            Id::Bytes(b) => Value::Bytes(b),
+            Id::Int8(i) => Value::Int8(i),
+        }
+    }
+}
+
+impl std::fmt::Display for Id {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Id::String(s) => write!(f, "{}", s),
+            Id::Bytes(b) => write!(f, "{}", b),
+            Id::Int8(i) => write!(f, "{}", i),
+        }
+    }
+}
+
+impl GasSizeOf for Id {
+    fn gas_size_of(&self) -> Gas {
+        match self {
+            Id::String(s) => s.gas_size_of(),
+            Id::Bytes(b) => b.gas_size_of(),
+            Id::Int8(i) => i.gas_size_of(),
+        }
+    }
+}
+
+impl StableHash for Id {
+    fn stable_hash<H: StableHasher>(&self, field_address: H::Addr, state: &mut H) {
+        match self {
+            Id::String(s) => stable_hash::StableHash::stable_hash(s, field_address, state),
+            Id::Bytes(b) => {
+                // We have to convert here to a string `0xdeadbeef` for
+                // backwards compatibility. It would be nice to avoid that
+                // allocation and just use the bytes directly, but that will
+                // break PoI compatibility
+                stable_hash::StableHash::stable_hash(&b.to_string(), field_address, state)
+            }
+            Id::Int8(i) => stable_hash::StableHash::stable_hash(i, field_address, state),
+        }
+    }
+}
+
+impl stable_hash_legacy::StableHash for Id {
+    fn stable_hash<H: stable_hash_legacy::StableHasher>(
+        &self,
+        sequence_number: H::Seq,
+        state: &mut H,
+    ) {
+        match self {
+            Id::String(s) => stable_hash_legacy::StableHash::stable_hash(s, sequence_number, state),
+            Id::Bytes(b) => {
+                stable_hash_legacy::StableHash::stable_hash(&b.to_string(), sequence_number, state)
+            }
+            Id::Int8(i) => stable_hash_legacy::StableHash::stable_hash(i, sequence_number, state),
+        }
+    }
+}
+
+/// A value that contains a reference to the underlying data for an entity
+/// ID. This is used to avoid cloning the ID when it is not necessary.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
+pub enum IdRef<'a> {
+    String(&'a str),
+    Bytes(&'a [u8]),
+    Int8(i64),
+}
+
+impl std::fmt::Display for IdRef<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            IdRef::String(s) => write!(f, "{}", s),
+            IdRef::Bytes(b) => write!(f, "0x{}", hex::encode(b)),
+            IdRef::Int8(i) => write!(f, "{}", i),
+        }
+    }
+}
+
+impl<'a> IdRef<'a> {
+    pub fn to_value(self) -> Id {
+        match self {
+            IdRef::String(s) => Id::String(Word::from(s.to_owned())),
+            IdRef::Bytes(b) => Id::Bytes(scalar::Bytes::from(b)),
+            IdRef::Int8(i) => Id::Int8(i),
+        }
+    }
+
+    fn id_type(&self) -> IdType {
+        match self {
+            IdRef::String(_) => IdType::String,
+            IdRef::Bytes(_) => IdType::Bytes,
+            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
+/// same `IdType`
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum IdList {
+    String(Vec<Word>),
+    Bytes(Vec<scalar::Bytes>),
+    Int8(Vec<i64>),
+}
+
+impl IdList {
+    pub fn new(typ: IdType) -> Self {
+        match typ {
+            IdType::String => IdList::String(Vec::new()),
+            IdType::Bytes => IdList::Bytes(Vec::new()),
+            IdType::Int8 => IdList::Int8(Vec::new()),
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        match self {
+            IdList::String(ids) => ids.len(),
+            IdList::Bytes(ids) => ids.len(),
+            IdList::Int8(ids) => ids.len(),
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn id_type(&self) -> IdType {
+        match self {
+            IdList::String(_) => IdType::String,
+            IdList::Bytes(_) => IdType::Bytes,
+            IdList::Int8(_) => IdType::Int8,
+        }
+    }
+
+    /// 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>>(
+        id_type: IdType,
+        mut iter: I,
+    ) -> Result<Self, QueryExecutionError> {
+        match id_type {
+            IdType::String => {
+                let ids: Vec<Word> = iter.try_fold(vec![], |mut ids, id| match id {
+                    Id::String(id) => {
+                        ids.push(id);
+                        Ok(ids)
+                    }
+                    _ => Err(internal_error!(
+                        "expected string id, got {}: {}",
+                        id.id_type(),
+                        id,
+                    )),
+                })?;
+                Ok(IdList::String(ids))
+            }
+            IdType::Bytes => {
+                let ids: Vec<scalar::Bytes> = iter.try_fold(vec![], |mut ids, id| match id {
+                    Id::Bytes(id) => {
+                        ids.push(id);
+                        Ok(ids)
+                    }
+                    _ => Err(internal_error!(
+                        "expected bytes id, got {}: {}",
+                        id.id_type(),
+                        id,
+                    )),
+                })?;
+                Ok(IdList::Bytes(ids))
+            }
+            IdType::Int8 => {
+                let ids: Vec<i64> = iter.try_fold(vec![], |mut ids, id| match id {
+                    Id::Int8(id) => {
+                        ids.push(id);
+                        Ok(ids)
+                    }
+                    _ => Err(internal_error!(
+                        "expected int8 id, got {}: {}",
+                        id.id_type(),
+                        id,
+                    )),
+                })?;
+                Ok(IdList::Int8(ids))
+            }
+        }
+    }
+
+    /// Turn a list of references to ids into an `IdList` and check that
+    /// they are all the same type. Note that this method clones all the ids
+    /// and `try_from_iter` is therefore preferrable
+    pub fn try_from_iter_ref<'a, I: Iterator<Item = IdRef<'a>>>(
+        mut iter: I,
+    ) -> Result<Self, QueryExecutionError> {
+        let first = match iter.next() {
+            Some(id) => id,
+            None => return Ok(IdList::String(Vec::new())),
+        };
+        match first {
+            IdRef::String(s) => {
+                let ids: Vec<_> = iter.try_fold(vec![Word::from(s)], |mut ids, id| match id {
+                    IdRef::String(id) => {
+                        ids.push(Word::from(id));
+                        Ok(ids)
+                    }
+                    _ => Err(internal_error!(
+                        "expected string id, got {}: 0x{}",
+                        id.id_type(),
+                        id,
+                    )),
+                })?;
+                Ok(IdList::String(ids))
+            }
+            IdRef::Bytes(b) => {
+                let ids: Vec<_> =
+                    iter.try_fold(vec![scalar::Bytes::from(b)], |mut ids, id| match id {
+                        IdRef::Bytes(id) => {
+                            ids.push(scalar::Bytes::from(id));
+                            Ok(ids)
+                        }
+                        _ => Err(internal_error!(
+                            "expected bytes id, got {}: {}",
+                            id.id_type(),
+                            id,
+                        )),
+                    })?;
+                Ok(IdList::Bytes(ids))
+            }
+            IdRef::Int8(i) => {
+                let ids: Vec<_> = iter.try_fold(vec![i], |mut ids, id| match id {
+                    IdRef::Int8(id) => {
+                        ids.push(id);
+                        Ok(ids)
+                    }
+                    _ => Err(internal_error!(
+                        "expected int8 id, got {}: {}",
+                        id.id_type(),
+                        id,
+                    )),
+                })?;
+                Ok(IdList::Int8(ids))
+            }
+        }
+    }
+
+    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()),
+            IdList::Int8(ids) => IdRef::Int8(ids[index]),
+        }
+    }
+
+    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.is_empty() {
+            Some(self.index(0))
+        } else {
+            None
+        }
+    }
+
+    pub fn iter(&self) -> Box<dyn Iterator<Item = IdRef<'_>> + '_> {
+        match self {
+            IdList::String(ids) => Box::new(ids.iter().map(|id| IdRef::String(id))),
+            IdList::Bytes(ids) => Box::new(ids.iter().map(|id| IdRef::Bytes(id))),
+            IdList::Int8(ids) => Box::new(ids.iter().map(|id| IdRef::Int8(*id))),
+        }
+    }
+
+    pub fn as_unique(self) -> Self {
+        match self {
+            IdList::String(mut ids) => {
+                ids.sort_unstable();
+                ids.dedup();
+                IdList::String(ids)
+            }
+            IdList::Bytes(mut ids) => {
+                ids.sort_unstable_by(|id1, id2| id1.as_slice().cmp(id2.as_slice()));
+                ids.dedup();
+                IdList::Bytes(ids)
+            }
+            IdList::Int8(mut ids) => {
+                ids.sort_unstable();
+                ids.dedup();
+                IdList::Int8(ids)
+            }
+        }
+    }
+
+    pub fn push(&mut self, entity_id: Id) -> Result<(), StoreError> {
+        match (self, entity_id) {
+            (IdList::String(ids), Id::String(id)) => {
+                ids.push(id);
+                Ok(())
+            }
+            (IdList::Bytes(ids), Id::Bytes(id)) => {
+                ids.push(id);
+                Ok(())
+            }
+            (IdList::Int8(ids), Id::Int8(id)) => {
+                ids.push(id);
+                Ok(())
+            }
+            (list, id) => Err(internal_error!(
+                "expected id of type {}, but got {}[{}]",
+                list.id_type(),
+                id.id_type(),
+                id
+            )),
+        }
+    }
+
+    pub fn as_ids(self) -> Vec<Id> {
+        match self {
+            IdList::String(ids) => ids.into_iter().map(Id::String).collect(),
+            IdList::Bytes(ids) => ids.into_iter().map(Id::Bytes).collect(),
+            IdList::Int8(ids) => ids.into_iter().map(Id::Int8).collect(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::data::store::{Id, IdType};
+
+    #[test]
+    fn generate_id() {
+        let id = IdType::Bytes.generate_id(1, 2).unwrap();
+        let exp = IdType::Bytes.parse("0x0000000100000002".into()).unwrap();
+        assert_eq!(exp, id);
+
+        let id = IdType::Bytes.generate_id(3, 2).unwrap();
+        let exp = IdType::Bytes.parse("0x0000000300000002".into()).unwrap();
+        assert_eq!(exp, id);
+
+        let id = IdType::Int8.generate_id(3, 2).unwrap();
+        let exp = Id::Int8(0x0000_0003_0000_0002);
+        assert_eq!(exp, id);
+
+        // Should be id + 1
+        let id2 = IdType::Int8.generate_id(3, 3).unwrap();
+        let d = id2.to_string().parse::<i64>().unwrap() - id.to_string().parse::<i64>().unwrap();
+        assert_eq!(1, d);
+        // Should be id + 2^32
+        let id3 = IdType::Int8.generate_id(4, 2).unwrap();
+        let d = id3.to_string().parse::<i64>().unwrap() - id.to_string().parse::<i64>().unwrap();
+        assert_eq!(1 << 32, d);
+
+        IdType::String.generate_id(3, 2).unwrap_err();
+    }
+}
diff --git a/graph/src/data/store/mod.rs b/graph/src/data/store/mod.rs
index 534bc5dec6c..d0b3ff7edd1 100644
--- a/graph/src/data/store/mod.rs
+++ b/graph/src/data/store/mod.rs
@@ -1,27 +1,28 @@
 use crate::{
-    components::store::{DeploymentLocator, EntityKey, EntityType},
-    data::graphql::ObjectTypeExt,
-    prelude::{anyhow::Context, q, r, s, CacheWeight, QueryExecutionError, Schema},
+    derive::CacheWeight,
+    prelude::{CacheWeight, QueryExecutionError, lazy_static, q, r, s},
     runtime::gas::{Gas, GasSizeOf},
+    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};
 use stable_hash::{FieldAddress, StableHash, StableHasher};
 use std::convert::TryFrom;
 use std::fmt;
-use std::iter::FromIterator;
 use std::str::FromStr;
-use std::{
-    borrow::Cow,
-    collections::{BTreeMap, HashMap},
-};
-use strum::AsStaticRef as _;
-use strum_macros::AsStaticStr;
+use std::sync::Arc;
+use std::{borrow::Cow, cmp::Ordering};
+use strum_macros::IntoStaticStr;
+use thiserror::Error;
+
+use super::{graphql::TypeExt as _, value::Word};
 
-use super::graphql::{ext::DirectiveFinder, DocumentExt as _, TypeExt as _};
+/// Handling of entity ids
+mod id;
+pub use id::{Id, IdList, IdRef, IdType};
 
 /// Custom scalars in GraphQL.
 pub mod scalar;
@@ -29,43 +30,27 @@ pub mod scalar;
 // Ethereum compatibility.
 pub mod ethereum;
 
-/// 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,
-            (Self::Assignment, EntityChange::Assignment { .. }) => true,
-            _ => false,
-        }
-    }
+/// Conversion of values to/from SQL
+pub mod sql;
+
+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))
@@ -99,49 +84,30 @@ 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"))
     }
 }
 
 /// An entity attribute name is represented as a string.
 pub type Attribute = String;
 
-pub const ID: &str = "ID";
 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, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub enum ValueType {
     Boolean,
     BigInt,
     Bytes,
     BigDecimal,
     Int,
+    Int8,
     String,
+    Timestamp,
 }
 
 impl FromStr for ValueType {
@@ -154,6 +120,8 @@ impl FromStr for ValueType {
             "Bytes" => Ok(ValueType::Bytes),
             "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)),
         }
@@ -165,16 +133,85 @@ impl ValueType {
     pub fn is_scalar(s: &str) -> bool {
         Self::from_str(s).is_ok()
     }
+
+    pub fn is_numeric(&self) -> bool {
+        match self {
+            ValueType::BigInt | ValueType::BigDecimal | ValueType::Int | ValueType::Int8 => true,
+            ValueType::Boolean | ValueType::Bytes | ValueType::String | ValueType::Timestamp => {
+                false
+            }
+        }
+    }
+
+    pub fn to_str(&self) -> &'static str {
+        match self {
+            ValueType::Boolean => "Boolean",
+            ValueType::BigInt => "BigInt",
+            ValueType::Bytes => "Bytes",
+            ValueType::BigDecimal => "BigDecimal",
+            ValueType::Int => "Int",
+            ValueType::Int8 => "Int8",
+            ValueType::Timestamp => "Timestamp",
+            ValueType::String => "String",
+        }
+    }
+}
+
+/// Types are ordered by how values for the types can be coerced to 'larger'
+/// types; for example, `Int < BigInt`
+impl PartialOrd for ValueType {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        use Ordering::*;
+        use ValueType::*;
+
+        match (self, other) {
+            (Boolean, Boolean)
+            | (BigInt, BigInt)
+            | (Bytes, Bytes)
+            | (BigDecimal, BigDecimal)
+            | (Int, Int)
+            | (Int8, Int8)
+            | (String, String) => Some(Equal),
+            (BigInt, BigDecimal)
+            | (Int, BigInt)
+            | (Int, BigDecimal)
+            | (Int, Int8)
+            | (Int8, BigInt)
+            | (Int8, BigDecimal) => Some(Less),
+            (BigInt, Int)
+            | (BigInt, Int8)
+            | (BigDecimal, BigInt)
+            | (BigDecimal, Int)
+            | (BigDecimal, Int8)
+            | (Int8, Int) => Some(Greater),
+            (Timestamp, _)
+            | (_, Timestamp)
+            | (Boolean, _)
+            | (_, Boolean)
+            | (Bytes, _)
+            | (_, Bytes)
+            | (String, _)
+            | (_, String) => None,
+        }
+    }
+}
+
+impl From<ValueType> for s::Type {
+    fn from(value_type: ValueType) -> Self {
+        s::Type::NamedType(value_type.to_str().to_owned())
+    }
 }
 
 // Note: Do not modify fields without also making a backward compatible change to the StableHash impl (below)
 /// An attribute value is represented as an enum with variants for all supported value types.
 #[derive(Clone, Deserialize, Serialize, PartialEq, Eq)]
 #[serde(tag = "type", content = "data")]
-#[derive(AsStaticStr)]
+#[derive(IntoStaticStr)]
 pub enum Value {
     String(String),
     Int(i32),
+    Int8(i64),
+    Timestamp(scalar::Timestamp),
     BigDecimal(scalar::BigDecimal),
     Bool(bool),
     List(Vec<Value>),
@@ -183,21 +220,23 @@ pub enum Value {
     BigInt(scalar::BigInt),
 }
 
+pub const NULL: Value = Value::Null;
+
 impl stable_hash_legacy::StableHash for Value {
     fn stable_hash<H: stable_hash_legacy::StableHasher>(
         &self,
         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 {
             return;
         }
         stable_hash_legacy::StableHash::stable_hash(
-            &self.as_static().to_string(),
+            &Into::<&str>::into(self).to_string(),
             sequence_number.next_child(),
             state,
         );
@@ -210,6 +249,9 @@ impl stable_hash_legacy::StableHash for Value {
             Int(inner) => {
                 stable_hash_legacy::StableHash::stable_hash(inner, sequence_number, state)
             }
+            Int8(inner) => {
+                stable_hash_legacy::StableHash::stable_hash(inner, sequence_number, state)
+            }
             BigDecimal(inner) => {
                 stable_hash_legacy::StableHash::stable_hash(inner, sequence_number, state)
             }
@@ -225,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)
+            }
         }
     }
 }
@@ -268,15 +313,29 @@ impl StableHash for Value {
                 inner.stable_hash(field_address.child(0), state);
                 7
             }
+            Int8(inner) => {
+                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])
     }
 }
 
+impl NullValue for Value {
+    fn null() -> Self {
+        Value::Null
+    }
+}
+
 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
@@ -301,17 +360,31 @@ impl Value {
                 // just a string.
                 match n.as_str() {
                     BYTES_SCALAR => Value::Bytes(scalar::Bytes::from_str(s)?),
-                    BIG_INT_SCALAR => Value::BigInt(scalar::BigInt::from_str(s)?),
+                    BIG_INT_SCALAR => Value::BigInt(scalar::BigInt::from_str(s).map_err(|e| {
+                        QueryExecutionError::ValueParseError("BigInt".to_string(), format!("{}", e))
+                    })?),
                     BIG_DECIMAL_SCALAR => Value::BigDecimal(scalar::BigDecimal::from_str(s)?),
+                    INT8_SCALAR => Value::Int8(s.parse::<i64>().map_err(|_| {
+                        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(),
                 ));
             }
@@ -346,6 +419,14 @@ impl Value {
         }
     }
 
+    pub fn as_int8(&self) -> Option<i64> {
+        if let Value::Int8(i) = self {
+            Some(*i)
+        } else {
+            None
+        }
+    }
+
     pub fn as_big_decimal(self) -> Option<scalar::BigDecimal> {
         if let Value::BigDecimal(d) = self {
             Some(d)
@@ -394,6 +475,8 @@ impl Value {
             Value::Bool(_) => "Boolean".to_owned(),
             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())
@@ -414,6 +497,8 @@ impl Value {
             | (Value::Bool(_), ValueType::Boolean)
             | (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()
@@ -421,6 +506,10 @@ impl Value {
             _ => false,
         }
     }
+
+    fn is_null(&self) -> bool {
+        matches!(self, Value::Null)
+    }
 }
 
 impl fmt::Display for Value {
@@ -431,13 +520,15 @@ impl fmt::Display for Value {
             match self {
                 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(),
             }
         )
     }
@@ -448,6 +539,8 @@ impl fmt::Debug for Value {
         match self {
             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(),
@@ -463,6 +556,8 @@ impl From<Value> for q::Value {
         match 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,
@@ -480,6 +575,8 @@ impl From<Value> for r::Value {
         match 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,
@@ -516,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)
@@ -546,6 +649,12 @@ impl From<u64> for Value {
     }
 }
 
+impl From<i64> for Value {
+    fn from(value: i64) -> Value {
+        Value::Int8(value)
+    }
+}
+
 impl TryFrom<Value> for Option<scalar::BigInt> {
     type Error = Error;
 
@@ -579,91 +688,326 @@ 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, Debug, Default, Deserialize, PartialEq, Eq, Serialize)]
-pub struct Entity(HashMap<Attribute, Value>);
+#[derive(Clone, CacheWeight, Eq, Serialize)]
+pub struct Entity(Object<Value>);
 
-impl stable_hash_legacy::StableHash for Entity {
-    #[inline]
-    fn stable_hash<H: stable_hash_legacy::StableHasher>(
-        &self,
-        mut sequence_number: H::Seq,
-        state: &mut H,
-    ) {
-        use stable_hash_legacy::SequenceNumber;
-        let Self(inner) = self;
-        stable_hash_legacy::StableHash::stable_hash(inner, sequence_number.next_child(), state);
+impl<'a> IntoIterator for &'a Entity {
+    type Item = (&'a str, &'a Value);
+
+    type IntoIter =
+        std::iter::Filter<intern::ObjectIter<'a, Value>, fn(&(&'a str, &'a Value)) -> bool>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        (&self.0).into_iter().filter(|(k, _)| *k != VID_FIELD)
     }
 }
 
-impl StableHash for Entity {
-    fn stable_hash<H: StableHasher>(&self, field_address: H::Addr, state: &mut H) {
-        let Self(inner) = self;
-        StableHash::stable_hash(inner, field_address.child(0), state);
+pub trait IntoEntityIterator: IntoIterator<Item = (Word, Value)> {}
+
+impl<T: IntoIterator<Item = (Word, Value)>> IntoEntityIterator for T {}
+
+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 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}"
+    )]
+    MismatchedElementTypeInList {
+        entity: String,
+        entity_id: String,
+        field: String,
+        expected_type: String,
+        value: String,
+        actual_type: String,
+        index: usize,
+    },
+
+    #[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,
+        value: String,
+        field: String,
+        expected_type: String,
+        actual_type: String,
+    },
+
+    #[error("Entity {entity}[{entity_id}]: missing value for non-nullable field `{field}`")]
+    MissingValueForNonNullableField {
+        entity: String,
+        entity_id: String,
+        field: String,
+    },
+
+    #[error("Entity {entity}[{entity_id}]: field `{field}` is derived and cannot be set")]
+    CannotSetDerivedField {
+        entity: String,
+        entity_id: String,
+        field: String,
+    },
+
+    #[error("Unknown key `{0}`. It probably is not part of the schema")]
+    UnknownKey(String),
+
+    #[error("Internal error: no id attribute for entity `{entity}`")]
+    MissingIDAttribute { entity: String },
+
+    #[error("Unsupported type for `id` attribute")]
+    UnsupportedTypeForIDAttribute,
+}
+
+/// The `entity!` macro is a convenient way to create entities in tests. It
+/// can not be used in production code since it panics when creating the
+/// entity goes wrong.
+///
+/// The macro takes a schema and a list of attribute names and values:
+/// ```
+///   use graph::entity;
+///   use graph::schema::InputSchema;
+///   use graph::data::subgraph::{LATEST_VERSION, DeploymentHash};
+///
+///   let id = DeploymentHash::new("Qm123").unwrap();
+///   let schema = InputSchema::parse(LATEST_VERSION, "type User @entity { id: String!, name: String! }", id).unwrap();
+///
+///   let entity = entity! { schema => id: "1", name: "John Doe" };
+/// ```
+#[cfg(debug_assertions)]
 #[macro_export]
 macro_rules! entity {
-    ($($name:ident: $value:expr,)*) => {
+    ($schema:expr => $($name:ident: $value:expr,)*) => {
         {
-            let mut result = $crate::data::store::Entity::new();
-            $(
-                result.set(stringify!($name), $crate::data::store::Value::from($value));
-            )*
-            result
+            let result = vec![$(
+                ($crate::data::value::Word::from(stringify!($name)), $crate::data::store::Value::from($value)),
+            )*];
+            $schema.make_entity(result).unwrap()
         }
     };
-    ($($name:ident: $value:expr),*) => {
-        entity! {$($name: $value,)*}
+    ($schema:expr => $($name:ident: $value:expr),*) => {
+        entity! {$schema => $($name: $value,)*}
     };
 }
 
 impl Entity {
-    /// Creates a new entity with no attributes set.
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    pub fn get(&self, key: &str) -> Option<&Value> {
-        self.0.get(key)
+    pub fn make<I: IntoEntityIterator>(
+        pool: Arc<AtomPool>,
+        iter: I,
+    ) -> Result<Entity, EntityValidationError> {
+        let mut obj = Object::new(pool);
+        for (key, value) in iter {
+            obj.insert(key, value)
+                .map_err(|e| EntityValidationError::unknown_key(e.not_interned()))?;
+        }
+        let entity = Entity(obj);
+        entity.check_id()?;
+        Ok(entity)
     }
 
-    pub fn insert(&mut self, key: String, value: Value) -> Option<Value> {
-        self.0.insert(key, value)
+    pub fn try_make<E: std::error::Error + Send + Sync + 'static, I: TryIntoEntityIterator<E>>(
+        pool: Arc<AtomPool>,
+        iter: I,
+    ) -> Result<Entity, Error> {
+        let mut obj = Object::new(pool);
+        for pair in iter {
+            let (key, value) = pair?;
+            obj.insert(key, value)
+                .map_err(|e| anyhow!("unknown attribute {}", e.not_interned()))?;
+        }
+        let entity = Entity(obj);
+        entity.check_id()?;
+        Ok(entity)
     }
 
-    pub fn remove(&mut self, key: &str) -> Option<Value> {
-        self.0.remove(key)
+    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<(String, Value)> {
-        let mut v: Vec<_> = self.0.into_iter().collect();
+    pub fn sorted(self) -> Vec<(Word, Value)> {
+        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().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::missing_id_attribute(format!(
+                "{:?}",
+                self.0
+            ))),
+            Some(Value::String(_)) | Some(Value::Bytes(_)) | Some(Value::Int8(_)) => Ok(()),
+            _ => Err(EntityValidationError::unsupported_type_for_id_attribute()),
+        }
+    }
+
     /// Return the ID of this entity. If the ID is a string, return the
     /// string. If it is `Bytes`, return it as a hex string with a `0x`
     /// prefix. If the ID is not set or anything but a `String` or `Bytes`,
     /// return an error
-    pub fn id(&self) -> Result<String, Error> {
-        match self.get("id") {
-            None => Err(anyhow!("Entity is missing an `id` attribute")),
-            Some(Value::String(s)) => Ok(s.clone()),
-            Some(Value::Bytes(b)) => Ok(b.to_string()),
-            _ => Err(anyhow!("Entity has non-string `id` attribute")),
-        }
+    pub fn id(&self) -> Id {
+        Id::try_from(self.get("id").unwrap().clone()).expect("the id is set to a valid value")
     }
 
-    /// Convenience method to save having to `.into()` the arguments.
-    pub fn set(&mut self, name: impl Into<Attribute>, value: impl Into<Value>) -> Option<Value> {
-        self.0.insert(name.into(), value.into())
+    /// 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.
@@ -672,9 +1016,7 @@ impl Entity {
     /// 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 set to `Value::Null`.
     pub fn merge(&mut self, update: Entity) {
-        for (key, value) in update.0.into_iter() {
-            self.insert(key, value);
-        }
+        self.0.merge(update.0);
     }
 
     /// Merges an entity update `update` into this entity, removing `Value::Null` values.
@@ -682,136 +1024,99 @@ 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) {
+    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.remove(&key),
-                _ => self.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(changed)
+    }
+
+    /// Remove all entries with value `Value::Null` from `self`
+    pub fn remove_null_fields(&mut self) {
+        self.0.retain(|_, value| !value.is_null())
+    }
+
+    /// Add the key/value pairs from `iter` to this entity. This is the same
+    /// as an implementation of `std::iter::Extend` would be, except that
+    /// this operation is fallible because one of the keys from the iterator
+    /// might not be in the underlying pool
+    pub fn merge_iter(
+        &mut self,
+        iter: impl IntoIterator<Item = (impl AsRef<str>, Value)>,
+    ) -> Result<(), InternError> {
+        for (key, value) in iter {
+            self.0.insert(key, value)?;
         }
+        Ok(())
     }
 
     /// Validate that this entity matches the object type definition in the
     /// schema. An entity that passes these checks can be stored
     /// successfully in the subgraph's database schema
-    pub fn validate(&self, schema: &Schema, key: &EntityKey) -> Result<(), anyhow::Error> {
-        fn scalar_value_type(schema: &Schema, field_type: &s::Type) -> ValueType {
-            use s::TypeDefinition as t;
-            match field_type {
-                s::Type::NamedType(name) => ValueType::from_str(name).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");
-                            scalar_value_type(schema, &id.field_type)
-                        }
-                        Some(t::Interface(intf)) => {
-                            // Validation checks that all implementors of an
-                            // interface use the same type for `id`. It is
-                            // therefore enough to use the id type of one of
-                            // the implementors
-                            match schema
-                                .types_for_interface()
-                                .get(&EntityType::new(intf.name.clone()))
-                                .expect("interface type names are known")
-                                .first()
-                            {
-                                None => {
-                                    // Nothing is implementing this interface; we assume it's of type string
-                                    // see also: id-type-for-unimplemented-interfaces
-                                    ValueType::String
-                                }
-                                Some(obj_type) => {
-                                    let id =
-                                        obj_type.field("id").expect("all object types have an id");
-                                    scalar_value_type(schema, &id.field_type)
-                                }
-                            }
-                        }
-                        Some(t::Enum(_)) => ValueType::String,
-                        Some(t::Scalar(_)) => unreachable!("user-defined scalars are not used"),
-                        Some(t::Union(_)) => unreachable!("unions are not used"),
-                        Some(t::InputObject(_)) => unreachable!("inputObjects are not used"),
-                        None => unreachable!("names of field types have been validated"),
-                    }
-                }),
-                s::Type::NonNullType(inner) => scalar_value_type(schema, inner),
-                s::Type::ListType(inner) => scalar_value_type(schema, inner),
-            }
-        }
-
+    pub fn validate(&self, key: &EntityKey) -> Result<(), EntityValidationError> {
         if key.entity_type.is_poi() {
             // Users can't modify Poi entities, and therefore they do not
             // need to be validated. In addition, the schema has no object
             // type for them, and validation would therefore fail
             return Ok(());
         }
-        let object_type_definitions = schema.document.get_object_type_definitions();
-        let object_type = object_type_definitions
-            .iter()
-            .find(|object_type| key.entity_type.as_str() == object_type.name)
-            .with_context(|| {
-                format!(
-                    "Entity {}[{}]: unknown entity type `{}`",
-                    key.entity_type, key.entity_id, key.entity_type
-                )
-            })?;
-
-        for field in &object_type.fields {
-            let is_derived = field.is_derived();
-            match (self.get(&field.name), is_derived) {
+
+        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()) {
                 (Some(value), false) => {
-                    let scalar_type = scalar_value_type(schema, &field.field_type);
+                    let scalar_type = &field.value_type;
                     if field.field_type.is_list() {
                         // Check for inhomgeneous lists to produce a better
                         // error message for them; other problems, like
                         // 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) {
-                                    anyhow::bail!(
-                                        "Entity {}[{}]: field `{}` is of type {}, but the value `{}` \
-                                        contains a {} at index {}",
-                                        key.entity_type,
-                                        key.entity_id,
-                                        field.name,
-                                        &field.field_type,
-                                        value,
-                                        elt.type_name(),
-                                        index
+                                if !elt.is_assignable(scalar_type, false) {
+                                    return Err(
+                                        EntityValidationError::mismatched_element_type_in_list(
+                                            key, field, value, elt, index,
+                                        ),
                                     );
                                 }
                             }
                         }
                     }
-                    if !value.is_assignable(&scalar_type, field.field_type.is_list()) {
-                        anyhow::bail!(
-                            "Entity {}[{}]: the value `{}` for field `{}` must have type {} but has type {}",
-                            key.entity_type,
-                            key.entity_id,
-                            value,
-                            field.name,
-                            &field.field_type,
-                            value.type_name()
-                        );
+                    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() {
-                        anyhow::bail!(
-                            "Entity {}[{}]: missing value for non-nullable field `{}`",
-                            key.entity_type,
-                            key.entity_id,
-                            field.name,
-                        );
+                        return Err(EntityValidationError::missing_value_for_non_nullable_field(
+                            key, field,
+                        ));
                     }
                 }
                 (Some(_), true) => {
-                    anyhow::bail!(
-                        "Entity {}[{}]: field `{}` is derived and can not be set",
-                        key.entity_type,
-                        key.entity_id,
-                        field.name,
-                    );
+                    return Err(EntityValidationError::cannot_set_derived_field(key, field));
                 }
                 (None, true) => {
                     // derived fields should not be set
@@ -822,21 +1127,39 @@ impl Entity {
     }
 }
 
-impl From<Entity> for BTreeMap<String, q::Value> {
-    fn from(entity: Entity) -> BTreeMap<String, q::Value> {
-        entity.0.into_iter().map(|(k, v)| (k, v.into())).collect()
+/// 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)
     }
 }
 
-impl From<Entity> for q::Value {
-    fn from(entity: Entity) -> q::Value {
-        q::Value::Object(entity.into())
+/// Convenience methods to modify individual attributes for tests.
+/// Production code should not use/need this.
+#[cfg(debug_assertions)]
+impl Entity {
+    pub fn insert(&mut self, key: &str, value: Value) -> Result<Option<Value>, InternError> {
+        self.0.insert(key, value)
     }
-}
 
-impl From<HashMap<Attribute, Value>> for Entity {
-    fn from(m: HashMap<Attribute, Value>) -> Entity {
-        Entity(m)
+    pub fn remove(&mut self, key: &str) -> Option<Value> {
+        self.0.remove(key)
+    }
+
+    pub fn set(
+        &mut self,
+        name: &str,
+        value: impl Into<Value>,
+    ) -> 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");
+        }
     }
 }
 
@@ -846,29 +1169,39 @@ impl<'a> From<&'a Entity> for Cow<'a, Entity> {
     }
 }
 
-impl<'a> From<Vec<(&'a str, Value)>> for Entity {
-    fn from(entries: Vec<(&'a str, Value)>) -> Entity {
-        Entity::from(HashMap::from_iter(
-            entries.into_iter().map(|(k, v)| (String::from(k), v)),
-        ))
+impl GasSizeOf for Entity {
+    fn gas_size_of(&self) -> Gas {
+        self.0.gas_size_of()
     }
 }
 
-impl CacheWeight for Entity {
-    fn indirect_weight(&self) -> usize {
-        self.0.indirect_weight()
+impl std::fmt::Debug for Entity {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut ds = f.debug_struct("Entity");
+        for (k, v) in &self.0 {
+            ds.field(k, v);
+        }
+        ds.finish()
     }
 }
 
-impl GasSizeOf for Entity {
-    fn gas_size_of(&self) -> Gas {
-        self.0.gas_size_of()
-    }
+/// An object that is returned from a query. It's a an `r::Value` which
+/// carries the attributes of the object (`__typename`, `id` etc.) and
+/// possibly a pointer to its parent if the query that constructed it is one
+/// that depends on parents
+pub struct QueryObject {
+    pub parent: Option<Id>,
+    pub entity: r::Object,
 }
 
-/// A value that can (maybe) be converted to an `Entity`.
-pub trait TryIntoEntity {
-    fn try_into_entity(self) -> Result<Entity, Error>;
+/// 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()
+    }
 }
 
 #[test]
@@ -879,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);
@@ -900,41 +1235,44 @@ fn value_bigint() {
 
 #[test]
 fn entity_validation() {
+    use crate::data::subgraph::DeploymentHash;
+    use crate::schema::EntityType;
+    use crate::schema::InputSchema;
+
+    const DOCUMENT: &str = "
+    enum Color { red, yellow, blue }
+    interface Stuff { id: ID!, name: String! }
+    type Cruft @entity {
+        id: ID!,
+        thing: Thing!
+    }
+    type Thing @entity {
+        id: ID!,
+        name: String!,
+        favorite_color: Color,
+        stuff: Stuff,
+        things: [Thing!]!
+        # Make sure we do not validate derived fields; it's ok
+        # to store a thing with a null Cruft
+        cruft: Cruft! @derivedFrom(field: \"thing\")
+    }";
+
+    lazy_static! {
+        static ref SUBGRAPH: DeploymentHash = DeploymentHash::new("doesntmatter").unwrap();
+        static ref SCHEMA: InputSchema = InputSchema::parse_latest(DOCUMENT, SUBGRAPH.clone())
+            .expect("Failed to parse test schema");
+        static ref THING_TYPE: EntityType = SCHEMA.entity_type("Thing").unwrap();
+    }
+
     fn make_thing(name: &str) -> Entity {
-        let mut thing = Entity::new();
-        thing.set("id", name);
-        thing.set("name", name);
-        thing.set("stuff", "less");
-        thing.set("favorite_color", "red");
-        thing.set("things", Value::List(vec![]));
-        thing
+        entity! { SCHEMA => id: name, name: name, stuff: "less", favorite_color: "red", things: Value::List(vec![]) }
     }
 
     fn check(thing: Entity, errmsg: &str) {
-        const DOCUMENT: &str = "
-      enum Color { red, yellow, blue }
-      interface Stuff { id: ID!, name: String! }
-      type Cruft @entity {
-          id: ID!,
-          thing: Thing!
-      }
-      type Thing @entity {
-          id: ID!,
-          name: String!,
-          favorite_color: Color,
-          stuff: Stuff,
-          things: [Thing!]!
-          # Make sure we do not validate derived fields; it's ok
-          # to store a thing with a null Cruft
-          cruft: Cruft! @derivedFrom(field: \"thing\")
-      }";
-        let subgraph = DeploymentHash::new("doesntmatter").unwrap();
-        let schema =
-            crate::prelude::Schema::parse(DOCUMENT, subgraph).expect("Failed to parse test schema");
-        let id = thing.id().unwrap_or("none".to_owned());
-        let key = EntityKey::data("Thing".to_owned(), id.clone());
-
-        let err = thing.validate(&schema, &key);
+        let id = thing.id();
+        let key = THING_TYPE.key(id.clone());
+
+        let err = thing.validate(&key);
         if errmsg.is_empty() {
             assert!(
                 err.is_ok(),
@@ -953,7 +1291,9 @@ fn entity_validation() {
     }
 
     let mut thing = make_thing("t1");
-    thing.set("things", Value::from(vec!["thing1", "thing2"]));
+    thing
+        .set("things", Value::from(vec!["thing1", "thing2"]))
+        .unwrap();
     check(thing, "");
 
     let thing = make_thing("t2");
@@ -974,7 +1314,7 @@ fn entity_validation() {
     );
 
     let mut thing = make_thing("t5");
-    thing.set("name", Value::Int(32));
+    thing.set("name", Value::Int(32)).unwrap();
     check(
         thing,
         "Entity Thing[t5]: the value `32` for field `name` must \
@@ -982,7 +1322,9 @@ fn entity_validation() {
     );
 
     let mut thing = make_thing("t6");
-    thing.set("things", Value::List(vec!["thing1".into(), 17.into()]));
+    thing
+        .set("things", Value::List(vec!["thing1".into(), 17.into()]))
+        .unwrap();
     check(
         thing,
         "Entity Thing[t6]: field `things` is of type [Thing!]!, \
@@ -995,10 +1337,10 @@ fn entity_validation() {
     check(thing, "");
 
     let mut thing = make_thing("t8");
-    thing.set("cruft", "wat");
+    thing.set("cruft", "wat").unwrap();
     check(
         thing,
-        "Entity Thing[t8]: field `cruft` is derived and can not be set",
+        "Entity Thing[t8]: field `cruft` is derived and cannot be set",
     );
 }
 
@@ -1018,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 ad5b2df360e..00000000000
--- a/graph/src/data/store/scalar.rs
+++ /dev/null
@@ -1,739 +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::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.0, -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(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 implementation 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(int).stable_hash(field_address, state);
-    }
-}
-
-#[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub struct BigInt(num_bigint::BigInt);
-
-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.0.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.0.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]) -> Self {
-        BigInt(num_bigint::BigInt::from_bytes_le(
-            num_bigint::Sign::Plus,
-            bytes,
-        ))
-    }
-
-    pub fn from_signed_bytes_le(bytes: &[u8]) -> Self {
-        BigInt(num_bigint::BigInt::from_signed_bytes_le(bytes))
-    }
-
-    pub fn from_signed_bytes_be(bytes: &[u8]) -> Self {
-        BigInt(num_bigint::BigInt::from_signed_bytes_be(bytes))
-    }
-
-    pub fn to_bytes_le(&self) -> (BigIntSign, Vec<u8>) {
-        self.0.to_bytes_le()
-    }
-
-    pub fn to_bytes_be(&self) -> (BigIntSign, Vec<u8>) {
-        self.0.to_bytes_be()
-    }
-
-    pub fn to_signed_bytes_le(&self) -> Vec<u8> {
-        self.0.to_signed_bytes_le()
-    }
-
-    /// Deprecated. Use try_into instead
-    pub fn to_u64(&self) -> u64 {
-        self.try_into().unwrap()
-    }
-
-    pub fn from_unsigned_u256(n: &U256) -> Self {
-        let mut bytes: [u8; 32] = [0; 32];
-        n.to_little_endian(&mut bytes);
-        BigInt::from_unsigned_bytes_le(&bytes)
-    }
-
-    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)
-    }
-
-    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) -> Self {
-        use num_traits::pow::Pow;
-
-        BigInt(self.0.pow(&exponent))
-    }
-
-    pub fn bits(&self) -> usize {
-        self.0.bits()
-    }
-}
-
-impl Display for BigInt {
-    fn fmt(&self, f: &mut Formatter) -> Result<(), fmt::Error> {
-        self.0.fmt(f)
-    }
-}
-
-impl From<num_bigint::BigInt> for BigInt {
-    fn from(big_int: num_bigint::BigInt) -> BigInt {
-        BigInt(big_int)
-    }
-}
-
-impl From<i32> for BigInt {
-    fn from(i: i32) -> BigInt {
-        BigInt(i.into())
-    }
-}
-
-impl From<u64> for BigInt {
-    fn from(i: u64) -> BigInt {
-        BigInt(i.into())
-    }
-}
-
-impl From<i64> for BigInt {
-    fn from(i: i64) -> BigInt {
-        BigInt(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 From<U128> for BigInt {
-    /// This implementation assumes that U128 represents an unsigned U128,
-    /// and not a signed U128 (aka int128 in Solidity). Right now, this is
-    /// all we need (for block numbers). If it ever becomes necessary to
-    /// handle signed U128s, we should add the same
-    /// `{to,from}_{signed,unsigned}_u128` methods that we have for U256.
-    fn from(n: U128) -> BigInt {
-        let mut bytes: [u8; 16] = [0; 16];
-        n.to_little_endian(&mut bytes);
-        BigInt::from_unsigned_bytes_le(&bytes)
-    }
-}
-
-impl FromStr for BigInt {
-    type Err = <num_bigint::BigInt as FromStr>::Err;
-
-    fn from_str(s: &str) -> Result<BigInt, Self::Err> {
-        num_bigint::BigInt::from_str(s).map(BigInt)
-    }
-}
-
-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(self.0.add(other.0))
-    }
-}
-
-impl Sub for BigInt {
-    type Output = BigInt;
-
-    fn sub(self, other: BigInt) -> BigInt {
-        BigInt(self.0.sub(other.0))
-    }
-}
-
-impl Mul for BigInt {
-    type Output = BigInt;
-
-    fn mul(self, other: BigInt) -> BigInt {
-        BigInt(self.0.mul(other.0))
-    }
-}
-
-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(self.0.div(other.0))
-    }
-}
-
-impl Rem for BigInt {
-    type Output = BigInt;
-
-    fn rem(self, other: BigInt) -> BigInt {
-        BigInt(self.0.rem(other.0))
-    }
-}
-
-impl BitOr for BigInt {
-    type Output = Self;
-
-    fn bitor(self, other: Self) -> Self {
-        Self::from(self.0.bitor(other.0))
-    }
-}
-
-impl BitAnd for BigInt {
-    type Output = Self;
-
-    fn bitand(self, other: Self) -> Self {
-        Self::from(self.0.bitand(other.0))
-    }
-}
-
-impl Shl<u8> for BigInt {
-    type Output = Self;
-
-    fn shl(self, bits: u8) -> Self {
-        Self::from(self.0.shl(bits.into()))
-    }
-}
-
-impl Shr<u8> for BigInt {
-    type Output = Self;
-
-    fn shr(self, bits: u8) -> Self {
-        Self::from(self.0.shr(bits.into()))
-    }
-}
-
-/// A byte array that's serialized as a hex string prefixed by `0x`.
-#[derive(Clone, PartialEq, Eq)]
-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())
-    }
-}
-
-#[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()));
-    }
-
-    #[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
new file mode 100644
index 00000000000..7124927ee74
--- /dev/null
+++ b/graph/src/data/store/sql.rs
@@ -0,0 +1,90 @@
+use anyhow::anyhow;
+use diesel::pg::Pg;
+use diesel::serialize::{self, Output, ToSql};
+use diesel::sql_types::{Binary, Bool, Int8, Integer, Text, Timestamptz};
+
+use std::str::FromStr;
+
+use super::{Value, scalar};
+
+impl ToSql<Bool, Pg> for Value {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
+        match self {
+            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
+            )
+            .into()),
+        }
+    }
+}
+
+impl ToSql<Integer, Pg> for Value {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
+        match self {
+            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
+            )
+            .into()),
+        }
+    }
+}
+
+impl ToSql<Int8, Pg> for Value {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
+        match self {
+            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
+            )
+            .into()),
+        }
+    }
+}
+
+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(&self, out: &mut Output<Pg>) -> serialize::Result {
+        match self {
+            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
+            )
+            .into()),
+        }
+    }
+}
+
+impl ToSql<Binary, Pg> for Value {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
+        match self {
+            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 b69567ebed0..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);
@@ -15,6 +18,15 @@ pub const API_VERSION_0_0_6: Version = Version::new(0, 0, 6);
 /// Enables event handlers to require transaction receipts in the runtime.
 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.
@@ -32,6 +44,37 @@ pub const SPEC_VERSION_0_0_6: Version = Version::new(0, 0, 6);
 /// Enables offchain data sources.
 pub const SPEC_VERSION_0_0_7: Version = Version::new(0, 0, 7);
 
+/// Enables polling block handlers and initialisation handlers.
+pub const SPEC_VERSION_0_0_8: Version = Version::new(0, 0, 8);
+
+// Enables `endBlock` feature.
+pub const SPEC_VERSION_0_0_9: Version = Version::new(0, 0, 9);
+
+// Enables `indexerHints` feature.
+pub const SPEC_VERSION_1_0_0: Version = Version::new(1, 0, 0);
+
+// Enables @aggregation entities
+// 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_5_0;
+
 pub const MIN_SPEC_VERSION: Version = Version::new(0, 0, 2);
 
 #[derive(Clone, PartialEq, Debug)]
@@ -52,19 +95,34 @@ 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))
     }
+
+    pub fn version(&self) -> Option<&Version> {
+        self.0.as_ref()
+    }
 }
 
 pub(super) fn format_versions(versions: &BTreeSet<Version>) -> String {
diff --git a/graph/src/data/subgraph/features.rs b/graph/src/data/subgraph/features.rs
index c86d6eb84c7..dd2263858f9 100644
--- a/graph/src/data/subgraph/features.rs
+++ b/graph/src/data/subgraph/features.rs
@@ -12,8 +12,9 @@
 
 use crate::{
     blockchain::Blockchain,
-    data::{graphql::DocumentExt, schema::Schema, subgraph::SubgraphManifest},
+    data::subgraph::SubgraphManifest,
     prelude::{Deserialize, Serialize},
+    schema::InputSchema,
 };
 use itertools::Itertools;
 use std::{collections::BTreeSet, fmt, str::FromStr};
@@ -32,6 +33,10 @@ pub enum SubgraphFeature {
     NonFatalErrors,
     Grafting,
     FullTextSearch,
+    Aggregations,
+    BytesAsIds,
+    DeclaredEthCalls,
+    ImmutableEntities,
     #[serde(alias = "nonDeterministicIpfs")]
     IpfsOnEthereumContracts,
 }
@@ -110,8 +115,8 @@ fn detect_grafting<C: Blockchain>(manifest: &SubgraphManifest<C>) -> Option<Subg
     manifest.graft.as_ref().map(|_| SubgraphFeature::Grafting)
 }
 
-fn detect_full_text_search(schema: &Schema) -> Option<SubgraphFeature> {
-    match schema.document.get_fulltext_directives() {
+fn detect_full_text_search(schema: &InputSchema) -> Option<SubgraphFeature> {
+    match schema.get_fulltext_directives() {
         Ok(directives) => (!directives.is_empty()).then_some(SubgraphFeature::FullTextSearch),
 
         Err(_) => {
@@ -153,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 037d0a0042d..0c20405cdf1 100644
--- a/graph/src/data/subgraph/mod.rs
+++ b/graph/src/data/subgraph/mod.rs
@@ -3,55 +3,67 @@ 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 anyhow::{anyhow, Error};
-use futures03::{future::try_join3, 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::{de, ser};
+use serde::{
+    de::{self, Visitor},
+    ser,
+};
 use serde_yaml;
-use slog::{info, Logger};
+use slog::Logger;
 use stable_hash::{FieldAddress, StableHash};
 use stable_hash_legacy::SequenceNumber;
-use std::{collections::BTreeSet, marker::PhantomData};
+use std::{
+    collections::{BTreeSet, HashMap, HashSet},
+    marker::PhantomData,
+};
 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::{
-        graphql::TryFromValue,
-        query::QueryExecutionError,
-        schema::{Schema, SchemaImportError, SchemaValidationError},
-        store::Entity,
+        graphql::TryFromValue, query::QueryExecutionError,
         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, 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;
 use std::str::FromStr;
 use std::sync::Arc;
 
+use super::{graphql::IntoValue, value::Word};
+
 /// Deserialize an Address (with or without '0x' prefix).
 fn deserialize_address<'de, D>(deserializer: D) -> Result<Option<Address>, D::Error>
 where
@@ -68,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>(
@@ -92,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
@@ -102,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))
@@ -126,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 {
@@ -173,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
@@ -181,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.
@@ -189,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.
@@ -211,13 +240,19 @@ impl SubgraphName {
                 || !last_char.is_ascii_alphanumeric()
                 || !part.chars().any(|c| c.is_ascii_alphabetic())
             {
-                return Err(());
+                return Err(s);
             }
         }
 
         Ok(SubgraphName(s))
     }
 
+    /// Tests are allowed to create arbitrary subgraph names
+    #[cfg(debug_assertions)]
+    pub fn new_unchecked(s: impl Into<String>) -> Self {
+        SubgraphName(s.into())
+    }
+
     pub fn as_str(&self) -> &str {
         self.0.as_str()
     }
@@ -245,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"))
     }
 }
 
@@ -314,12 +349,6 @@ impl From<::diesel::result::Error> for SubgraphAssignmentProviderError {
     }
 }
 
-#[derive(Error, Debug)]
-pub enum SubgraphManifestValidationWarning {
-    #[error("schema validation produced warnings: {0:?}")]
-    SchemaValidationWarning(SchemaImportError),
-}
-
 #[derive(Error, Debug)]
 pub enum SubgraphManifestValidationError {
     #[error("subgraph has no data sources")]
@@ -330,10 +359,8 @@ 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("imported schema(s) are invalid: {0:?}")]
-    SchemaImportError(Vec<SchemaImportError>),
     #[error("schema validation failed: {0:?}")]
     SchemaValidationError(Vec<SchemaValidationError>),
     #[error("the graft base is invalid: {0}")]
@@ -344,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)]
@@ -354,20 +383,98 @@ pub enum SubgraphManifestResolveError {
     NonUtf8,
     #[error("subgraph is not valid YAML")]
     InvalidFormat,
-    #[error("resolve error: {0}")]
+    #[error("resolve error: {0:#}")]
     ResolveError(#[from] anyhow::Error),
 }
 
-/// Data source contexts are conveniently represented as entities.
-pub type DataSourceContext = Entity;
+#[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())
+    }
+
+    // This collects the entries 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().collect();
+        v.sort_by(|(k1, _), (k2, _)| k1.cmp(k2));
+        v
+    }
+}
+
+impl From<HashMap<Word, Value>> for DataSourceContext {
+    fn from(map: HashMap<Word, Value>) -> Self {
+        Self(map)
+    }
+}
 
 /// 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 {
@@ -384,18 +491,25 @@ 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<Schema, anyhow::Error> {
-        info!(logger, "Resolve schema"; "link" => &self.file.link);
-
-        let schema_bytes = resolver.cat(logger, &self.file).await?;
-        Schema::parse(&String::from_utf8(schema_bytes)?, id)
+    ) -> Result<InputSchema, anyhow::Error> {
+        let schema_bytes = resolver
+            .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)
     }
 }
 
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct Source {
     /// The contract address for the data source. We allow data sources
     /// without an address for 'wildcard' triggers that catch all possible
@@ -403,8 +517,9 @@ pub struct Source {
     #[serde(default, deserialize_with = "deserialize_address")]
     pub address: Option<Address>,
     pub abi: String,
-    #[serde(rename = "startBlock", default)]
+    #[serde(default)]
     pub start_block: BlockNumber,
+    pub end_block: Option<BlockNumber>,
 }
 
 pub fn calls_host_fn(runtime: &[u8], host_fn: &str) -> anyhow::Result<bool> {
@@ -414,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);
                 }
             }
@@ -462,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.
             //
@@ -469,9 +596,61 @@ 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(())
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct DeploymentFeatures {
+    pub id: String,
+    pub spec_version: String,
+    pub api_version: Option<String>,
+    pub features: Vec<String>,
+    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 {
+    fn into_value(self) -> r::Value {
+        object! {
+            __typename: "SubgraphFeatures",
+            specVersion: self.spec_version,
+            apiVersion: self.api_version,
+            features: self.features,
+            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
         }
     }
 }
@@ -492,36 +671,194 @@ pub struct BaseSubgraphManifest<C, S, D, T> {
     pub templates: Vec<T>,
     #[serde(skip_serializing, default)]
     pub chain: PhantomData<C>,
+    pub indexer_hints: Option<IndexerHints>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IndexerHints {
+    pub prune: Option<Prune>,
+}
+
+impl IndexerHints {
+    pub fn history_blocks(&self) -> BlockNumber {
+        match self.prune {
+            Some(ref hb) => hb.history_blocks(),
+            None => BLOCK_NUMBER_MAX,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum Prune {
+    Auto,
+    Never,
+    Blocks(BlockNumber),
+}
+
+impl Prune {
+    pub fn history_blocks(&self) -> BlockNumber {
+        match self {
+            Prune::Never => BLOCK_NUMBER_MAX,
+            Prune::Auto => ENV_VARS.min_history_blocks,
+            Prune::Blocks(x) => *x,
+        }
+    }
+}
+
+impl<'de> de::Deserialize<'de> for Prune {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: de::Deserializer<'de>,
+    {
+        struct HistoryBlocksVisitor;
+
+        const ERROR_MSG: &str = "expected 'all', 'min', or a number for history blocks";
+
+        impl<'de> Visitor<'de> for HistoryBlocksVisitor {
+            type Value = Prune;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a string or an integer for history blocks")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Prune, E>
+            where
+                E: de::Error,
+            {
+                match value {
+                    "never" => Ok(Prune::Never),
+                    "auto" => Ok(Prune::Auto),
+                    _ => value
+                        .parse::<i32>()
+                        .map(Prune::Blocks)
+                        .map_err(|_| E::custom(ERROR_MSG)),
+                }
+            }
+
+            fn visit_i32<E>(self, value: i32) -> Result<Prune, E>
+            where
+                E: de::Error,
+            {
+                Ok(Prune::Blocks(value))
+            }
+
+            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                let i = v.try_into().map_err(|_| E::custom(ERROR_MSG))?;
+                Ok(Prune::Blocks(i))
+            }
+        }
+
+        deserializer.deserialize_any(HistoryBlocksVisitor)
+    }
 }
 
 /// SubgraphManifest with IPFS links unresolved
 pub type UnresolvedSubgraphManifest<C> = BaseSubgraphManifest<
     C,
-    UnresolvedSchema,
+    Option<UnresolvedSchema>,
     UnresolvedDataSource<C>,
     UnresolvedDataSourceTemplate<C>,
 >;
 
 /// SubgraphManifest validated with IPFS links resolved
 pub type SubgraphManifest<C> =
-    BaseSubgraphManifest<C, Schema, DataSource<C>, DataSourceTemplate<C>>;
+    BaseSubgraphManifest<C, InputSchema, DataSource<C>, DataSourceTemplate<C>>;
 
 /// Unvalidated SubgraphManifest
 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?,
         ))
     }
 
@@ -533,17 +870,17 @@ impl<C: Blockchain> UnvalidatedSubgraphManifest<C> {
         store: Arc<S>,
         validate_graft_base: bool,
     ) -> Result<SubgraphManifest<C>, Vec<SubgraphManifestValidationError>> {
-        let (schemas, _) = self.0.schema.resolve_schema_references(store.clone());
+        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)
             }));
         }
@@ -553,46 +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);
         }
 
-        self.0
-            .schema
-            .validate(&schemas)
-            .err()
-            .into_iter()
-            .for_each(|schema_errors| {
-                errors.push(SubgraphManifestValidationError::SchemaValidationError(
-                    schema_errors,
-                ));
-            });
-
-        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),
@@ -602,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)
     }
 
@@ -626,17 +1008,24 @@ 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()
     }
 
+    pub fn history_blocks(&self) -> BlockNumber {
+        match self.indexer_hints {
+            Some(ref hints) => hints.history_blocks(),
+            None => BLOCK_NUMBER_MAX,
+        }
+    }
+
     pub fn api_versions(&self) -> impl Iterator<Item = semver::Version> + '_ {
         self.templates
             .iter()
@@ -644,6 +1033,64 @@ impl<C: Blockchain> SubgraphManifest<C> {
             .chain(self.data_sources.iter().map(|source| source.api_version()))
     }
 
+    pub fn deployment_features(&self) -> DeploymentFeatures {
+        let unified_api_version = self.unified_mapping_api_version().ok();
+        let network = self.network_name();
+        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()
+            .flat_map(|ds| ds.handler_kinds())
+            .collect::<HashSet<_>>();
+
+        let features: Vec<String> = self
+            .features
+            .iter()
+            .map(|f| f.to_string())
+            .collect::<Vec<_>>();
+
+        let spec_version = self.spec_version.to_string();
+
+        let mut data_source_kinds = self
+            .data_sources
+            .iter()
+            .map(|ds| ds.kind().to_string())
+            .collect::<HashSet<_>>();
+
+        let data_source_template_kinds = self
+            .templates
+            .iter()
+            .map(|t| t.kind().to_string())
+            .collect::<Vec<_>>();
+
+        data_source_kinds.extend(data_source_template_kinds);
+        DeploymentFeatures {
+            id: self.id.to_string(),
+            api_version,
+            features,
+            spec_version,
+            data_source_kinds: data_source_kinds.into_iter().collect_vec(),
+            handler_kinds: handler_kinds
+                .into_iter()
+                .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,
+        }
+    }
+
     pub fn runtimes(&self) -> impl Iterator<Item = Arc<Vec<u8>>> + '_ {
         self.templates
             .iter()
@@ -685,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> {
@@ -697,11 +1146,12 @@ impl<C: Blockchain> UnresolvedSubgraphManifest<C> {
             features,
             description,
             repository,
-            schema,
+            schema: unresolved_schema,
             data_sources,
             graft,
             templates,
             chain,
+            indexer_hints,
         } = self;
 
         if !(MIN_SPEC_VERSION..=max_spec_version.clone()).contains(&spec_version) {
@@ -714,30 +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, data_sources, templates) = try_join3(
-            schema.resolve(id.clone(), resolver, logger),
-            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, logger, ds_count as u32 + idx as u32)
-                })
-                .collect::<FuturesOrdered<_>>()
-                .try_collect::<Vec<_>>(),
-        )
+        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 = 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 {
@@ -754,7 +1253,7 @@ impl<C: Blockchain> UnresolvedSubgraphManifest<C> {
         if spec_version < SPEC_VERSION_0_0_7
             && data_sources
                 .iter()
-                .any(|ds| OFFCHAIN_KINDS.contains(&ds.kind()))
+                .any(|ds| OFFCHAIN_KINDS.contains_key(ds.kind().as_str()))
         {
             bail!(
                 "Offchain data sources not supported prior to {}",
@@ -762,7 +1261,49 @@ impl<C: Blockchain> UnresolvedSubgraphManifest<C> {
             );
         }
 
-        Ok(SubgraphManifest {
+        if spec_version < SPEC_VERSION_0_0_9
+            && data_sources.iter().any(|ds| ds.end_block().is_some())
+        {
+            bail!(
+                "Defining `endBlock` in the manifest is not supported prior to {}",
+                SPEC_VERSION_0_0_9
+            );
+        }
+
+        if spec_version < SPEC_VERSION_1_0_0 && indexer_hints.is_some() {
+            bail!(
+                "`indexerHints` are not supported prior to {}",
+                SPEC_VERSION_1_0_0
+            );
+        }
+
+        // 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()
+            .find(|ds| spec_version < ds.min_spec_version());
+
+        if let Some(min_spec_version_mismatch) = min_spec_version_mismatch {
+            bail!(
+                "Subgraph `{}` uses spec version {}, but data source `{}` requires at least version {}",
+                id,
+                spec_version,
+                min_spec_version_mismatch.name(),
+                min_spec_version_mismatch.min_spec_version()
+            );
+        }
+
+        let manifest = SubgraphManifest {
             id,
             spec_version,
             features,
@@ -773,7 +1314,17 @@ impl<C: Blockchain> UnresolvedSubgraphManifest<C> {
             graft,
             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)
     }
 }
 
@@ -797,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 {
@@ -822,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 67717c03964..c65dfad88e2 100644
--- a/graph/src/data/subgraph/schema.rs
+++ b/graph/src/data/subgraph/schema.rs
@@ -1,26 +1,24 @@
 //! 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 lazy_static::lazy_static;
+use rand::TryRngCore as _;
 use rand::rngs::OsRng;
-use rand::Rng;
 use std::collections::BTreeSet;
 use std::str::FromStr;
 use std::{fmt, fmt::Display};
 
 use super::DeploymentHash;
+use crate::blockchain::Blockchain;
 use crate::data::graphql::TryFromValue;
 use crate::data::store::Value;
 use crate::data::subgraph::SubgraphManifest;
 use crate::prelude::*;
+use crate::schema::EntityType;
 use crate::util::stable_hash_glue::impl_stable_hash;
-use crate::{blockchain::Blockchain, components::store::EntityType};
 
 pub const POI_TABLE: &str = "poi2$";
-lazy_static! {
-    pub static ref POI_OBJECT: EntityType = EntityType::new("Poi$".to_string());
-}
 
 #[derive(Copy, Clone, PartialEq, Eq, Debug, Deserialize)]
 #[serde(rename_all = "lowercase")]
@@ -108,6 +106,7 @@ pub struct DeploymentCreate {
     pub graft_base: Option<DeploymentHash>,
     pub graft_block: Option<BlockPtr>,
     pub debug_fork: Option<DeploymentHash>,
+    pub history_blocks_override: Option<i32>,
 }
 
 impl DeploymentCreate {
@@ -122,9 +121,15 @@ impl DeploymentCreate {
             graft_base: None,
             graft_block: None,
             debug_fork: None,
+            history_blocks_override: None,
         }
     }
 
+    pub fn with_history_blocks_override(mut self, blocks: i32) -> Self {
+        self.history_blocks_override = Some(blocks);
+        self
+    }
+
     pub fn graft(mut self, base: Option<(DeploymentHash, BlockPtr)>) -> Self {
         if let Some((subgraph, ptr)) = base {
             self.graft_base = Some(subgraph);
@@ -155,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
@@ -180,6 +185,7 @@ pub struct SubgraphManifestEntity {
     pub schema: String,
     pub raw_yaml: Option<String>,
     pub entities_with_causality_region: Vec<EntityType>,
+    pub history_blocks: BlockNumber,
 }
 
 impl SubgraphManifestEntity {
@@ -193,9 +199,10 @@ impl SubgraphManifestEntity {
             description: manifest.description.clone(),
             repository: manifest.repository.clone(),
             features: manifest.features.iter().map(|f| f.to_string()).collect(),
-            schema: manifest.schema.document.clone().to_string(),
+            schema: manifest.schema.document_string(),
             raw_yaml: Some(raw_yaml),
             entities_with_causality_region,
+            history_blocks: manifest.history_blocks(),
         }
     }
 
@@ -265,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 0813221ad17..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,
@@ -103,6 +132,7 @@ pub struct Info {
     pub health: SubgraphHealth,
     pub fatal_error: Option<SubgraphError>,
     pub non_fatal_errors: Vec<SubgraphError>,
+    pub paused: Option<bool>,
 
     /// Indexing status on different chains involved in the subgraph's data sources.
     pub chains: Vec<ChainInfo>,
@@ -111,6 +141,11 @@ pub struct Info {
 
     /// ID of the Graph Node that the subgraph is indexed by.
     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 {
@@ -122,9 +157,12 @@ impl IntoValue for Info {
             entity_count,
             fatal_error,
             health,
+            paused,
             node,
             non_fatal_errors,
             synced,
+            history_blocks,
+            subgraph_size,
         } = self;
 
         fn subgraph_error_to_value(subgraph_error: SubgraphError) -> r::Value {
@@ -161,11 +199,14 @@ impl IntoValue for Info {
             subgraph: subgraph,
             synced: synced,
             health: r::Value::from(health),
+            paused: paused,
             fatalError: fatal_error_val,
             nonFatalErrors: non_fatal_errors,
             chains: chains.into_iter().map(|chain| chain.into_value()).collect::<Vec<_>>(),
             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 7991ef3ac17..6dce081aa7b 100644
--- a/graph/src/data/value.rs
+++ b/graph/src/data/value.rs
@@ -1,10 +1,17 @@
-use crate::prelude::{q, s, CacheWeight};
-use serde::ser::{SerializeMap, SerializeSeq, Serializer};
+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, ToSql};
+use diesel::sql_types::Text;
 use serde::Serialize;
+use serde::ser::{SerializeMap, SerializeSeq, Serializer};
 use std::collections::BTreeMap;
 use std::convert::TryFrom;
 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
@@ -67,7 +74,72 @@ impl<'de> serde::Deserialize<'de> for Word {
     }
 }
 
-#[derive(Clone, Debug, PartialEq)]
+impl ToSql<Text, Pg> for Word {
+    fn to_sql(&self, out: &mut Output<Pg>) -> serialize::Result {
+        <str as ToSql<Text, Pg>>::to_sql(&self.0, &mut out.reborrow())
+    }
+}
+
+impl stable_hash_legacy::StableHash for Word {
+    #[inline]
+    fn stable_hash<H: stable_hash_legacy::StableHasher>(
+        &self,
+        sequence_number: H::Seq,
+        state: &mut H,
+    ) {
+        self.as_str().stable_hash(sequence_number, state)
+    }
+}
+
+impl stable_hash::StableHash for Word {
+    fn stable_hash<H: stable_hash::StableHasher>(&self, field_address: H::Addr, state: &mut H) {
+        self.as_str().stable_hash(field_address, state)
+    }
+}
+
+impl GasSizeOf for Word {
+    fn gas_size_of(&self) -> Gas {
+        self.0.len().saturating_into()
+    }
+}
+
+impl AsRef<str> for Word {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl PartialEq<&str> for Word {
+    fn eq(&self, other: &&str) -> bool {
+        self.as_str() == *other
+    }
+}
+
+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, CacheWeight, Debug, PartialEq)]
 struct Entry {
     key: Option<Word>,
     value: Value,
@@ -89,10 +161,14 @@ impl Entry {
     }
 }
 
-#[derive(Clone, PartialEq, Default)]
+#[derive(Clone, CacheWeight, PartialEq, Default)]
 pub struct Object(Box<[Entry]>);
 
 impl Object {
+    pub fn empty() -> Object {
+        Object(Box::new([]))
+    }
+
     pub fn get(&self, key: &str) -> Option<&Value> {
         self.0
             .iter()
@@ -114,22 +190,39 @@ impl Object {
         ObjectIter::new(self)
     }
 
-    fn len(&self) -> usize {
+    pub fn len(&self) -> usize {
         self.0.len()
     }
 
-    pub fn extend(&mut self, other: Object) {
+    /// Add the entries from an object to `self`. Note that if `self` and
+    /// `object` have entries with identical keys, the entry in `self` wins.
+    pub fn append(&mut self, other: Object) {
         let mut entries = std::mem::replace(&mut self.0, Box::new([])).into_vec();
         entries.extend(other.0.into_vec());
         self.0 = entries.into_boxed_slice();
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+impl Extend<(Word, Value)> for Object {
+    /// Add the entries from the iterator to an object. Note that if the
+    /// iterator produces a key that is already set in the object, it will
+    /// not be overwritten, and the previous value wins.
+    fn extend<T: IntoIterator<Item = (Word, Value)>>(&mut self, iter: T) {
+        let mut entries = std::mem::replace(&mut self.0, Box::new([])).into_vec();
+        entries.extend(iter.into_iter().map(|(key, value)| Entry::new(key, value)));
+        self.0 = entries.into_boxed_slice();
+    }
 }
 
-impl FromIterator<(String, Value)> for Object {
-    fn from_iter<T: IntoIterator<Item = (String, Value)>>(iter: T) -> Self {
+impl FromIterator<(Word, Value)> for Object {
+    fn from_iter<T: IntoIterator<Item = (Word, Value)>>(iter: T) -> Self {
         let mut items: Vec<_> = Vec::new();
         for (key, value) in iter {
-            items.push(Entry::new(key.into(), value))
+            items.push(Entry::new(key, value))
         }
         Object(items.into_boxed_slice())
     }
@@ -198,25 +291,20 @@ 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 {
-        self.0.fmt(f)
+        f.debug_map()
+            .entries(self.0.iter().map(|e| {
+                (
+                    e.key.as_ref().map(|w| w.as_str()).unwrap_or("---"),
+                    &e.value,
+                )
+            }))
+            .finish()
     }
 }
 
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Clone, CacheWeight, PartialEq)]
 pub enum Value {
     Int(i64),
     Float(f64),
@@ -226,6 +314,7 @@ pub enum Value {
     Enum(String),
     List(Vec<Value>),
     Object(Object),
+    Timestamp(scalar::Timestamp),
 }
 
 impl Value {
@@ -261,12 +350,18 @@ 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))
                 }
             }
+            ("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())),
@@ -313,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())
+            }
         }
     }
 }
@@ -345,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) => {
@@ -407,8 +497,10 @@ impl From<serde_json::Value> for Value {
                 Value::List(vals)
             }
             serde_json::Value::Object(map) => {
-                let obj =
-                    Object::from_iter(map.into_iter().map(|(key, val)| (key, Value::from(val))));
+                let obj = Object::from_iter(
+                    map.into_iter()
+                        .map(|(key, val)| (Word::from(key), Value::from(val))),
+                );
                 Value::Object(obj)
             }
         }
@@ -436,6 +528,60 @@ impl From<Value> for q::Value {
                 }
                 q::Value::Object(rmap)
             }
+            Value::Timestamp(ts) => q::Value::String(ts.as_microseconds_since_epoch().to_string()),
+        }
+    }
+}
+
+impl std::fmt::Debug for Value {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Value::Int(i) => f.debug_tuple("Int").field(i).finish(),
+            Value::Float(n) => f.debug_tuple("Float").field(n).finish(),
+            Value::String(s) => write!(f, "{s:?}"),
+            Value::Boolean(b) => write!(f, "{b}"),
+            Value::Null => write!(f, "null"),
+            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 29d07c99605..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)]
@@ -8,27 +13,37 @@ mod tests;
 
 use crate::{
     blockchain::{
-        BlockPtr, Blockchain, DataSource as _, DataSourceTemplate as _, TriggerData as _,
-        UnresolvedDataSource as _, UnresolvedDataSourceTemplate as _,
+        Block, BlockPtr, BlockTime, Blockchain, DataSource as _, DataSourceTemplate as _,
+        MappingTriggerTrait, TriggerData as _, UnresolvedDataSource as _,
+        UnresolvedDataSourceTemplate as _,
     },
     components::{
         link_resolver::LinkResolver,
-        store::{BlockNumber, EntityType, StoredDynamicDataSource},
+        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, fmt, sync::Arc};
+use std::{
+    collections::{BTreeMap, HashSet},
+    fmt,
+    sync::Arc,
+};
 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)]
@@ -62,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(", "))
             }
         }
@@ -83,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,
         }
     }
 
@@ -90,13 +125,43 @@ 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),
         }
     }
 
+    pub fn is_onchain(&self) -> bool {
+        self.as_onchain().is_some()
+    }
+
+    pub fn is_offchain(&self) -> bool {
+        self.as_offchain().is_some()
+    }
+
     pub fn address(&self) -> Option<Vec<u8>> {
         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()),
         }
     }
 
@@ -104,13 +169,35 @@ 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(),
         }
     }
 
-    pub fn kind(&self) -> &str {
+    pub fn kind(&self) -> String {
         match self {
-            Self::Onchain(ds) => ds.kind(),
-            Self::Offchain(ds) => &ds.kind,
+            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(),
+        }
+    }
+
+    pub fn min_spec_version(&self) -> Version {
+        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,
+        }
+    }
+
+    pub fn end_block(&self) -> Option<BlockNumber> {
+        match self {
+            Self::Onchain(ds) => ds.end_block(),
+            Self::Offchain(_) => None,
+            Self::Subgraph(_) => None,
+            Self::Amp(ds) => Some(ds.source.end_block as i32),
         }
     }
 
@@ -118,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,
         }
     }
 
@@ -125,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),
         }
     }
 
@@ -132,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(),
         }
     }
 
@@ -139,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,
         }
     }
 
@@ -148,6 +243,26 @@ 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,
+        }
+    }
+
+    pub fn handler_kinds(&self) -> HashSet<&str> {
+        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,
         }
     }
 
@@ -158,14 +273,23 @@ impl<C: Blockchain> DataSource<C> {
         logger: &Logger,
     ) -> Result<Option<TriggerWithHandler<MappingTrigger<C>>>, Error> {
         match (self, trigger) {
+            (Self::Onchain(ds), _) if ds.has_expired(block.number()) => Ok(None),
             (Self::Onchain(ds), TriggerData::Onchain(trigger)) => ds
                 .match_and_decode(trigger, block, logger)
                 .map(|t| t.map(|t| t.map(MappingTrigger::Onchain))),
             (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),
         }
     }
 
@@ -181,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!(),
         }
     }
 
@@ -197,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(),
         }
     }
 
@@ -211,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,
         }
     }
 }
@@ -219,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)
         }
     }
 
@@ -261,6 +443,7 @@ impl<C: Blockchain> DataSourceTemplate<C> {
         match self {
             Self::Onchain(_) => None,
             Self::Offchain(t) => Some(t),
+            Self::Subgraph(_) => todo!(), // TODO(krishna)
         }
     }
 
@@ -268,6 +451,7 @@ impl<C: Blockchain> DataSourceTemplate<C> {
         match self {
             Self::Onchain(ds) => Some(ds),
             Self::Offchain(_) => None,
+            Self::Subgraph(_) => todo!(), // TODO(krishna)
         }
     }
 
@@ -275,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,
         }
     }
 
@@ -282,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(),
         }
     }
 
@@ -289,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()),
         }
     }
 
@@ -296,6 +483,15 @@ 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,
+        }
+    }
+
+    pub fn kind(&self) -> String {
+        match self {
+            Self::Onchain(ds) => ds.kind().to_string(),
+            Self::Offchain(ds) => ds.kind.to_string(),
+            Self::Subgraph(ds) => ds.kind.clone(),
         }
     }
 }
@@ -304,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> {
@@ -315,19 +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)
+                .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),
         }
     }
 }
@@ -336,6 +552,7 @@ pub struct TriggerWithHandler<T> {
     pub trigger: T,
     handler: String,
     block_ptr: BlockPtr,
+    timestamp: BlockTime,
     logging_extras: Arc<dyn SendSyncRefUnwindSafeKV>,
 }
 
@@ -349,25 +566,28 @@ impl<T: fmt::Debug> fmt::Debug for TriggerWithHandler<T> {
 }
 
 impl<T> TriggerWithHandler<T> {
-    pub fn new(trigger: T, handler: String, block_ptr: BlockPtr) -> Self {
-        Self {
+    pub fn new(trigger: T, handler: String, block_ptr: BlockPtr, timestamp: BlockTime) -> Self {
+        Self::new_with_logging_extras(
             trigger,
             handler,
             block_ptr,
-            logging_extras: Arc::new(slog::o! {}),
-        }
+            timestamp,
+            Arc::new(slog::o! {}),
+        )
     }
 
     pub fn new_with_logging_extras(
         trigger: T,
         handler: String,
         block_ptr: BlockPtr,
+        timestamp: BlockTime,
         logging_extras: Arc<dyn SendSyncRefUnwindSafeKV>,
     ) -> Self {
         TriggerWithHandler {
             trigger,
             handler,
             block_ptr,
+            timestamp,
             logging_extras,
         }
     }
@@ -386,6 +606,7 @@ impl<T> TriggerWithHandler<T> {
             trigger: f(self.trigger),
             handler: self.handler,
             block_ptr: self.block_ptr,
+            timestamp: self.timestamp,
             logging_extras: self.logging_extras,
         }
     }
@@ -393,11 +614,17 @@ impl<T> TriggerWithHandler<T> {
     pub fn block_ptr(&self) -> BlockPtr {
         self.block_ptr.clone()
     }
+
+    pub fn timestamp(&self) -> BlockTime {
+        self.timestamp
+    }
 }
 
+#[derive(Debug)]
 pub enum TriggerData<C: Blockchain> {
     Onchain(C::TriggerData),
     Offchain(offchain::TriggerData),
+    Subgraph(subgraph::TriggerData),
 }
 
 impl<C: Blockchain> TriggerData<C> {
@@ -405,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),
         }
     }
 }
@@ -413,55 +641,116 @@ impl<C: Blockchain> TriggerData<C> {
 pub enum MappingTrigger<C: Blockchain> {
     Onchain(C::MappingTrigger),
     Offchain(offchain::TriggerData),
+    Subgraph(subgraph::MappingEntityTrigger),
 }
 
-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> MappingTrigger<C> {
+    pub fn error_context(&self) -> Option<String> {
+        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)
+        }
+    }
 }
 
-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(&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 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()),
+        }
+    }
+}
+
+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()),
+        }
+    }
+}
+
+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,
+            )))
         }
-    };
+    }
 }
 
-deserialize_data_source!(UnresolvedDataSource);
-deserialize_data_source!(UnresolvedDataSourceTemplate);
+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 a77b125043c..b21b52a6e3a 100644
--- a/graph/src/data_source/offchain.rs
+++ b/graph/src/data_source/offchain.rs
@@ -1,32 +1,99 @@
 use crate::{
     bail,
-    blockchain::{BlockPtr, Blockchain},
+    blockchain::{BlockPtr, BlockTime, Blockchain},
     components::{
-        link_resolver::LinkResolver,
-        store::{BlockNumber, EntityType, StoredDynamicDataSource},
-        subgraph::DataSourceTemplateInfo,
+        link_resolver::{LinkResolver, LinkResolverContext},
+        store::{BlockNumber, StoredDynamicDataSource},
+        subgraph::{InstanceDSTemplate, InstanceDSTemplateInfo},
+    },
+    data::{
+        store::scalar::Bytes,
+        subgraph::{DeploymentHash, SPEC_VERSION_0_0_7},
+        value::Word,
     },
-    data::store::scalar::Bytes,
     data_source,
-    ipfs_client::CidFile,
+    ipfs::ContentPath,
     prelude::{DataSourceContext, Link},
+    schema::{EntityType, InputSchema},
 };
-use anyhow::{self, Context, Error};
+use anyhow::{Context, Error, anyhow};
+use itertools::Itertools;
+use lazy_static::lazy_static;
 use serde::Deserialize;
-use slog::{info, Logger};
+use slog::{Logger, info, warn};
 use std::{
+    collections::HashMap,
     fmt,
-    sync::{atomic::AtomicI32, Arc},
+    str::FromStr,
+    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> = [
+        ("file/ipfs", OffchainDataSourceKind::Ipfs),
+        ("file/arweave", OffchainDataSourceKind::Arweave),
+    ]
+    .into_iter()
+    .collect();
+}
 
-pub const OFFCHAIN_KINDS: &[&str] = &["file/ipfs"];
+const OFFCHAIN_HANDLER_KIND: &str = "offchain";
 const NOT_DONE_VALUE: i32 = -1;
 
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum OffchainDataSourceKind {
+    Ipfs,
+    Arweave,
+}
+impl OffchainDataSourceKind {
+    pub fn try_parse_source(&self, bs: Bytes) -> Result<Source, anyhow::Error> {
+        let source = match self {
+            OffchainDataSourceKind::Ipfs => {
+                let path = ContentPath::try_from(bs)?;
+                Source::Ipfs(path)
+            }
+            OffchainDataSourceKind::Arweave => {
+                let base64 = Word::from(String::from_utf8(bs.to_vec())?);
+                Source::Arweave(base64)
+            }
+        };
+        Ok(source)
+    }
+}
+
+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.
+        let label = OFFCHAIN_KINDS
+            .iter()
+            .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_or("<unknown offchain kind>");
+
+        write!(f, "{}", label)
+    }
+}
+
+impl FromStr for OffchainDataSourceKind {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        OFFCHAIN_KINDS
+            .iter()
+            .find_map(|(str, kind)| if str.eq(&s) { Some(kind.clone()) } else { None })
+            .ok_or(anyhow!(
+                "unsupported offchain datasource kind: {s}, expected one of: {}",
+                OFFCHAIN_KINDS.iter().map(|x| x.0).join(",")
+            ))
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct DataSource {
-    pub kind: String,
+    pub kind: OffchainDataSourceKind,
     pub name: String,
     pub manifest_idx: u32,
     pub source: Source,
@@ -39,7 +106,7 @@ pub struct DataSource {
 
 impl DataSource {
     pub fn new(
-        kind: String,
+        kind: OffchainDataSourceKind,
         name: String,
         manifest_idx: u32,
         source: Source,
@@ -86,16 +153,28 @@ impl DataSource {
         self.done_at
             .store(value, std::sync::atomic::Ordering::SeqCst);
     }
+
+    pub fn min_spec_version(&self) -> semver::Version {
+        // off-chain data sources are only supported in spec version 0.0.7 and up
+        // As more and more kinds of off-chain data sources are added, this
+        // function should be updated to return the minimum spec version
+        // required for each kind
+        SPEC_VERSION_0_0_7
+    }
+
+    pub fn handler_kind(&self) -> &str {
+        OFFCHAIN_HANDLER_KIND
+    }
 }
 
 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")
             }
         };
@@ -104,11 +183,13 @@ impl DataSource {
             template.name
         ))?;
 
-        let source = match source.parse() {
-            Ok(source) => Source::Ipfs(source),
-
-            // Ignore data sources created with an invalid CID.
-            Err(e) => return Err(DataSourceCreationError::Ignore(source, e)),
+        let source = match template.kind {
+            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.into())),
+            },
+            OffchainDataSourceKind::Arweave => Source::Arweave(Word::from(source)),
         };
 
         Ok(Self {
@@ -135,14 +216,12 @@ impl DataSource {
             data_source::MappingTrigger::Offchain(trigger.clone()),
             self.mapping.handler.clone(),
             BlockPtr::new(Default::default(), self.creation_block.unwrap_or(0)),
+            BlockTime::NONE,
         ))
     }
 
     pub fn as_stored_dynamic_data_source(&self) -> StoredDynamicDataSource {
-        let param = match self.source {
-            Source::Ipfs(ref link) => Bytes::from(link.to_bytes()),
-        };
-
+        let param = self.source.clone().into();
         let done_at = self.done_at.load(std::sync::atomic::Ordering::SeqCst);
         let done_at = if done_at == NOT_DONE_VALUE {
             None
@@ -180,9 +259,7 @@ impl DataSource {
         } = stored;
 
         let param = param.context("no param on stored data source")?;
-        let cid_file = CidFile::try_from(param)?;
-
-        let source = Source::Ipfs(cid_file);
+        let source = template.kind.try_parse_source(param)?;
         let context = Arc::new(context.map(serde_json::from_value).transpose()?);
 
         Ok(Self {
@@ -198,12 +275,8 @@ impl DataSource {
         })
     }
 
-    /// The concept of an address may or not make sense for an offchain data source, but this is
-    /// used as the value to be returned to mappings from the `dataSource.address()` host function.
     pub fn address(&self) -> Option<Vec<u8>> {
-        match self.source {
-            Source::Ipfs(ref cid) => Some(cid.to_bytes()),
-        }
+        self.source.address()
     }
 
     pub(super) fn is_duplicate_of(&self, b: &DataSource) -> bool {
@@ -236,9 +309,36 @@ impl DataSource {
     }
 }
 
+pub type Base64 = Word;
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum Source {
-    Ipfs(CidFile),
+    Ipfs(ContentPath),
+    Arweave(Base64),
+}
+
+impl Source {
+    /// The concept of an address may or not make sense for an offchain 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) -> Option<Vec<u8>> {
+        match self {
+            Source::Ipfs(path) => Some(path.to_string().as_bytes().to_vec()),
+            Source::Arweave(base64) => Some(base64.as_bytes().to_vec()),
+        }
+    }
+}
+
+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()),
+        }
+    }
 }
 
 #[derive(Clone, Debug)]
@@ -271,59 +371,44 @@ pub struct UnresolvedMapping {
     pub language: String,
     pub file: Link,
     pub handler: String,
-    pub entities: Vec<EntityType>,
-}
-
-impl UnresolvedDataSource {
-    #[allow(dead_code)]
-    pub(super) async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-        manifest_idx: u32,
-        causality_region: CausalityRegion,
-    ) -> Result<DataSource, Error> {
-        info!(logger, "Resolve offchain data source";
-            "name" => &self.name,
-            "kind" => &self.kind,
-            "source" => format_args!("{:?}", &self.source),
-        );
-        let source = match self.kind.as_str() {
-            "file/ipfs" => Source::Ipfs(self.source.file.link.parse()?),
-            _ => {
-                anyhow::bail!(
-                    "offchain data source has invalid `kind`, expected `file/ipfs` but found {}",
-                    self.kind
-                );
-            }
-        };
-        Ok(DataSource {
-            manifest_idx,
-            kind: self.kind,
-            name: self.name,
-            source,
-            mapping: self.mapping.resolve(resolver, logger).await?,
-            context: Arc::new(None),
-            creation_block: None,
-            done_at: Arc::new(AtomicI32::new(NOT_DONE_VALUE)),
-            causality_region,
-        })
-    }
+    pub entities: Vec<String>,
 }
 
 impl UnresolvedMapping {
     pub async fn resolve(
         self,
+        deployment_hash: &DeploymentHash,
         resolver: &Arc<dyn LinkResolver>,
+        schema: &InputSchema,
         logger: &Logger,
     ) -> Result<Mapping, Error> {
         info!(logger, "Resolve offchain mapping"; "link" => &self.file.link);
+        // It is possible for a manifest to mention entity types that do not
+        // exist in the schema. Rather than fail the subgraph, which could
+        // fail existing subgraphs, filter them out and just log a warning.
+        let (entities, errs) = self
+            .entities
+            .iter()
+            .map(|s| schema.entity_type(s).map_err(|_| s))
+            .partition::<Vec<_>, _>(Result::is_ok);
+        if !errs.is_empty() {
+            let errs = errs.into_iter().map(Result::unwrap_err).join(", ");
+            warn!(logger, "Ignoring unknown entity types in mapping"; "entities" => errs, "link" => &self.file.link);
+        }
+        let entities = entities.into_iter().map(Result::unwrap).collect::<Vec<_>>();
         Ok(Mapping {
             language: self.language,
             api_version: semver::Version::parse(&self.api_version)?,
-            entities: self.entities,
+            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,
         })
     }
@@ -339,28 +424,56 @@ pub struct UnresolvedDataSourceTemplate {
 
 #[derive(Clone, Debug)]
 pub struct DataSourceTemplate {
-    pub kind: String,
+    pub kind: OffchainDataSourceKind,
     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,
+        schema: &InputSchema,
     ) -> Result<DataSourceTemplate, Error> {
-        info!(logger, "Resolve data source template"; "name" => &self.name);
+        let kind = OffchainDataSourceKind::from_str(&self.kind)?;
+
+        let mapping = self
+            .mapping
+            .resolve(deployment_hash, resolver, schema, logger)
+            .await
+            .with_context(|| format!("failed to resolve data source template {}", self.name))?;
 
         Ok(DataSourceTemplate {
-            kind: self.kind,
+            kind,
             network: self.network,
             name: self.name,
             manifest_idx,
-            mapping: self.mapping.resolve(resolver, logger).await?,
+            mapping,
         })
     }
 }
@@ -386,3 +499,31 @@ impl fmt::Debug for TriggerData {
         )
     }
 }
+
+#[cfg(test)]
+mod test {
+    use crate::{
+        data::{store::scalar::Bytes, value::Word},
+        ipfs::ContentPath,
+    };
+
+    use super::{OffchainDataSourceKind, Source};
+
+    #[test]
+    fn test_source_bytes_round_trip() {
+        let base64 = "8APeQ5lW0-csTcBaGdPBDLAL2ci2AT9pTn2tppGPU_8";
+        let path = ContentPath::new("QmVkvoPGi9jvvuxsHDVJDgzPEzagBaWSZRYoRDzU244HjZ").unwrap();
+
+        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(&path))};
+
+        let arweave_source = Source::Arweave(Word::from(base64));
+        let s = OffchainDataSourceKind::Arweave
+            .try_parse_source(arweave_source.into())
+            .unwrap();
+        assert! { matches!(s, Source::Arweave(b64) if b64.eq(&base64))};
+    }
+}
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 30421fca84f..93818f5bb8f 100644
--- a/graph/src/data_source/tests.rs
+++ b/graph/src/data_source/tests.rs
@@ -2,8 +2,7 @@ use cid::Cid;
 
 use crate::{
     blockchain::mock::{MockBlockchain, MockDataSource},
-    components::subgraph::Entity,
-    ipfs_client::CidFile,
+    ipfs::ContentPath,
     prelude::Link,
 };
 
@@ -32,14 +31,11 @@ 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();
-    c.context = Arc::new(Some(Entity::new()));
+    c.context = Arc::new(Some(DataSourceContext::new()));
     assert!(!a.is_duplicate_of(&c));
 }
 
@@ -55,25 +51,28 @@ 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);
+    let onchain = DataSource::<MockBlockchain>::Onchain(MockDataSource {
+        api_version: Version::new(1, 0, 0),
+        kind: "mock/kind".into(),
+        network: Some("mock_network".into()),
+    });
     assert!(onchain.causality_region() == CausalityRegion::ONCHAIN);
     assert!(onchain.as_offchain().is_none());
 }
 
 fn new_datasource() -> offchain::DataSource {
     offchain::DataSource::new(
-        "theKind".into(),
+        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
new file mode 100644
index 00000000000..a62dc07f2ba
--- /dev/null
+++ b/graph/src/endpoint.rs
@@ -0,0 +1,198 @@
+use std::{
+    collections::HashMap,
+    sync::{
+        Arc,
+        atomic::{AtomicU64, Ordering},
+    },
+};
+
+use prometheus::IntCounterVec;
+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<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: ProviderName,
+    pub req_type: Word,
+    pub conn_type: ConnectionType,
+}
+
+/// The type of underlying connection we are reporting for.
+#[derive(Clone)]
+pub enum ConnectionType {
+    Firehose,
+    Rpc,
+}
+
+impl From<&ConnectionType> for &str {
+    fn from(val: &ConnectionType) -> Self {
+        match val {
+            ConnectionType::Firehose => "firehose",
+            ConnectionType::Rpc => "rpc",
+        }
+    }
+}
+
+impl RequestLabels {
+    fn to_slice(&self, is_success: bool) -> Box<[&str]> {
+        Box::new([
+            (&self.conn_type).into(),
+            self.req_type.as_str(),
+            self.provider.as_str(),
+            match is_success {
+                true => "success",
+                false => "failure",
+            },
+        ])
+    }
+}
+
+/// EndpointMetrics keeps track of calls success rate for specific calls,
+/// a success call to a host will clear the error count.
+pub struct EndpointMetrics {
+    logger: Logger,
+    providers: ProviderCount,
+    counter: Box<IntCounterVec>,
+}
+
+impl std::fmt::Debug for EndpointMetrics {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_fmt(format_args!("{:?}", self.providers))
+    }
+}
+
+impl EndpointMetrics {
+    pub fn new(
+        logger: Logger,
+        providers: &[impl AsRef<str>],
+        registry: Arc<MetricsRegistry>,
+    ) -> Self {
+        let providers = Arc::new(HashMap::from_iter(
+            providers
+                .iter()
+                .map(|h| (ProviderName::from(h.as_ref()), AtomicU64::new(0))),
+        ));
+
+        let counter = registry
+            .new_int_counter_vec(
+                "endpoint_request",
+                "successfull request",
+                &["conn_type", "req_type", "provider", "result"],
+            )
+            .expect("unable to create endpoint_request counter_vec");
+
+        Self {
+            logger,
+            providers,
+            counter,
+        }
+    }
+
+    /// This should only be used for testing.
+    pub fn mock() -> Self {
+        use slog::{Discard, o};
+        let providers: &[&str] = &[];
+        Self::new(
+            Logger::root(Discard, o!()),
+            providers,
+            Arc::new(MetricsRegistry::mock()),
+        )
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn report_for_test(&self, provider: &ProviderName, success: bool) {
+        match success {
+            true => self.success(&RequestLabels {
+                provider: provider.clone(),
+                req_type: "".into(),
+                conn_type: ConnectionType::Firehose,
+            }),
+            false => self.failure(&RequestLabels {
+                provider: provider.clone(),
+                req_type: "".into(),
+                conn_type: ConnectionType::Firehose,
+            }),
+        }
+    }
+
+    pub fn success(&self, labels: &RequestLabels) {
+        match self.providers.get(&labels.provider) {
+            Some(count) => {
+                count.store(0, Ordering::Relaxed);
+            }
+            None => warn!(
+                &self.logger,
+                "metrics not available for host {}", labels.provider
+            ),
+        };
+
+        self.counter.with_label_values(&labels.to_slice(true)).inc();
+    }
+
+    pub fn failure(&self, labels: &RequestLabels) {
+        match self.providers.get(&labels.provider) {
+            Some(count) => {
+                count.fetch_add(1, Ordering::Relaxed);
+            }
+            None => warn!(
+                &self.logger,
+                "metrics not available for host {}", &labels.provider
+            ),
+        };
+
+        self.counter
+            .with_label_values(&labels.to_slice(false))
+            .inc();
+    }
+
+    /// 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: &ProviderName) -> u64 {
+        self.providers
+            .get(provider)
+            .map(|c| c.load(Ordering::Relaxed))
+            .unwrap_or(0)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use std::sync::Arc;
+
+    use slog::{Discard, Logger, o};
+
+    use crate::{
+        components::metrics::MetricsRegistry,
+        endpoint::{EndpointMetrics, ProviderName},
+    };
+
+    #[crate::test]
+    async fn should_increment_and_reset() {
+        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!());
+
+        let metrics = EndpointMetrics::new(logger, hosts, Arc::new(MetricsRegistry::mock()));
+
+        metrics.report_for_test(&a, true);
+        metrics.report_for_test(&a, false);
+        metrics.report_for_test(&b, false);
+        metrics.report_for_test(&b, false);
+        metrics.report_for_test(&c, true);
+
+        assert_eq!(metrics.get_count(&a), 1);
+        assert_eq!(metrics.get_count(&b), 2);
+        assert_eq!(metrics.get_count(&c), 0);
+    }
+}
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 bb3ee2c1d30..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.
@@ -16,7 +18,7 @@ pub struct EnvVarsMapping {
     /// kilobytes). The default value is 10 megabytes.
     pub entity_cache_size: usize,
     /// Set by the environment variable `GRAPH_MAX_API_VERSION`. The default
-    /// value is `0.0.7`.
+    /// value is `0.0.8`.
     pub max_api_version: Version,
     /// Set by the environment variable `GRAPH_MAPPING_HANDLER_TIMEOUT`
     /// (expressed in seconds). No default is provided.
@@ -46,17 +48,56 @@ pub struct EnvVarsMapping {
     /// Sets the `ipfs.cat` file size limit.
     ///
     /// Set by the environment variable `GRAPH_MAX_IPFS_FILE_BYTES` (expressed in
-    /// bytes). Defaults to 256 MiB.
+    /// bytes). Defaults to 25 MiB.
     pub max_ipfs_file_bytes: usize,
 
-    /// Limits both concurrent and per second requests to IPFS for file data sources.
+    /// Limits per second requests to IPFS for file data sources.
     ///
     /// 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.7")]
+    #[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>,
@@ -110,9 +192,54 @@ pub struct InnerMappingHandlers {
     #[envconfig(from = "GRAPH_MAX_IPFS_MAP_FILE_SIZE", default = "")]
     max_ipfs_map_file_size: WithDefaultUsize<usize, { 256 * 1024 * 1024 }>,
     #[envconfig(from = "GRAPH_MAX_IPFS_FILE_BYTES", default = "")]
-    max_ipfs_file_bytes: WithDefaultUsize<usize, { 256 * 1024 * 1024 }>,
+    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 04f24152e94..54c585d5ab3 100644
--- a/graph/src/env/mod.rs
+++ b/graph/src/env/mod.rs
@@ -1,22 +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::subgraph::SubgraphVersionSwitchingMode, runtime::gas::CONST_MAX_GAS_PER_HANDLER,
+    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.
@@ -41,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.
@@ -69,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.
@@ -85,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.
     ///
@@ -118,6 +137,10 @@ pub struct EnvVars {
     pub subgraph_version_switching_mode: SubgraphVersionSwitchingMode,
     /// Set by the flag `GRAPH_KILL_IF_UNRESPONSIVE`. Off by default.
     pub kill_if_unresponsive: bool,
+    /// Max timeout in seconds before killing the node.
+    /// Set by the environment variable `GRAPH_KILL_IF_UNRESPONSIVE_TIMEOUT_SECS`
+    /// (expressed in seconds). The default value is 10s.
+    pub kill_if_unresponsive_timeout: Duration,
     /// Guards public access to POIs in the `index-node`.
     ///
     /// Set by the environment variable `GRAPH_POI_ACCESS_TOKEN`. No default
@@ -133,13 +156,30 @@ pub struct EnvVars {
     /// Ceiling for the backoff retry of non-deterministic errors.
     ///
     /// Set by the environment variable `GRAPH_SUBGRAPH_ERROR_RETRY_CEIL_SECS`
-    /// (expressed in seconds). The default value is 1800s (30 minutes).
+    /// (expressed in seconds). The default value is 3600s (60 minutes).
     pub subgraph_error_retry_ceil: Duration,
+    /// Jitter factor for the backoff retry of non-deterministic errors.
+    ///
+    /// Set by the environment variable `GRAPH_SUBGRAPH_ERROR_RETRY_JITTER`
+    /// (clamped between 0.0 and 1.0). The default value is 0.2.
+    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
@@ -163,19 +203,114 @@ pub struct EnvVars {
     /// Maximum number of Dynamic Data Sources after which a Subgraph will
     /// switch to using static filter.
     pub static_filters_threshold: usize,
+    /// Set by the environment variable `ETHEREUM_REORG_THRESHOLD`. The default
+    /// value is 250 blocks.
+    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.
+    pub ingestor_polling_interval: Duration,
+    /// Set by the env var `GRAPH_EXPERIMENTAL_SUBGRAPH_SETTINGS` which should point
+    /// to a file with subgraph-specific settings
+    pub subgraph_settings: Option<String>,
+    /// Set by the flag `GRAPH_ENABLE_DIPS_METRICS`. Whether to enable
+    /// gas metrics. Off by default.
+    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
+    pub history_blocks_override: Option<BlockNumber>,
+    /// Set by the env var `GRAPH_MIN_HISTORY_BLOCKS`
+    /// 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,
@@ -191,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(',')
@@ -206,11 +342,18 @@ impl EnvVars {
             experimental_static_filters: inner.experimental_static_filters.0,
             subgraph_version_switching_mode: inner.subgraph_version_switching_mode,
             kill_if_unresponsive: inner.kill_if_unresponsive.0,
+            kill_if_unresponsive_timeout: Duration::from_secs(
+                inner.kill_if_unresponsive_timeout_secs,
+            ),
             poi_access_token: inner.poi_access_token,
             subgraph_max_data_sources: inner.subgraph_max_data_sources.0,
             disable_fail_fast: inner.disable_fail_fast.0,
             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),
@@ -218,6 +361,31 @@ impl EnvVars {
             external_http_base_url: inner.external_http_base_url,
             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,
+            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,
         })
     }
 
@@ -242,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 {
@@ -270,7 +503,7 @@ struct Inner {
         default = "false"
     )]
     allow_non_deterministic_fulltext_search: EnvVarBoolean,
-    #[envconfig(from = "GRAPH_MAX_SPEC_VERSION", default = "0.0.7")]
+    #[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,
@@ -280,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,
 
@@ -307,16 +542,24 @@ struct Inner {
     subgraph_version_switching_mode: SubgraphVersionSwitchingMode,
     #[envconfig(from = "GRAPH_KILL_IF_UNRESPONSIVE", default = "false")]
     kill_if_unresponsive: EnvVarBoolean,
+    #[envconfig(from = "GRAPH_KILL_IF_UNRESPONSIVE_TIMEOUT_SECS", default = "10")]
+    kill_if_unresponsive_timeout_secs: u64,
     #[envconfig(from = "GRAPH_POI_ACCESS_TOKEN")]
     poi_access_token: Option<String>,
     #[envconfig(from = "GRAPH_SUBGRAPH_MAX_DATA_SOURCES", default = "1_000_000_000")]
     subgraph_max_data_sources: NoUnderscores<usize>,
     #[envconfig(from = "GRAPH_DISABLE_FAIL_FAST", default = "false")]
     disable_fail_fast: EnvVarBoolean,
-    #[envconfig(from = "GRAPH_SUBGRAPH_ERROR_RETRY_CEIL_SECS", default = "1800")]
+    #[envconfig(from = "GRAPH_SUBGRAPH_ERROR_RETRY_CEIL_SECS", default = "3600")]
     subgraph_error_retry_ceil_in_secs: u64,
-    #[envconfig(from = "GRAPH_ENABLE_SELECT_BY_SPECIFIC_ATTRIBUTES", default = "false")]
+    #[envconfig(from = "GRAPH_SUBGRAPH_ERROR_RETRY_JITTER", default = "0.2")]
+    subgraph_error_retry_jitter: f64,
+    #[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")]
@@ -329,9 +572,63 @@ struct Inner {
     external_http_base_url: Option<String>,
     #[envconfig(from = "EXTERNAL_WS_BASE_URL")]
     external_ws_base_url: Option<String>,
-    // Setting this to be unrealistically high so it doesn't get triggered.
-    #[envconfig(from = "GRAPH_STATIC_FILTERS_THRESHOLD", default = "100000000")]
+    #[envconfig(from = "GRAPH_STATIC_FILTERS_THRESHOLD", default = "10000")]
     static_filters_threshold: usize,
+    // 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_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 1132333c0dd..92c5564d17f 100644
--- a/graph/src/env/store.rs
+++ b/graph/src/env/store.rs
@@ -1,5 +1,7 @@
 use std::fmt;
 
+use crate::bail;
+
 use super::*;
 
 #[derive(Clone)]
@@ -13,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.
     ///
@@ -43,26 +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,
-    /// When the flag is present, `ORDER BY` clauses are changed so that `asc`
-    /// and `desc` ordering produces reverse orders. Setting the flag turns the
-    /// new, correct behavior off.
-    ///
-    /// Set by the flag `REVERSIBLE_ORDER_BY_OFF`.
-    pub reversible_order_by_off: 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,
-    /// A fallback in case the logic to remember database availability goes
-    /// wrong; when this is set, we always try to get a connection and never
-    /// use the availability state we remembered.
-    ///
-    /// Set by the flag `GRAPH_STORE_CONNECTION_TRY_ALWAYS`. Disabled by
-    /// default.
-    pub connection_try_always: 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,
@@ -77,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>,
@@ -94,6 +84,107 @@ pub struct EnvVarsStore {
     /// Set by `GRAPH_STORE_BATCH_TARGET_DURATION` (expressed in seconds).
     /// 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
+    pub rebuild_threshold: f64,
+    /// Prune tables where we will remove at least this fraction of entity
+    /// versions, but fewer than `rebuild_threshold`, by deleting. Set by
+    /// `GRAPH_STORE_HISTORY_DELETE_THRESHOLD`. The default is 0.05
+    pub delete_threshold: f64,
+    /// How much history a subgraph with limited history can accumulate
+    /// before it will be pruned. Setting this to 1.1 means that the
+    /// subgraph will be pruned every time it contains 10% more history (in
+    /// 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.
+    /// Setting this to 0 disables write batching.
+    pub write_batch_duration: Duration,
+    /// How many changes to accumulate in bytes before a write has to
+    /// happen. Set by the environment variable
+    /// `GRAPH_STORE_WRITE_BATCH_SIZE`, which is in kilobytes. The default
+    /// 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,
+    /// Temporary env var in case we need to quickly rollback PR #5010
+    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
@@ -103,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,
@@ -120,19 +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,
-            reversible_order_by_off: x.reversible_order_by_off.0,
-            disable_subscription_notifications: x.disable_subscription_notifications.0,
-            connection_try_always: x.connection_try_always.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)
     }
 }
 
@@ -142,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")]
@@ -154,12 +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 = "REVERSIBLE_ORDER_BY_OFF", default = "false")]
-    reversible_order_by_off: EnvVarBoolean,
-    #[envconfig(from = "GRAPH_DISABLE_SUBSCRIPTION_NOTIFICATIONS", default = "false")]
-    disable_subscription_notifications: EnvVarBoolean,
-    #[envconfig(from = "GRAPH_STORE_CONNECTION_TRY_ALWAYS", default = "false")]
-    connection_try_always: 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")]
@@ -171,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")]
@@ -179,4 +319,87 @@ 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)]
+struct ZeroToOneF64(f64);
+
+impl FromStr for ZeroToOneF64 {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let f = s.parse::<f64>()?;
+        if !(0.0..=1.0).contains(&f) {
+            bail!("invalid value: {s} must be between 0 and 1");
+        } else {
+            Ok(ZeroToOneF64(f))
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct HistorySlackF64(f64);
+
+impl FromStr for HistorySlackF64 {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let f = s.parse::<f64>()?;
+        if f < 1.01 {
+            bail!("invalid value: {s} must be bigger than 1.01");
+        } else {
+            Ok(HistorySlackF64(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 c4d392515ff..8176dc3fbd1 100644
--- a/graph/src/firehose/endpoints.rs
+++ b/graph/src/firehose/endpoints.rs
@@ -1,41 +1,136 @@
+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,
+    endpoint::{ConnectionType, EndpointMetrics, RequestLabels},
+    env::ENV_VARS,
     firehose::decode_firehose_block,
-    prelude::{anyhow, debug, info},
-    substreams,
+    prelude::{DeploymentHash, anyhow, debug},
 };
-
-use anyhow::bail;
-use futures03::StreamExt;
+use anyhow::Context;
+use async_trait::async_trait;
+use futures03::{StreamExt, TryStreamExt};
 use http::uri::{Scheme, Uri};
-use slog::Logger;
-use std::{collections::BTreeMap, fmt::Display, sync::Arc, time::Duration};
+use itertools::Itertools;
+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::MetadataValue,
+    metadata::{Ascii, MetadataKey, MetadataValue},
     transport::{Channel, ClientTlsConfig},
-    Request,
 };
 
-use super::codec as firehose;
+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.
 /// For more details see: https://github.com/graphprotocol/graph-node/issues/3879
 pub const SUBGRAPHS_PER_CONN: usize = 100;
 
-#[derive(Clone, Debug)]
+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: String,
-    pub token: Option<String>,
+    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)]
+pub enum AvailableCapacity {
+    Unavailable,
+    Low,
+    High,
 }
 
 // TODO: Find a new home for this type.
@@ -47,6 +142,36 @@ pub enum SubgraphLimit {
 }
 
 impl SubgraphLimit {
+    pub fn get_capacity(&self, current: usize) -> AvailableCapacity {
+        match self {
+            // Limit(0) should probably be Disabled but just in case
+            SubgraphLimit::Disabled | SubgraphLimit::Limit(0) => AvailableCapacity::Unavailable,
+            SubgraphLimit::Limit(total) => {
+                let total = *total;
+                if current >= total {
+                    return AvailableCapacity::Unavailable;
+                }
+
+                let used_percent = current * 100 / total;
+
+                // If total is low it can vary very quickly so we can consider 50% as the low threshold
+                // to make selection more reliable
+                let threshold_percent = if total <= LOW_VALUE_THRESHOLD {
+                    LOW_VALUE_USED_PERCENTAGE
+                } else {
+                    HIGH_VALUE_USED_PERCENTAGE
+                };
+
+                if used_percent < threshold_percent {
+                    return AvailableCapacity::High;
+                }
+
+                AvailableCapacity::Low
+            }
+            _ => AvailableCapacity::High,
+        }
+    }
+
     pub fn has_capacity(&self, current: usize) -> bool {
         match self {
             SubgraphLimit::Unlimited => true,
@@ -67,9 +192,11 @@ impl FirehoseEndpoint {
         provider: S,
         url: S,
         token: Option<String>,
+        key: Option<String>,
         filters_enabled: bool,
         compression_enabled: bool,
         subgraph_limit: SubgraphLimit,
+        endpoint_metrics: Arc<EndpointMetrics>,
     ) -> Self {
         let uri = url
             .as_ref()
@@ -78,12 +205,31 @@ 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"),
         };
 
+        // These tokens come from the config so they have to be ascii.
+        let token: Option<MetadataValue<Ascii>> = token
+            .map_or(Ok(None), |token| {
+                let bearer_token = format!("bearer {}", token);
+                bearer_token.parse::<MetadataValue<Ascii>>().map(Some)
+            })
+            .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
@@ -111,20 +257,94 @@ impl FirehoseEndpoint {
         };
 
         FirehoseEndpoint {
-            provider: provider.as_ref().to_string(),
+            provider: provider.as_ref().into(),
             channel: endpoint.connect_lazy(),
-            token,
+            auth: AuthInterceptor { token, key },
             filters_enabled,
             compression_enabled,
             subgraph_limit,
+            endpoint_metrics,
+            info_response: OnceCell::new(),
         }
     }
 
+    pub fn current_error_count(&self) -> u64 {
+        self.endpoint_metrics.get_count(&self.provider)
+    }
+
     // we need to -1 because there will always be a reference
     // inside FirehoseEndpoints that is not used (is always cloned).
-    pub fn has_subgraph_capacity(self: &Arc<Self>) -> bool {
+    pub fn get_capacity(self: &Arc<Self>) -> AvailableCapacity {
         self.subgraph_limit
-            .has_capacity(Arc::strong_count(self).saturating_sub(1))
+            .get_capacity(Arc::strong_count(self).saturating_sub(1))
+    }
+
+    fn metrics_interceptor(&self) -> MetricsInterceptor<Channel> {
+        MetricsInterceptor {
+            metrics: self.endpoint_metrics.cheap_clone(),
+            service: self.channel.cheap_clone(),
+            labels: RequestLabels {
+                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
+    }
+
+    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
+    }
+
+    fn new_stream_client(
+        &self,
+    ) -> StreamClient<
+        InterceptedService<MetricsInterceptor<Channel>, impl tonic::service::Interceptor>,
+    > {
+        let metrics = self.metrics_interceptor();
+
+        let mut client = StreamClient::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
+    }
+
+    fn new_firehose_info_client(&self) -> crate::firehose::endpoint_info::Client {
+        let metrics = self.metrics_interceptor();
+        let auth = self.auth.clone();
+
+        let mut client = crate::firehose::endpoint_info::Client::new(metrics, auth);
+
+        if self.compression_enabled {
+            client = client.with_compression();
+        }
+
+        client = client.with_max_message_size(self.max_message_size());
+        client
     }
 
     pub async fn get_block<M>(
@@ -135,55 +355,201 @@ impl FirehoseEndpoint {
     where
         M: prost::Message + BlockchainBlock + Default + 'static,
     {
-        let token_metadata = match self.token.clone() {
-            Some(token) => Some(MetadataValue::try_from(token.as_str())?),
-            None => None,
+        debug!(
+            logger,
+            "Connecting to firehose to retrieve block for cursor {}", cursor;
+            "provider" => self.provider.as_str(),
+        );
+
+        let req = firehose::SingleBlockRequest {
+            transforms: [].to_vec(),
+            reference: Some(firehose::single_block_request::Reference::Cursor(
+                firehose::single_block_request::Cursor {
+                    cursor: cursor.to_string(),
+                },
+            )),
         };
 
-        let mut client = firehose::fetch_client::FetchClient::with_interceptor(
-            self.channel.cheap_clone(),
-            move |mut r: Request<()>| {
-                if let Some(ref t) = token_metadata {
-                    r.metadata_mut().insert("authorization", t.clone());
-                }
+        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)),
+        }
+    }
 
-                Ok(r)
-            },
-        )
-        .accept_compressed(CompressionEncoding::Gzip);
+    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(),
+        );
 
-        if self.compression_enabled {
-            client = client.send_compressed(CompressionEncoding::Gzip);
+        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)),
         }
+    }
 
-        debug!(
+    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 cursor {}", cursor
+            "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::Cursor(
-                firehose::single_block_request::Cursor {
-                    cursor: cursor.to_string(),
-                },
+            reference: Some(firehose::single_block_request::Reference::BlockNumber(
+                firehose::single_block_request::BlockNumber { num: number },
             )),
         };
-        let resp = client.block(req);
 
-        match resp.await {
+        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
@@ -200,32 +566,14 @@ impl FirehoseEndpoint {
     where
         M: prost::Message + BlockchainBlock + Default + 'static,
     {
-        let token_metadata = match self.token.clone() {
-            Some(token) => Some(MetadataValue::try_from(token.as_str())?),
-            None => None,
-        };
-
-        let mut client = firehose::stream_client::StreamClient::with_interceptor(
-            self.channel.cheap_clone(),
-            move |mut r: Request<()>| {
-                if let Some(ref t) = token_metadata {
-                    r.metadata_mut().insert("authorization", t.clone());
-                }
-
-                Ok(r)
-            },
-        )
-        .accept_compressed(CompressionEncoding::Gzip);
-
-        if self.compression_enabled {
-            client = client.send_compressed(CompressionEncoding::Gzip);
-        }
-
         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();
+
         // The trick is the following.
         //
         // Firehose `start_block_num` and `stop_block_num` are both inclusive, so we specify
@@ -249,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 {
@@ -293,237 +642,347 @@ impl FirehoseEndpoint {
     pub async fn stream_blocks(
         self: Arc<Self>,
         request: firehose::Request,
+        headers: &ConnectionHeaders,
     ) -> Result<tonic::Streaming<firehose::Response>, anyhow::Error> {
-        let token_metadata = match self.token.clone() {
-            Some(token) => Some(MetadataValue::try_from(token.as_str())?),
-            None => None,
-        };
-
-        let mut client = firehose::stream_client::StreamClient::with_interceptor(
-            self.channel.cheap_clone(),
-            move |mut r: Request<()>| {
-                if let Some(ref t) = token_metadata {
-                    r.metadata_mut().insert("authorization", t.clone());
-                }
-
-                Ok(r)
-            },
-        )
-        .accept_compressed(CompressionEncoding::Gzip);
-        if self.compression_enabled {
-            client = client.send_compressed(CompressionEncoding::Gzip);
-        }
-
+        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::Request,
-    ) -> Result<tonic::Streaming<substreams::Response>, anyhow::Error> {
-        let token_metadata = match self.token.clone() {
-            Some(token) => Some(MetadataValue::try_from(token.as_str())?),
-            None => None,
-        };
+    ) -> Result<crate::firehose::endpoint_info::InfoResponse, anyhow::Error> {
+        let endpoint = self.cheap_clone();
 
-        let mut client = substreams::stream_client::StreamClient::with_interceptor(
-            self.channel.cheap_clone(),
-            move |mut r: Request<()>| {
-                if let Some(ref t) = token_metadata {
-                    r.metadata_mut().insert("authorization", t.clone());
-                }
-
-                Ok(r)
-            },
-        );
+        self.info_response
+            .get_or_try_init(move || async move {
+                let mut client = endpoint.new_firehose_info_client();
 
-        let response_stream = client.blocks(request).await?;
-        let block_stream = response_stream.into_inner();
-
-        Ok(block_stream)
+                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 len(&self) -> usize {
-        self.0.len()
+    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,
+            ),
+        )
     }
 
-    // selects the FirehoseEndpoint with the least amount of references, which will help with spliting
-    // the load naively across the entire list.
-    pub fn random(&self) -> anyhow::Result<Arc<FirehoseEndpoint>> {
-        let endpoint = self
-            .0
-            .iter()
-            .min_by_key(|x| Arc::strong_count(x))
-            .ok_or(anyhow!("no available firehose endpoints"))?;
-        if !endpoint.has_subgraph_capacity() {
-            bail!("all connections saturated with {} connections, increase the firehose conn_pool_size or limit for the node", SUBGRAPHS_PER_CONN);
-        }
-
-        // Cloning here ensure we have the correct count at any given time, if we return a reference it can be cloned later
-        // which could cause a high number of endpoints to be given away before accounting for them.
-        Ok(endpoint.clone())
+    pub fn new(
+        chain_name: ChainName,
+        provider_manager: ProviderManager<Arc<FirehoseEndpoint>>,
+    ) -> Self {
+        Self(chain_name, provider_manager)
     }
 
-    pub fn remove(&mut self, provider: &str) {
-        self.0
-            .retain(|network_endpoint| network_endpoint.provider != provider);
-    }
-}
-
-impl From<Vec<Arc<FirehoseEndpoint>>> for FirehoseEndpoints {
-    fn from(val: Vec<Arc<FirehoseEndpoint>>) -> Self {
-        FirehoseEndpoints(val)
+    pub fn len(&self) -> usize {
+        self.1.len(&self.0)
     }
-}
-
-#[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 is_empty(&self) -> bool {
+        self.len() == 0
     }
 
-    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);
-    }
+    /// 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 async fn endpoint(&self) -> anyhow::Result<Arc<FirehoseEndpoint>> {
+        let endpoint = self
+            .1
+            .providers(&self.0)
+            .await?
+            .sorted_by_key(|x| x.current_error_count())
+            .try_fold(None, |acc, adapter| {
+                match adapter.get_capacity() {
+                    AvailableCapacity::Unavailable => ControlFlow::Continue(acc),
+                    AvailableCapacity::Low => match acc {
+                        Some(_) => ControlFlow::Continue(acc),
+                        None => ControlFlow::Continue(Some(adapter)),
+                    },
+                    // This means that if all adapters with low/no errors are low capacity
+                    // we will retry the high capacity that has errors, at this point
+                    // any other available with no errors are almost at their limit.
+                    AvailableCapacity::High => ControlFlow::Break(Some(adapter)),
+                }
+            });
 
-    pub fn remove(&mut self, chain_id: &str, provider: &str) {
-        if let Some(endpoints) = self.networks.get_mut(chain_id) {
-            endpoints.remove(provider);
+        match endpoint {
+            ControlFlow::Continue(adapter)
+            | ControlFlow::Break(adapter) =>
+            adapter.cloned().ok_or(anyhow!("unable to get a connection, increase the firehose conn_pool_size or limit for the node"))
         }
     }
-
-    /// Returns a `Vec` of tuples where the first element of the tuple is
-    /// the chain's id and the second one is an endpoint for this chain.
-    /// There can be mulitple tuple with the same chain id but with different
-    /// endpoint where multiple providers exist for a single chain id.
-    pub fn flatten(&self) -> Vec<(String, Arc<FirehoseEndpoint>)> {
-        self.networks
-            .iter()
-            .flat_map(|(chain_id, firehose_endpoints)| {
-                firehose_endpoints
-                    .0
-                    .iter()
-                    .map(move |endpoint| (chain_id.clone(), endpoint.clone()))
-            })
-            .collect()
-    }
 }
 
 #[cfg(test)]
 mod test {
     use std::{mem, sync::Arc};
 
-    use crate::firehose::SubgraphLimit;
+    use slog::{Discard, Logger, o};
 
-    use super::{FirehoseEndpoint, FirehoseEndpoints, SUBGRAPHS_PER_CONN};
+    use super::*;
+    use crate::components::metrics::MetricsRegistry;
+    use crate::endpoint::EndpointMetrics;
+    use crate::firehose::SubgraphLimit;
 
-    #[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.random().unwrap());
+            keep.push(endpoints.endpoint().await.unwrap());
         }
 
-        let err = endpoints.random().unwrap_err();
+        let err = endpoints.endpoint().await.unwrap_err();
         assert!(err.to_string().contains("conn_pool_size"));
 
         mem::drop(keep);
-        endpoints.random().unwrap();
+        endpoints.endpoint().await.unwrap();
 
-        // Fails when empty too
-        endpoints.remove("");
+        let endpoints = FirehoseEndpoints::for_testing(vec![]);
 
-        let err = endpoints.random().unwrap_err();
-        assert!(err.to_string().contains("no available firehose endpoints"));
+        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.random().unwrap());
+            keep.push(endpoints.endpoint().await.unwrap());
         }
 
-        let err = endpoints.random().unwrap_err();
+        let err = endpoints.endpoint().await.unwrap_err();
         assert!(err.to_string().contains("conn_pool_size"));
 
         mem::drop(keep);
-        endpoints.random().unwrap();
-
-        // Fails when empty too
-        endpoints.remove("");
-
-        let err = endpoints.random().unwrap_err();
-        assert!(err.to_string().contains("no available firehose endpoints"));
+        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.random().unwrap_err();
+        let err = endpoints.endpoint().await.unwrap_err();
         assert!(err.to_string().contains("conn_pool_size"));
+    }
+
+    #[crate::test]
+    async fn firehose_endpoint_selection() {
+        let logger = Logger::root(Discard, o!());
+        let endpoint_metrics = Arc::new(EndpointMetrics::new(
+            logger,
+            &["high_error", "low availability", "high availability"],
+            Arc::new(MetricsRegistry::mock()),
+        ));
+
+        let high_error_adapter1 = Arc::new(FirehoseEndpoint::new(
+            "high_error".to_string(),
+            "http://127.0.0.1".to_string(),
+            None,
+            None,
+            false,
+            false,
+            SubgraphLimit::Unlimited,
+            endpoint_metrics.clone(),
+        ));
+        let high_error_adapter2 = Arc::new(FirehoseEndpoint::new(
+            "high_error".to_string(),
+            "http://127.0.0.1".to_string(),
+            None,
+            None,
+            false,
+            false,
+            SubgraphLimit::Unlimited,
+            endpoint_metrics.clone(),
+        ));
+        let low_availability = Arc::new(FirehoseEndpoint::new(
+            "low availability".to_string(),
+            "http://127.0.0.2".to_string(),
+            None,
+            None,
+            false,
+            false,
+            SubgraphLimit::Limit(2),
+            endpoint_metrics.clone(),
+        ));
+        let high_availability = Arc::new(FirehoseEndpoint::new(
+            "high availability".to_string(),
+            "http://127.0.0.3".to_string(),
+            None,
+            None,
+            false,
+            false,
+            SubgraphLimit::Unlimited,
+            endpoint_metrics.clone(),
+        ));
+
+        endpoint_metrics.report_for_test(&high_error_adapter1.provider, false);
+
+        let endpoints = FirehoseEndpoints::for_testing(vec![
+            high_error_adapter1.clone(),
+            high_error_adapter2.clone(),
+            low_availability.clone(),
+            high_availability.clone(),
+        ]);
+
+        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
+        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().await.unwrap();
+        // This will match both high error adapters
+        assert_eq!(res.provider, high_error_adapter1.provider);
+    }
 
-        // Fails when empty too
-        endpoints.remove("");
+    #[test]
+    fn subgraph_limit_calculates_availability() {
+        #[derive(Debug)]
+        struct Case {
+            limit: SubgraphLimit,
+            current: usize,
+            capacity: AvailableCapacity,
+        }
+
+        let cases = vec![
+            Case {
+                limit: SubgraphLimit::Disabled,
+                current: 20,
+                capacity: AvailableCapacity::Unavailable,
+            },
+            Case {
+                limit: SubgraphLimit::Limit(0),
+                current: 20,
+                capacity: AvailableCapacity::Unavailable,
+            },
+            Case {
+                limit: SubgraphLimit::Limit(0),
+                current: 0,
+                capacity: AvailableCapacity::Unavailable,
+            },
+            Case {
+                limit: SubgraphLimit::Limit(100),
+                current: 80,
+                capacity: AvailableCapacity::Low,
+            },
+            Case {
+                limit: SubgraphLimit::Limit(2),
+                current: 1,
+                capacity: AvailableCapacity::Low,
+            },
+            Case {
+                limit: SubgraphLimit::Limit(100),
+                current: 19,
+                capacity: AvailableCapacity::High,
+            },
+            Case {
+                limit: SubgraphLimit::Limit(100),
+                current: 100,
+                capacity: AvailableCapacity::Unavailable,
+            },
+            Case {
+                limit: SubgraphLimit::Limit(100),
+                current: 99,
+                capacity: AvailableCapacity::Low,
+            },
+            Case {
+                limit: SubgraphLimit::Limit(100),
+                current: 101,
+                capacity: AvailableCapacity::Unavailable,
+            },
+            Case {
+                limit: SubgraphLimit::Unlimited,
+                current: 1000,
+                capacity: AvailableCapacity::High,
+            },
+            Case {
+                limit: SubgraphLimit::Unlimited,
+                current: 0,
+                capacity: AvailableCapacity::High,
+            },
+        ];
+
+        for c in cases {
+            let res = c.limit.get_capacity(c.current);
+            assert_eq!(res, c.capacity, "{:#?}", c);
+        }
+    }
 
-        let err = endpoints.random().unwrap_err();
-        assert!(err.to_string().contains("no available firehose endpoints"));
+    #[test]
+    fn available_capacity_ordering() {
+        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
new file mode 100644
index 00000000000..3ef62b24f13
--- /dev/null
+++ b/graph/src/firehose/interceptors.rs
@@ -0,0 +1,85 @@
+use std::future::Future;
+use std::pin::Pin;
+use std::{fmt, sync::Arc};
+
+use tonic::{
+    codegen::Service,
+    metadata::{Ascii, MetadataValue},
+    service::Interceptor,
+};
+
+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, &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"),
+        }
+    }
+}
+
+impl Interceptor for AuthInterceptor {
+    fn call(&mut self, mut req: tonic::Request<()>) -> Result<tonic::Request<()>, tonic::Status> {
+        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)
+    }
+}
+
+pub struct MetricsInterceptor<S> {
+    pub(crate) metrics: Arc<EndpointMetrics>,
+    pub(crate) service: S,
+    pub(crate) labels: RequestLabels,
+}
+
+impl<S, Request> Service<Request> for MetricsInterceptor<S>
+where
+    S: Service<Request>,
+    S::Future: Send + 'static,
+    Request: fmt::Debug,
+{
+    type Response = S::Response;
+
+    type Error = S::Error;
+
+    type Future = Pin<Box<dyn Future<Output = <S::Future as Future>::Output> + Send + 'static>>;
+
+    fn poll_ready(
+        &mut self,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(cx)
+    }
+
+    fn call(&mut self, req: Request) -> Self::Future {
+        let labels = self.labels.clone();
+        let metrics = self.metrics.clone();
+
+        let fut = self.service.call(req);
+        let res = async move {
+            let res = fut.await;
+            if res.is_ok() {
+                metrics.success(&labels);
+            } else {
+                metrics.failure(&labels);
+            }
+            res
+        };
+
+        Box::pin(res)
+    }
+}
diff --git a/graph/src/firehose/mod.rs b/graph/src/firehose/mod.rs
index 8dd12b09587..9f4e8510c3b 100644
--- a/graph/src/firehose/mod.rs
+++ b/graph/src/firehose/mod.rs
@@ -1,6 +1,8 @@
 mod codec;
+mod endpoint_info;
 mod endpoints;
 mod helpers;
+mod interceptors;
 
 pub use codec::*;
 pub use endpoints::*;
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 3fe4f578386..00000000000
--- a/graph/src/ipfs_client.rs
+++ /dev/null
@@ -1,324 +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>,
-    client: Arc<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: Arc::new(reqwest::Client::new()),
-            base: Arc::new(Uri::from_str(base)?),
-        })
-    }
-
-    pub fn localhost() -> Self {
-        IpfsClient {
-            client: Arc::new(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 d686ff7c899..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,28 +24,49 @@ pub mod runtime;
 
 pub mod firehose;
 
-pub mod substreams;
+pub mod endpoint;
+
+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_stream;
 pub use url;
 
 /// A prelude that makes all system component traits and data types available.
@@ -58,24 +77,13 @@ pub use url;
 /// use graph::prelude::*;
 /// ```
 pub mod prelude {
-    pub use super::entity;
     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;
@@ -84,8 +92,9 @@ pub mod prelude {
     pub use serde;
     pub use serde_derive::{Deserialize, Serialize};
     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;
@@ -93,10 +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>>;
@@ -107,50 +115,42 @@ pub mod prelude {
         EthereumBlock, EthereumBlockWithCalls, EthereumCall, LightEthereumBlock,
         LightEthereumBlockExt,
     };
-    pub use crate::components::graphql::{
-        GraphQLMetrics, GraphQlRunner, QueryLoadManager, SubscriptionResultFuture,
+    pub use crate::components::graphql::{GraphQLMetrics, GraphQlRunner};
+    pub use crate::components::link_resolver::{
+        IpfsResolver, JsonStreamValue, JsonValueStream, LinkResolver,
     };
-    pub use crate::components::link_resolver::{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::{
-        AttributeNames, BlockNumber, CachedEthereumCall, ChainStore, Child, ChildMultiplicity,
-        EntityCache, EntityChange, EntityChangeOperation, EntityCollection, EntityFilter,
-        EntityLink, EntityModification, EntityOperation, EntityOrder, EntityOrderByChild,
+        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, StoreError,
-        StoreEvent, StoreEventStream, StoreEventStreamBox, SubgraphStore, UnfailOutcome,
-        WindowAttribute, BLOCK_NUMBER_MAX,
+        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::schema::{ApiSchema, Schema};
-    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, TryIntoEntity, 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,
@@ -158,51 +158,54 @@ 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, 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::Value;
+        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 cbc49810beb..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 {
@@ -139,8 +54,6 @@ pub struct ElasticDrainConfig {
     pub general: ElasticLoggingConfig,
     /// The Elasticsearch index to log to.
     pub index: String,
-    /// The Elasticsearch type to use for logs.
-    pub document_type: String,
     /// The name of the custom object id that the drain is for.
     pub custom_id_key: String,
     /// The custom id for the object that the drain is for.
@@ -156,8 +69,7 @@ pub struct ElasticDrainConfig {
 /// Writes logs to Elasticsearch using the following format:
 /// ```ignore
 /// {
-///   "_index": "subgraph-logs"
-///   "_type": "log",
+///   "_index": "subgraph-logs",
 ///   "_id": "Qmb31zcpzqga7ERaUTp83gVdYcuBasz4rXUHFufikFTJGU-2018-11-08T00:54:52.589258000Z",
 ///   "_source": {
 ///     "level": "debug",
@@ -205,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;
 
@@ -245,7 +157,6 @@ impl ElasticDrain {
                             let action_line = json!({
                                 "index": {
                                     "_index": config.index,
-                                    "_type": config.document_type,
                                     "_id": log.id,
                                 }
                             })
@@ -313,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();
@@ -360,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
@@ -390,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 1b126a6995d..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>,
-    metrics_registry: Arc<dyn MetricsRegistry>,
+    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>,
-        metrics_registry: Arc<dyn MetricsRegistry>,
+        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,58 +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,
-                                    document_type: String::from("log"),
-                                    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"),
-                            document_type: String::from("log"),
-                            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 60bbbcd5153..833f984e208 100644
--- a/graph/src/log/mod.rs
+++ b/graph/src/log/mod.rs
@@ -17,22 +17,32 @@ 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 {
-    let use_color = isatty::stdout_isatty();
+    logger_with_levels(show_debug, ENV_VARS.log_levels.as_deref())
+}
+
+pub fn logger_with_levels(show_debug: bool, levels: Option<&str>) -> Logger {
+    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)
@@ -44,7 +54,7 @@ pub fn logger(show_debug: bool) -> Logger {
                 FilterLevel::Info
             },
         )
-        .parse(ENV_VARS.log_levels.as_deref().unwrap_or(""))
+        .parse(levels.unwrap_or(""))
         .build();
     let drain = slog_async::Async::new(drain)
         .chan_size(20000)
@@ -90,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()?;
@@ -102,7 +115,9 @@ where
             write!(decorator, " ")?;
 
             decorator.start_msg()?;
-            write!(decorator, "{}", record.msg())?;
+            // Escape control characters in the message, including newlines.
+            let msg = escape_control_chars(record.msg().to_string());
+            write!(decorator, "{}", msg)?;
 
             // Collect key values from the record
             let mut serializer = KeyValueSerializer::new();
@@ -381,3 +396,47 @@ fn formatted_timestamp_local(io: &mut impl io::Write) -> io::Result<()> {
         chrono::Local::now().format(ENV_VARS.log_time_format.as_str())
     )
 }
+
+pub fn escape_control_chars(input: String) -> String {
+    let should_escape = |c: char| c.is_control() && c != '\t';
+
+    if !input.chars().any(should_escape) {
+        return input;
+    }
+
+    let mut escaped = String::new();
+    for c in input.chars() {
+        match c {
+            '\n' => escaped.push_str("\\n"),
+            c if should_escape(c) => {
+                let code = c as u32;
+                escaped.push_str(&format!("\\u{{{:04x}}}", code));
+            }
+            _ => escaped.push(c),
+        }
+    }
+    escaped
+}
+
+#[test]
+fn test_escape_control_chars() {
+    let test_cases = vec![
+        (
+            "This is a test\nwith some\tcontrol characters\x1B[1;32m and others.",
+            "This is a test\\nwith some\tcontrol characters\\u{001b}[1;32m and others.",
+        ),
+        (
+            "This string has no control characters.",
+            "This string has no control characters.",
+        ),
+        (
+            "This string has a tab\tbut no other control characters.",
+            "This string has a tab\tbut no other control characters.",
+        ),
+    ];
+
+    for (input, expected) in test_cases {
+        let escaped = escape_control_chars(input.to_string());
+        assert_eq!(escaped, expected);
+    }
+}
diff --git a/graph/src/runtime/asc_heap.rs b/graph/src/runtime/asc_heap.rs
index c39165461db..ecccf546ba3 100644
--- a/graph/src/runtime/asc_heap.rs
+++ b/graph/src/runtime/asc_heap.rs
@@ -1,17 +1,29 @@
 use std::mem::MaybeUninit;
 
+use async_trait::async_trait;
 use semver::Version;
 
 use super::{
-    gas::GasCounter, AscIndexId, AscPtr, AscType, DeterministicHostError, 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
+// large enough to cause stack overflows.
+const MAX_RECURSION_DEPTH: usize = 128;
+
 /// A type that can read and write to the Asc heap. Call `asc_new` and `asc_get`
 /// 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,
@@ -22,12 +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(
+    async fn asc_type_id(
         &mut self,
         type_id_index: IndexForAscTypeId,
-    ) -> Result<u32, DeterministicHostError>;
+    ) -> Result<u32, HostExportError>;
 }
 
 /// Instantiate `rust_obj` as an Asc object of class `C`.
@@ -35,58 +47,58 @@ 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>, DeterministicHostError>
+) -> 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,
     type_name: &str,
     field_name: &str,
-) -> Result<AscPtr<A>, DeterministicHostError>
+) -> 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>, DeterministicHostError>
+) -> 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()),
     }
 }
 
 /// Create an error for a missing field in a type.
-fn missing_field_error(type_name: &str, field_name: &str) -> DeterministicHostError {
-    DeterministicHostError::from(anyhow::anyhow!("{} missing {}", type_name, field_name))
+fn missing_field_error(type_name: &str, field_name: &str) -> HostExportError {
+    DeterministicHostError::from(anyhow::anyhow!("{} missing {}", type_name, field_name)).into()
 }
 
 ///  Read the rust representation of an Asc object of class `C`.
@@ -97,48 +109,65 @@ pub fn asc_get<T, C, H: AscHeap + ?Sized>(
     heap: &H,
     asc_ptr: AscPtr<C>,
     gas: &GasCounter,
+    mut depth: usize,
 ) -> Result<T, DeterministicHostError>
 where
     C: AscType + AscIndexId,
     T: FromAscObj<C>,
 {
-    T::from_asc_obj(asc_ptr.read_ptr(heap, gas)?, heap, gas)
+    depth += 1;
+
+    if depth > MAX_RECURSION_DEPTH {
+        return Err(DeterministicHostError::Other(anyhow::anyhow!(
+            "recursion limit reached"
+        )));
+    }
+
+    T::from_asc_obj(asc_ptr.read_ptr(heap, gas)?, heap, gas, depth)
 }
 
 /// 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, DeterministicHostError>;
+    ) -> 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, DeterministicHostError> {
-        (*self).to_asc_obj(heap, gas)
+    ) -> Result<C, HostExportError> {
+        (*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,
-    ) -> Result<bool, DeterministicHostError> {
+    ) -> Result<bool, HostExportError> {
         Ok(*self)
     }
 }
 
 /// Type that can be converted from an Asc object of class `C`.
+///
+/// ### Overflow protection
+/// The `depth` parameter is used to prevent stack overflows, it measures how many `asc_get` calls
+/// have been made. `from_asc_obj` does not need to increment the depth, only pass it through.
 pub trait FromAscObj<C: AscType>: Sized {
     fn from_asc_obj<H: AscHeap + ?Sized>(
         obj: C,
         heap: &H,
         gas: &GasCounter,
+        depth: usize,
     ) -> Result<Self, DeterministicHostError>;
 }
diff --git a/graph/src/runtime/asc_ptr.rs b/graph/src/runtime/asc_ptr.rs
index 59796ee60d6..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};
+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,17 +84,17 @@ 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,
-    ) -> Result<AscPtr<C>, DeterministicHostError>
+    ) -> Result<AscPtr<C>, HostExportError>
     where
         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,18 +140,19 @@ 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,
         full_length: usize,
-    ) -> Result<Vec<u8>, DeterministicHostError> {
+    ) -> Result<Vec<u8>, HostExportError> {
         let mut header: Vec<u8> = Vec::with_capacity(20);
 
         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 a4593a0d253..06decdf03aa 100644
--- a/graph/src/runtime/gas/costs.rs
+++ b/graph/src/runtime/gas/costs.rs
@@ -53,6 +53,8 @@ pub const BIG_MATH_GAS_OP: GasOp = GasOp {
 // Allow up to 100,000 data sources to be created
 pub const CREATE_DATA_SOURCE: Gas = Gas(CONST_MAX_GAS_PER_HANDLER / 100_000);
 
+pub const ENS_NAME_BY_HASH: Gas = Gas(DEFAULT_BASE_COST);
+
 pub const LOG_OP: GasOp = GasOp {
     // Allow up to 100,000 logs
     base_cost: CONST_MAX_GAS_PER_HANDLER / 100_000,
@@ -74,3 +76,17 @@ pub const STORE_GET: GasOp = GasOp {
 };
 
 pub const STORE_REMOVE: GasOp = STORE_SET;
+
+// Deeply nested JSON can take over 100x the memory of the serialized format, so multiplying the
+// size cost by 100 makes sense.
+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 7d9bb38b620..ab666c9095b 100644
--- a/graph/src/runtime/gas/mod.rs
+++ b/graph/src/runtime/gas/mod.rs
@@ -3,15 +3,17 @@ mod costs;
 mod ops;
 mod saturating;
 mod size_of;
-use crate::prelude::{CheapClone, ENV_VARS};
+use crate::components::metrics::gas::GasMetrics;
+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 {
@@ -54,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);
@@ -75,22 +77,38 @@ impl Display for Gas {
     }
 }
 
-#[derive(Clone, Default)]
-pub struct GasCounter(Arc<AtomicU64>);
-
-impl CheapClone for GasCounter {}
+#[derive(Clone, CheapClone)]
+pub struct GasCounter {
+    counter: Arc<AtomicU64>,
+    metrics: GasMetrics,
+}
 
 impl GasCounter {
-    /// Alias of [`Default::default`].
-    pub fn new() -> Self {
-        Self::default()
+    pub fn new(metrics: GasMetrics) -> Self {
+        Self {
+            counter: Arc::new(AtomicU64::new(0)),
+            metrics,
+        }
     }
 
     /// This should be called once per host export
-    pub fn consume_host_fn(&self, mut amount: Gas) -> Result<(), DeterministicHostError> {
+    pub fn consume_host_fn_inner(
+        &self,
+        mut amount: Gas,
+        method: Option<&str>,
+    ) -> Result<(), DeterministicHostError> {
         amount += costs::HOST_EXPORT_GAS;
+
+        // If gas metrics are enabled, track the gas used
+        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
-            .0
+            .counter
             .fetch_update(SeqCst, SeqCst, |v| Some(v.saturating_add(amount.0)))
             .unwrap();
         let new = old.saturating_add(amount.0);
@@ -104,7 +122,19 @@ impl GasCounter {
         }
     }
 
+    pub fn consume_host_fn(&self, amount: Gas) -> Result<(), DeterministicHostError> {
+        self.consume_host_fn_inner(amount, Some("untracked"))
+    }
+
+    pub fn consume_host_fn_with_metrics(
+        &self,
+        amount: Gas,
+        method: &str,
+    ) -> Result<(), DeterministicHostError> {
+        self.consume_host_fn_inner(amount, Some(method))
+    }
+
     pub fn get(&self) -> Gas {
-        Gas(self.0.load(SeqCst))
+        Gas(self.counter.load(SeqCst))
     }
 }
diff --git a/graph/src/runtime/gas/size_of.rs b/graph/src/runtime/gas/size_of.rs
index 49bb60b1215..05369d94847 100644
--- a/graph/src/runtime/gas/size_of.rs
+++ b/graph/src/runtime/gas/size_of.rs
@@ -1,9 +1,9 @@
 //! Various implementations of GasSizeOf;
 
 use crate::{
-    components::store::{EntityKey, EntityType},
-    data::store::{scalar::Bytes, Value},
-    prelude::{BigDecimal, BigInt},
+    components::store::LoadRelatedRequest,
+    data::store::{Value, scalar::Bytes},
+    schema::{EntityKey, EntityType},
 };
 
 use super::{Gas, GasSizeOf, SaturatingInto as _};
@@ -16,6 +16,8 @@ impl GasSizeOf for Value {
             Value::Null => Gas(1),
             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(),
@@ -50,22 +52,6 @@ where
     }
 }
 
-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()
-    }
-}
-
-impl GasSizeOf for BigDecimal {
-    fn gas_size_of(&self) -> Gas {
-        let (int, _) = self.as_bigint_and_exponent();
-        BigInt::from(int).gas_size_of()
-    }
-}
-
 impl GasSizeOf for str {
     fn gas_size_of(&self) -> Gas {
         self.len().saturating_into()
@@ -168,6 +154,14 @@ impl GasSizeOf for EntityKey {
     }
 }
 
+impl GasSizeOf for LoadRelatedRequest {
+    fn gas_size_of(&self) -> Gas {
+        self.entity_type.gas_size_of()
+            + self.entity_id.gas_size_of()
+            + self.entity_field.gas_size_of()
+    }
+}
+
 impl GasSizeOf for EntityType {
     fn gas_size_of(&self) -> Gas {
         self.as_str().gas_size_of()
diff --git a/graph/src/runtime/mod.rs b/graph/src/runtime/mod.rs
index 4b7109c6f8e..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,8 +260,9 @@ 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.
     // e.g.:
     // NextEthereumType = 1004,
@@ -267,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,
@@ -354,7 +287,33 @@ pub enum IndexForAscTypeId {
     // ...
     // LastArweaveType = 3499,
 
-    // Reserved discriminant space for a future blockchain type IDs: [3,500, 4,499]
+    // StarkNet types
+    StarknetBlock = 3500,
+    StarknetTransaction = 3501,
+    StarknetTransactionTypeEnum = 3502,
+    StarknetEvent = 3503,
+    StarknetArrayBytes = 3504,
+    // Continue to add more StarkNet type IDs here.
+    // e.g.:
+    // NextStarknetType = 3505,
+    // AnotherStarknetType = 3506,
+    // ...
+    // LastStarknetType = 4499,
+
+    // 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:
     //
@@ -380,12 +339,13 @@ 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,
-    ) -> Result<u32, DeterministicHostError> {
+    ) -> Result<u32, HostExportError> {
         Ok(*self as u32)
     }
 }
diff --git a/graph/src/schema/api.rs b/graph/src/schema/api.rs
new file mode 100644
index 00000000000..38ee4582a47
--- /dev/null
+++ b/graph/src/schema/api.rs
@@ -0,0 +1,2500 @@
+use std::collections::{BTreeMap, HashMap};
+use std::str::FromStr;
+use std::sync::Arc;
+
+use anyhow::Context;
+use lazy_static::lazy_static;
+use thiserror::Error;
+
+use crate::cheap_clone::CheapClone;
+use crate::data::graphql::{ObjectOrInterface, ObjectTypeExt, TypeExt};
+use crate::data::store::IdType;
+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, camel_cased_names,
+};
+use crate::derive::CheapClone;
+use crate::prelude::{DeploymentHash, q, r, s};
+
+use super::{Aggregation, Field, InputSchema, Schema, TypeKind};
+
+#[derive(Error, Debug)]
+pub enum APISchemaError {
+    #[error("type {0} already exists in the input schema")]
+    TypeExists(String),
+    #[error("Type {0} not found")]
+    TypeNotFound(String),
+    #[error("Fulltext search is not yet deterministic")]
+    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
+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, CheapClone)]
+pub enum ErrorPolicy {
+    Allow,
+    Deny,
+}
+
+impl std::str::FromStr for ErrorPolicy {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<ErrorPolicy, anyhow::Error> {
+        match s {
+            "allow" => Ok(ErrorPolicy::Allow),
+            "deny" => Ok(ErrorPolicy::Deny),
+            _ => Err(anyhow::anyhow!("failed to parse `{}` as ErrorPolicy", s)),
+        }
+    }
+}
+
+impl TryFrom<&q::Value> for ErrorPolicy {
+    type Error = anyhow::Error;
+
+    /// `value` should be the output of input value coercion.
+    fn try_from(value: &q::Value) -> Result<Self, Self::Error> {
+        match value {
+            q::Value::Enum(s) => ErrorPolicy::from_str(s),
+            _ => Err(anyhow::anyhow!("invalid `ErrorPolicy`")),
+        }
+    }
+}
+
+impl TryFrom<&r::Value> for ErrorPolicy {
+    type Error = anyhow::Error;
+
+    /// `value` should be the output of input value coercion.
+    fn try_from(value: &r::Value) -> Result<Self, Self::Error> {
+        match value {
+            r::Value::Enum(s) => ErrorPolicy::from_str(s),
+            _ => Err(anyhow::anyhow!("invalid `ErrorPolicy`")),
+        }
+    }
+}
+
+/// A GraphQL schema used for responding to queries. These schemas can be
+/// generated in one of two ways:
+///
+/// (1) By calling `api_schema()` on an `InputSchema`. This is the way to
+/// generate a query schema for a subgraph.
+///
+/// (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, 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
+/// for querying.
+#[derive(Debug)]
+pub struct ApiSchema {
+    schema: Schema,
+
+    // Root types for the api schema.
+    pub query_type: Arc<s::ObjectType>,
+    object_types: HashMap<String, Arc<s::ObjectType>>,
+}
+
+impl ApiSchema {
+    /// Set up the `ApiSchema`, mostly by extracting important pieces of
+    /// information from it like `query_type` etc.
+    ///
+    /// In addition, the API schema has an introspection schema mixed into
+    /// `api_schema`. In particular, the `Query` type has fields called
+    /// `__schema` and `__type`
+    pub(in crate::schema) fn from_api_schema(mut schema: Schema) -> Result<Self, anyhow::Error> {
+        add_introspection_schema(&mut schema.document);
+
+        let query_type = schema
+            .document
+            .get_root_query_type()
+            .context("no root `Query` in the schema")?
+            .clone();
+
+        let object_types = HashMap::from_iter(
+            schema
+                .document
+                .get_object_type_definitions()
+                .into_iter()
+                .map(|obj_type| (obj_type.name.clone(), Arc::new(obj_type.clone()))),
+        );
+
+        Ok(Self {
+            schema,
+            query_type: Arc::new(query_type),
+            object_types,
+        })
+    }
+
+    /// Create an API Schema that can be used to execute GraphQL queries.
+    /// This method is only meant for schemas that are not derived from a
+    /// subgraph schema, like the schema for the index-node server. Use
+    /// `InputSchema::api_schema` to get an API schema for a subgraph
+    pub fn from_graphql_schema(schema: Schema) -> Result<Self, anyhow::Error> {
+        Self::from_api_schema(schema)
+    }
+
+    pub fn document(&self) -> &s::Document {
+        &self.schema.document
+    }
+
+    pub fn id(&self) -> &DeploymentHash {
+        &self.schema.id
+    }
+
+    pub fn schema(&self) -> &Schema {
+        &self.schema
+    }
+
+    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<s::InterfaceType>> {
+        self.schema.interfaces_for_type(type_name)
+    }
+
+    /// Return an `Arc` around the `ObjectType` from our internal cache
+    ///
+    /// # Panics
+    /// If `obj_type` is not part of this schema, this function panics
+    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")
+            .cheap_clone()
+    }
+
+    pub fn get_named_type(&self, name: &str) -> Option<&s::TypeDefinition> {
+        self.schema.document.get_named_type(name)
+    }
+
+    /// Returns true if the given type is an input type.
+    ///
+    /// Uses the algorithm outlined on
+    /// https://facebook.github.io/graphql/draft/#IsInputType().
+    pub fn is_input_type(&self, t: &s::Type) -> bool {
+        match t {
+            s::Type::NamedType(name) => {
+                let named_type = self.get_named_type(name);
+                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),
+            s::Type::NonNullType(inner) => self.is_input_type(inner),
+        }
+    }
+
+    pub fn get_root_query_type_def(&self) -> Option<&s::TypeDefinition> {
+        self.schema
+            .document
+            .definitions
+            .iter()
+            .find_map(|d| match d {
+                s::Definition::TypeDefinition(def @ s::TypeDefinition::Object(_)) => match def {
+                    s::TypeDefinition::Object(t) if t.name == "Query" => Some(def),
+                    _ => None,
+                },
+                _ => None,
+            })
+    }
+
+    pub fn object_or_interface(&self, name: &str) -> Option<ObjectOrInterface<'_>> {
+        if name.starts_with("__") {
+            INTROSPECTION_SCHEMA.object_or_interface(name)
+        } else {
+            self.schema.document.object_or_interface(name)
+        }
+    }
+
+    /// Returns the type definition that a field type corresponds to.
+    pub fn get_type_definition_from_field<'a>(
+        &'a self,
+        field: &s::Field,
+    ) -> Option<&'a s::TypeDefinition> {
+        self.get_type_definition_from_type(&field.field_type)
+    }
+
+    /// Returns the type definition for a type.
+    pub fn get_type_definition_from_type<'a>(
+        &'a self,
+        t: &s::Type,
+    ) -> Option<&'a s::TypeDefinition> {
+        match t {
+            s::Type::NamedType(name) => self.get_named_type(name),
+            s::Type::ListType(inner) => self.get_type_definition_from_type(inner),
+            s::Type::NonNullType(inner) => self.get_type_definition_from_type(inner),
+        }
+    }
+
+    #[cfg(debug_assertions)]
+    pub fn definitions(&self) -> impl Iterator<Item = &s::Definition> {
+        self.schema.document.definitions.iter()
+    }
+}
+
+lazy_static! {
+    static ref INTROSPECTION_SCHEMA: s::Document = {
+        let schema = include_str!("introspection.graphql");
+        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
+            .get_root_query_type()
+            .expect("Schema does not have a root query type");
+        ast::ObjectType::from(Arc::new(root_query_type.clone()))
+    };
+}
+
+pub fn is_introspection_field(name: &str) -> bool {
+    INTROSPECTION_QUERY_TYPE.field(name).is_some()
+}
+
+/// Extend `schema` with the definitions from the introspection schema and
+/// modify the root query type to contain the fields from the introspection
+/// schema's root query type.
+///
+/// This results in a schema that combines the original schema with the
+/// introspection schema
+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:
+        //
+        // type Query {
+        //   __schema: __Schema!
+        //   __type(name: String!): __Type
+        // }
+
+        let type_args = vec![s::InputValue {
+            position: q::Pos::default(),
+            description: None,
+            name: "name".to_string(),
+            value_type: s::Type::NonNullType(Box::new(s::Type::NamedType("String".to_string()))),
+            default_value: None,
+            directives: vec![],
+        }];
+
+        vec![
+            s::Field {
+                position: q::Pos::default(),
+                description: None,
+                name: "__schema".to_string(),
+                arguments: vec![],
+                field_type: s::Type::NonNullType(Box::new(s::Type::NamedType(
+                    "__Schema".to_string(),
+                ))),
+                directives: vec![],
+            },
+            s::Field {
+                position: q::Pos::default(),
+                description: None,
+                name: "__type".to_string(),
+                arguments: type_args,
+                field_type: s::Type::NamedType("__Type".to_string()),
+                directives: vec![],
+            },
+        ]
+    }
+
+    // Add all definitions from the introspection schema to the schema,
+    // except for the root query type as that qould clobber the 'real' root
+    // query type
+    schema.definitions.extend(
+        INTROSPECTION_SCHEMA
+            .definitions
+            .iter()
+            .filter(|dfn| !dfn.is_root_query_type())
+            .cloned(),
+    );
+
+    let query_type = schema
+        .definitions
+        .iter_mut()
+        .filter_map(|d| match d {
+            s::Definition::TypeDefinition(s::TypeDefinition::Object(t)) if t.name == "Query" => {
+                Some(t)
+            }
+            _ => None,
+        })
+        .peekable()
+        .next()
+        .expect("no root `Query` in the schema");
+    query_type.fields.append(&mut introspection_fields());
+}
+
+/// Derives a full-fledged GraphQL API schema from an input schema.
+///
+/// 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: &InputSchema,
+) -> Result<s::Document, APISchemaError> {
+    // Refactor: Don't clone the schema.
+    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);
+            }
+        }
+    }
+
+    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 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: s::Document = {
+            let schema = include_str!("meta.graphql");
+            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")
+        };
+    }
+
+    api.definitions
+        .extend(META_FIELD_SCHEMA.definitions.iter().cloned());
+    api.definitions
+        .extend(LOGS_FIELD_SCHEMA.definitions.iter().cloned());
+}
+
+fn add_types_for_object_types(
+    api: &mut Schema,
+    schema: &InputSchema,
+) -> Result<(), APISchemaError> {
+    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(
+    api: &mut Schema,
+    input_schema: &InputSchema,
+) -> Result<(), APISchemaError> {
+    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(
+    api: &mut s::Document,
+    type_name: &str,
+    fields: &[Field],
+) -> Result<(), APISchemaError> {
+    let type_name = format!("{}_orderBy", type_name);
+
+    match api.get_named_type(&type_name) {
+        None => {
+            let typedef = s::TypeDefinition::Enum(s::EnumType {
+                position: q::Pos::default(),
+                description: None,
+                name: type_name,
+                directives: vec![],
+                values: field_enum_values(api, fields)?,
+            });
+            let def = s::Definition::TypeDefinition(typedef);
+            api.definitions.push(def);
+        }
+        Some(_) => return Err(APISchemaError::TypeExists(type_name)),
+    }
+    Ok(())
+}
+
+/// Generates enum values for the given set of fields.
+fn field_enum_values(
+    schema: &s::Document,
+    fields: &[Field],
+) -> Result<Vec<s::EnumValue>, APISchemaError> {
+    let mut enum_values = vec![];
+    for field in fields {
+        enum_values.push(s::EnumValue {
+            position: q::Pos::default(),
+            description: None,
+            name: field.name.to_string(),
+            directives: vec![],
+        });
+        enum_values.extend(field_enum_values_from_child_entity(schema, field)?);
+    }
+    Ok(enum_values)
+}
+
+fn enum_value_from_child_entity_field(
+    schema: &s::Document,
+    parent_field_name: &str,
+    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(s::EnumValue {
+            position: q::Pos::default(),
+            description: None,
+            name: format!("{}__{}", parent_field_name, field.name),
+            directives: vec![],
+        })
+    }
+}
+
+fn field_enum_values_from_child_entity(
+    schema: &s::Document,
+    field: &Field,
+) -> Result<Vec<s::EnumValue>, APISchemaError> {
+    fn resolve_supported_type_name(field_type: &s::Type) -> Option<&String> {
+        match field_type {
+            s::Type::NamedType(name) => Some(name),
+            s::Type::ListType(_) => None,
+            s::Type::NonNullType(of_type) => resolve_supported_type_name(of_type),
+        }
+    }
+
+    let type_name = match ENV_VARS.graphql.disable_child_sorting {
+        true => None,
+        false => resolve_supported_type_name(&field.field_type),
+    };
+
+    Ok(match type_name {
+        Some(name) => {
+            let named_type = schema
+                .get_named_type(name)
+                .ok_or_else(|| APISchemaError::TypeNotFound(name.clone()))?;
+            match named_type {
+                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)
+                    })
+                    .collect(),
+                _ => vec![],
+            }
+        }
+        None => vec![],
+    })
+}
+
+/// 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(
+    api: &mut Schema,
+    type_name: &str,
+    fields: &[Field],
+) -> 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, fields, FilterOps::Object)?;
+
+    let defn = filter_type_defn(filter_type_name, filter_fields);
+    api.document.definitions.push(defn);
+
+    Ok(())
+}
+
+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(())
+}
+
+/// Generates `*_filter` input values for the given set of fields.
+fn field_input_values(
+    schema: &Schema,
+    fields: &[Field],
+    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, ops)?);
+    }
+    Ok(input_values)
+}
+
+/// Generates `*_filter` input values for the given field.
+fn field_filter_input_values(
+    schema: &Schema,
+    field: &Field,
+    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: &s::TypeDefinition,
+) -> Result<Option<s::ScalarType>, APISchemaError> {
+    let id_type = match typedef {
+        s::TypeDefinition::Object(obj_type) => IdType::try_from(obj_type)
+            .map(Option::Some)
+            .map_err(|_| APISchemaError::IllegalIdType(obj_type.name.to_owned())),
+        s::TypeDefinition::Interface(intf_type) => {
+            match schema
+                .types_for_interface
+                .get(&intf_type.name)
+                .and_then(|obj_types| obj_types.first())
+            {
+                None => Ok(Some(IdType::String)),
+                Some(obj_type) => IdType::try_from(obj_type)
+                    .map(Option::Some)
+                    .map_err(|_| APISchemaError::IllegalIdType(obj_type.name.to_owned())),
+            }
+        }
+        _ => Ok(None),
+    }?;
+    let scalar_type = id_type.map(|id_type| match id_type {
+        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 => s::ScalarType::new(String::from("Int")),
+    });
+    Ok(scalar_type)
+}
+
+fn field_filter_ops(set: FilterOpsSet<'_>) -> &'static [&'static str] {
+    use FilterOpsSet::*;
+
+    match set {
+        Object("Boolean") => &["", "not", "in", "not_in"],
+        Object("Bytes") => &[
+            "",
+            "not",
+            "gt",
+            "lt",
+            "gte",
+            "lte",
+            "in",
+            "not_in",
+            "contains",
+            "not_contains",
+        ],
+        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",
+            "lt",
+            "gte",
+            "lte",
+            "in",
+            "not_in",
+            "contains",
+            "contains_nocase",
+            "not_contains",
+            "not_contains_nocase",
+            "starts_with",
+            "starts_with_nocase",
+            "not_starts_with",
+            "not_starts_with_nocase",
+            "ends_with",
+            "ends_with_nocase",
+            "not_ends_with",
+            "not_ends_with_nocase",
+        ],
+        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: &str,
+    input_values: &mut Vec<s::InputValue>,
+) {
+    input_values.push(input_value(
+        &format!("{}_", field.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: &s::Document,
+    field: &Field,
+    field_type: &s::EnumType,
+) -> Vec<s::InputValue> {
+    vec!["", "not", "in", "not_in"]
+        .into_iter()
+        .map(|filter_type| {
+            let field_type = s::Type::NamedType(field_type.name.clone());
+            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()
+}
+
+/// 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,
+) -> 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.field_type) {
+        Some(typedef) => typedef,
+        None => return Ok(None),
+    };
+
+    // Decide what type of values can be passed to the filter. In the case
+    // one-to-many or many-to-many object or interface fields that are not
+    // 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 {
+        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 = s::Type::NamedType(scalar_type.name);
+                (Some(named_type), Some(name.clone()))
+            }
+        }
+        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<s::InputValue> = match input_field_type {
+        None => {
+            vec![]
+        }
+        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 {
+        extend_with_child_filter_input_value(field, &parent, &mut input_values);
+    }
+
+    Ok(Some(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: s::Type) -> s::InputValue {
+    s::InputValue {
+        position: q::Pos::default(),
+        description: None,
+        name: if suffix.is_empty() {
+            name.to_owned()
+        } else {
+            format!("{}_{}", name, suffix)
+        },
+        value_type,
+        default_value: None,
+        directives: vec![],
+    }
+}
+
+/// Adds a root `Query` object type to the schema.
+fn add_query_type(api: &mut s::Document, input_schema: &InputSchema) -> Result<(), APISchemaError> {
+    let type_name = String::from("Query");
+
+    if api.get_named_type(&type_name).is_some() {
+        return Err(APISchemaError::TypeExists(type_name));
+    }
+
+    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 = s::TypeDefinition::Object(s::ObjectType {
+        position: q::Pos::default(),
+        description: None,
+        name: type_name,
+        implements_interfaces: vec![],
+        directives: vec![],
+        fields,
+    });
+    let def = s::Definition::TypeDefinition(typedef);
+    api.definitions.push(def);
+    Ok(())
+}
+
+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();
+    // Only one include is allowed per fulltext directive
+    let include = includes.iter().next().unwrap();
+    let included_entity = include.as_object().unwrap();
+    let entity_name = included_entity.get("entity").unwrap().as_str().unwrap();
+
+    let mut arguments = vec![
+        // text: String
+        s::InputValue {
+            position: q::Pos::default(),
+            description: None,
+            name: String::from("text"),
+            value_type: s::Type::NonNullType(Box::new(s::Type::NamedType(String::from("String")))),
+            default_value: None,
+            directives: vec![],
+        },
+        // first: Int
+        s::InputValue {
+            position: q::Pos::default(),
+            description: None,
+            name: String::from("first"),
+            value_type: s::Type::NamedType(String::from("Int")),
+            default_value: Some(s::Value::Int(100.into())),
+            directives: vec![],
+        },
+        // skip: Int
+        s::InputValue {
+            position: q::Pos::default(),
+            description: None,
+            name: String::from("skip"),
+            value_type: s::Type::NamedType(String::from("Int")),
+            default_value: Some(s::Value::Int(0.into())),
+            directives: vec![],
+        },
+        // block: BlockHeight
+        block_argument(),
+        input_value(
+            "where",
+            "",
+            s::Type::NamedType(format!("{}_filter", entity_name)),
+        ),
+    ];
+
+    arguments.push(subgraph_error_argument());
+
+    Some(s::Field {
+        position: q::Pos::default(),
+        description: None,
+        name,
+        arguments,
+        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()],
+    })
+}
+
+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, \
+             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."
+                .to_owned(),
+        ),
+        name: "block".to_string(),
+        value_type: s::Type::NamedType(BLOCK_HEIGHT.to_owned()),
+        default_value: None,
+        directives: vec![],
+    }
+}
+
+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: s::Type::NamedType(CHANGE_BLOCK_FILTER_NAME.to_owned()),
+        default_value: None,
+        directives: vec![],
+    }
+}
+
+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: 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, 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![
+        s::InputValue {
+            position: q::Pos::default(),
+            description: None,
+            name: "id".to_string(),
+            value_type: s::Type::NonNullType(Box::new(s::Type::NamedType("ID".to_string()))),
+            default_value: None,
+            directives: vec![],
+        },
+        block_argument(),
+    ];
+
+    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![
+        s::Field {
+            position: q::Pos::default(),
+            description: None,
+            name: singular,
+            arguments: by_id_arguments,
+            field_type: s::Type::NamedType(type_name.to_owned()),
+            directives: vec![],
+        },
+        s::Field {
+            position: q::Pos::default(),
+            description: None,
+            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 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: 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
+                s::InputValue {
+                    position: q::Pos::default(),
+                    description: None,
+                    name: String::from("block"),
+                    value_type: s::Type::NamedType(BLOCK_HEIGHT.to_string()),
+                    default_value: None,
+                    directives: vec![],
+                },
+            ],
+            field_type: s::Type::NamedType(META_FIELD_TYPE.to_string()),
+            directives: vec![],
+        };
+    }
+    META_FIELD.clone()
+}
+
+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![],
+        };
+    }
+    LOGS_FIELD.clone()
+}
+
+#[cfg(test)]
+mod tests {
+    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;
+    use crate::schema::ast;
+
+    lazy_static! {
+        static ref ID: DeploymentHash = DeploymentHash::new("apiTest").unwrap();
+    }
+
+    #[track_caller]
+    fn parse(raw: &str) -> ApiSchema {
+        let input_schema = InputSchema::parse(LATEST_VERSION, raw, ID.clone())
+            .expect("Failed to parse input schema");
+        input_schema
+            .api_schema()
+            .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! }");
+
+        schema
+            .get_named_type("Boolean")
+            .expect("Boolean type is missing in API schema");
+        schema
+            .get_named_type("ID")
+            .expect("ID type is missing in API schema");
+        schema
+            .get_named_type("Int")
+            .expect("Int type is missing in API schema");
+        schema
+            .get_named_type("BigDecimal")
+            .expect("BigDecimal type is missing in API schema");
+        schema
+            .get_named_type("String")
+            .expect("String type is missing in API schema");
+        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]
+    fn api_schema_contains_order_direction_enum() {
+        let schema = parse("type User @entity { id: ID!, name: String! }");
+
+        let order_direction = schema
+            .get_named_type("OrderDirection")
+            .expect("OrderDirection type is missing in derived API schema");
+        let enum_type = match order_direction {
+            s::TypeDefinition::Enum(t) => Some(t),
+            _ => None,
+        }
+        .expect("OrderDirection type is not an enum");
+
+        let values: Vec<&str> = enum_type
+            .values
+            .iter()
+            .map(|value| value.name.as_str())
+            .collect();
+        assert_eq!(values, ["asc", "desc"]);
+    }
+
+    #[test]
+    fn api_schema_contains_query_type() {
+        let schema = parse("type User @entity { id: ID! }");
+        schema
+            .get_named_type("Query")
+            .expect("Root Query type is missing in API schema");
+    }
+
+    #[test]
+    fn api_schema_contains_field_order_by_enum() {
+        let schema = parse("type User @entity { id: ID!, name: String! }");
+
+        let user_order_by = schema
+            .get_named_type("User_orderBy")
+            .expect("User_orderBy type is missing in derived API schema");
+
+        let enum_type = match user_order_by {
+            s::TypeDefinition::Enum(t) => Some(t),
+            _ => None,
+        }
+        .expect("User_orderBy type is not an enum");
+
+        let values: Vec<&str> = enum_type
+            .values
+            .iter()
+            .map(|value| value.name.as_str())
+            .collect();
+        assert_eq!(values, ["id", "name"]);
+    }
+
+    #[test]
+    fn api_schema_contains_field_order_by_enum_for_child_entity() {
+        let schema = parse(
+            r#"
+              enum FurType {
+                  NONE
+                  FLUFFY
+                  BRISTLY
+              }
+
+              type Pet @entity {
+                  id: ID!
+                  name: String!
+                  mostHatedBy: [User!]!
+                  mostLovedBy: [User!]!
+              }
+
+              interface Recipe {
+                id: ID!
+                name: String!
+                author: User!
+                lovedBy: [User!]!
+                ingredients: [String!]!
+              }
+
+              type FoodRecipe implements Recipe @entity {
+                id: ID!
+                name: String!
+                author: User!
+                lovedBy: [User!]!
+                ingredients: [String!]!
+              }
+
+              type DrinkRecipe implements Recipe @entity {
+                id: ID!
+                name: String!
+                author: User!
+                lovedBy: [User!]!
+                ingredients: [String!]!
+              }
+
+              interface Meal {
+                id: ID!
+                name: String!
+                mostHatedBy: [User!]!
+                mostLovedBy: [User!]!
+              }
+
+              type Pizza implements Meal @entity {
+                id: ID!
+                name: String!
+                toppings: [String!]!
+                mostHatedBy: [User!]!
+                mostLovedBy: [User!]!
+              }
+
+              type Burger implements Meal @entity {
+                id: ID!
+                name: String!
+                bun: String!
+                mostHatedBy: [User!]!
+                mostLovedBy: [User!]!
+              }
+
+              type User @entity {
+                  id: ID!
+                  name: String!
+                  favoritePetNames: [String!]
+                  pets: [Pet!]!
+                  favoriteFurType: FurType!
+                  favoritePet: Pet!
+                  leastFavoritePet: Pet @derivedFrom(field: "mostHatedBy")
+                  mostFavoritePets: [Pet!] @derivedFrom(field: "mostLovedBy")
+                  favoriteMeal: Meal!
+                  leastFavoriteMeal: Meal @derivedFrom(field: "mostHatedBy")
+                  mostFavoriteMeals: [Meal!] @derivedFrom(field: "mostLovedBy")
+                  recipes: [Recipe!]! @derivedFrom(field: "author")
+              }
+            "#,
+        );
+
+        let user_order_by = schema
+            .get_named_type("User_orderBy")
+            .expect("User_orderBy type is missing in derived API schema");
+
+        let enum_type = match user_order_by {
+            s::TypeDefinition::Enum(t) => Some(t),
+            _ => None,
+        }
+        .expect("User_orderBy type is not an enum");
+
+        let values: Vec<&str> = enum_type
+            .values
+            .iter()
+            .map(|value| value.name.as_str())
+            .collect();
+
+        assert_eq!(
+            values,
+            [
+                "id",
+                "name",
+                "favoritePetNames",
+                "pets",
+                "favoriteFurType",
+                "favoritePet",
+                "favoritePet__id",
+                "favoritePet__name",
+                "leastFavoritePet",
+                "leastFavoritePet__id",
+                "leastFavoritePet__name",
+                "mostFavoritePets",
+                "favoriteMeal",
+                "favoriteMeal__id",
+                "favoriteMeal__name",
+                "leastFavoriteMeal",
+                "leastFavoriteMeal__id",
+                "leastFavoriteMeal__name",
+                "mostFavoriteMeals",
+                "recipes",
+            ]
+        );
+
+        let meal_order_by = schema
+            .get_named_type("Meal_orderBy")
+            .expect("Meal_orderBy type is missing in derived API schema");
+
+        let enum_type = match meal_order_by {
+            s::TypeDefinition::Enum(t) => Some(t),
+            _ => None,
+        }
+        .expect("Meal_orderBy type is not an enum");
+
+        let values: Vec<&str> = enum_type
+            .values
+            .iter()
+            .map(|value| value.name.as_str())
+            .collect();
+
+        assert_eq!(values, ["id", "name", "mostHatedBy", "mostLovedBy",]);
+
+        let recipe_order_by = schema
+            .get_named_type("Recipe_orderBy")
+            .expect("Recipe_orderBy type is missing in derived API schema");
+
+        let enum_type = match recipe_order_by {
+            s::TypeDefinition::Enum(t) => Some(t),
+            _ => None,
+        }
+        .expect("Recipe_orderBy type is not an enum");
+
+        let values: Vec<&str> = enum_type
+            .values
+            .iter()
+            .map(|value| value.name.as_str())
+            .collect();
+
+        assert_eq!(
+            values,
+            [
+                "id",
+                "name",
+                "author",
+                "author__id",
+                "author__name",
+                "author__favoriteFurType",
+                "lovedBy",
+                "ingredients"
+            ]
+        );
+    }
+
+    #[test]
+    fn api_schema_contains_object_type_filter_enum() {
+        let schema = parse(
+            r#"
+              enum FurType {
+                  NONE
+                  FLUFFY
+                  BRISTLY
+              }
+
+              type Pet @entity {
+                  id: ID!
+                  name: String!
+                  mostHatedBy: [User!]!
+                  mostLovedBy: [User!]!
+              }
+
+              type User @entity {
+                  id: ID!
+                  name: String!
+                  favoritePetNames: [String!]
+                  pets: [Pet!]!
+                  favoriteFurType: FurType!
+                  favoritePet: Pet!
+                  leastFavoritePet: Pet @derivedFrom(field: "mostHatedBy")
+                  mostFavoritePets: [Pet!] @derivedFrom(field: "mostLovedBy")
+              }
+            "#,
+        );
+
+        let user_filter = schema
+            .get_named_type("User_filter")
+            .expect("User_filter type is missing in derived API schema");
+
+        let user_filter_type = match user_filter {
+            s::TypeDefinition::InputObject(t) => Some(t),
+            _ => None,
+        }
+        .expect("User_filter type is not an input object");
+
+        assert_eq!(
+            user_filter_type
+                .fields
+                .iter()
+                .map(|field| field.name.clone())
+                .collect::<Vec<String>>(),
+            [
+                "id",
+                "id_not",
+                "id_gt",
+                "id_lt",
+                "id_gte",
+                "id_lte",
+                "id_in",
+                "id_not_in",
+                "name",
+                "name_not",
+                "name_gt",
+                "name_lt",
+                "name_gte",
+                "name_lte",
+                "name_in",
+                "name_not_in",
+                "name_contains",
+                "name_contains_nocase",
+                "name_not_contains",
+                "name_not_contains_nocase",
+                "name_starts_with",
+                "name_starts_with_nocase",
+                "name_not_starts_with",
+                "name_not_starts_with_nocase",
+                "name_ends_with",
+                "name_ends_with_nocase",
+                "name_not_ends_with",
+                "name_not_ends_with_nocase",
+                "favoritePetNames",
+                "favoritePetNames_not",
+                "favoritePetNames_contains",
+                "favoritePetNames_contains_nocase",
+                "favoritePetNames_not_contains",
+                "favoritePetNames_not_contains_nocase",
+                "pets",
+                "pets_not",
+                "pets_contains",
+                "pets_contains_nocase",
+                "pets_not_contains",
+                "pets_not_contains_nocase",
+                "pets_",
+                "favoriteFurType",
+                "favoriteFurType_not",
+                "favoriteFurType_in",
+                "favoriteFurType_not_in",
+                "favoritePet",
+                "favoritePet_not",
+                "favoritePet_gt",
+                "favoritePet_lt",
+                "favoritePet_gte",
+                "favoritePet_lte",
+                "favoritePet_in",
+                "favoritePet_not_in",
+                "favoritePet_contains",
+                "favoritePet_contains_nocase",
+                "favoritePet_not_contains",
+                "favoritePet_not_contains_nocase",
+                "favoritePet_starts_with",
+                "favoritePet_starts_with_nocase",
+                "favoritePet_not_starts_with",
+                "favoritePet_not_starts_with_nocase",
+                "favoritePet_ends_with",
+                "favoritePet_ends_with_nocase",
+                "favoritePet_not_ends_with",
+                "favoritePet_not_ends_with_nocase",
+                "favoritePet_",
+                "leastFavoritePet_",
+                "mostFavoritePets_",
+                "_change_block",
+                "and",
+                "or"
+            ]
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<String>>()
+        );
+
+        let pets_field = user_filter_type
+            .fields
+            .iter()
+            .find(|field| field.name == "pets_")
+            .expect("pets_ field is missing");
+
+        assert_eq!(
+            pets_field.value_type.to_string(),
+            String::from("Pet_filter")
+        );
+
+        let pet_filter = schema
+            .get_named_type("Pet_filter")
+            .expect("Pet_filter type is missing in derived API schema");
+
+        let pet_filter_type = match pet_filter {
+            s::TypeDefinition::InputObject(t) => Some(t),
+            _ => None,
+        }
+        .expect("Pet_filter type is not an input object");
+
+        assert_eq!(
+            pet_filter_type
+                .fields
+                .iter()
+                .map(|field| field.name.clone())
+                .collect::<Vec<String>>(),
+            [
+                "id",
+                "id_not",
+                "id_gt",
+                "id_lt",
+                "id_gte",
+                "id_lte",
+                "id_in",
+                "id_not_in",
+                "name",
+                "name_not",
+                "name_gt",
+                "name_lt",
+                "name_gte",
+                "name_lte",
+                "name_in",
+                "name_not_in",
+                "name_contains",
+                "name_contains_nocase",
+                "name_not_contains",
+                "name_not_contains_nocase",
+                "name_starts_with",
+                "name_starts_with_nocase",
+                "name_not_starts_with",
+                "name_not_starts_with_nocase",
+                "name_ends_with",
+                "name_ends_with_nocase",
+                "name_not_ends_with",
+                "name_not_ends_with_nocase",
+                "mostHatedBy",
+                "mostHatedBy_not",
+                "mostHatedBy_contains",
+                "mostHatedBy_contains_nocase",
+                "mostHatedBy_not_contains",
+                "mostHatedBy_not_contains_nocase",
+                "mostHatedBy_",
+                "mostLovedBy",
+                "mostLovedBy_not",
+                "mostLovedBy_contains",
+                "mostLovedBy_contains_nocase",
+                "mostLovedBy_not_contains",
+                "mostLovedBy_not_contains_nocase",
+                "mostLovedBy_",
+                "_change_block",
+                "and",
+                "or"
+            ]
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<String>>()
+        );
+
+        let change_block_filter = user_filter_type
+            .fields
+            .iter()
+            .find(|p| p.name == "_change_block")
+            .expect("_change_block field is missing in User_filter");
+
+        match &change_block_filter.value_type {
+            s::Type::NamedType(name) => assert_eq!(name.as_str(), "BlockChangedFilter"),
+            _ => panic!("_change_block field is not a named type"),
+        }
+
+        schema
+            .get_named_type("BlockChangedFilter")
+            .expect("BlockChangedFilter type is missing in derived API schema");
+    }
+
+    #[test]
+    fn api_schema_contains_object_type_with_field_interface() {
+        let schema = parse(
+            r#"
+              interface Pet {
+                  id: ID!
+                  name: String!
+                  owner: User!
+              }
+
+              type Dog implements Pet @entity {
+                id: ID!
+                name: String!
+                owner: User!
+            }
+
+              type Cat implements Pet @entity {
+                id: ID!
+                name: String!
+                owner: User!
+              }
+
+              type User @entity {
+                  id: ID!
+                  name: String!
+                  pets: [Pet!]! @derivedFrom(field: "owner")
+                  favoritePet: Pet!
+              }
+            "#,
+        );
+
+        let user_filter = schema
+            .get_named_type("User_filter")
+            .expect("User_filter type is missing in derived API schema");
+
+        let user_filter_type = match user_filter {
+            s::TypeDefinition::InputObject(t) => Some(t),
+            _ => None,
+        }
+        .expect("User_filter type is not an input object");
+
+        assert_eq!(
+            user_filter_type
+                .fields
+                .iter()
+                .map(|field| field.name.clone())
+                .collect::<Vec<String>>(),
+            [
+                "id",
+                "id_not",
+                "id_gt",
+                "id_lt",
+                "id_gte",
+                "id_lte",
+                "id_in",
+                "id_not_in",
+                "name",
+                "name_not",
+                "name_gt",
+                "name_lt",
+                "name_gte",
+                "name_lte",
+                "name_in",
+                "name_not_in",
+                "name_contains",
+                "name_contains_nocase",
+                "name_not_contains",
+                "name_not_contains_nocase",
+                "name_starts_with",
+                "name_starts_with_nocase",
+                "name_not_starts_with",
+                "name_not_starts_with_nocase",
+                "name_ends_with",
+                "name_ends_with_nocase",
+                "name_not_ends_with",
+                "name_not_ends_with_nocase",
+                "pets_",
+                "favoritePet",
+                "favoritePet_not",
+                "favoritePet_gt",
+                "favoritePet_lt",
+                "favoritePet_gte",
+                "favoritePet_lte",
+                "favoritePet_in",
+                "favoritePet_not_in",
+                "favoritePet_contains",
+                "favoritePet_contains_nocase",
+                "favoritePet_not_contains",
+                "favoritePet_not_contains_nocase",
+                "favoritePet_starts_with",
+                "favoritePet_starts_with_nocase",
+                "favoritePet_not_starts_with",
+                "favoritePet_not_starts_with_nocase",
+                "favoritePet_ends_with",
+                "favoritePet_ends_with_nocase",
+                "favoritePet_not_ends_with",
+                "favoritePet_not_ends_with_nocase",
+                "favoritePet_",
+                "_change_block",
+                "and",
+                "or"
+            ]
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<String>>()
+        );
+
+        let change_block_filter = user_filter_type
+            .fields
+            .iter()
+            .find(|p| p.name == "_change_block")
+            .expect("_change_block field is missing in User_filter");
+
+        match &change_block_filter.value_type {
+            s::Type::NamedType(name) => assert_eq!(name.as_str(), "BlockChangedFilter"),
+            _ => panic!("_change_block field is not a named type"),
+        }
+
+        schema
+            .get_named_type("BlockChangedFilter")
+            .expect("BlockChangedFilter type is missing in derived API schema");
+    }
+
+    #[test]
+    fn api_schema_contains_object_fields_on_query_type() {
+        let schema = parse(
+            "type User @entity { id: ID!, name: String! } type UserProfile @entity { id: ID!, title: String! }",
+        );
+
+        let query_type = schema
+            .get_named_type("Query")
+            .expect("Query type is missing in derived API schema");
+
+        let user_singular_field = match query_type {
+            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,
+            s::Type::NamedType("User".to_string())
+        );
+
+        assert_eq!(
+            user_singular_field
+                .arguments
+                .iter()
+                .map(|input_value| input_value.name.clone())
+                .collect::<Vec<String>>(),
+            vec![
+                "id".to_string(),
+                "block".to_string(),
+                "subgraphError".to_string()
+            ],
+        );
+
+        let user_plural_field = match query_type {
+            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,
+            s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(s::Type::NonNullType(
+                Box::new(s::Type::NamedType("User".to_string()))
+            )))))
+        );
+
+        assert_eq!(
+            user_plural_field
+                .arguments
+                .iter()
+                .map(|input_value| input_value.name.clone())
+                .collect::<Vec<String>>(),
+            [
+                "skip",
+                "first",
+                "orderBy",
+                "orderDirection",
+                "where",
+                "block",
+                "subgraphError",
+            ]
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<String>>()
+        );
+
+        let user_profile_singular_field = match query_type {
+            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,
+            s::Type::NamedType("UserProfile".to_string())
+        );
+
+        let user_profile_plural_field = match query_type {
+            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,
+            s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(s::Type::NonNullType(
+                Box::new(s::Type::NamedType("UserProfile".to_string()))
+            )))))
+        );
+    }
+
+    #[test]
+    fn api_schema_contains_interface_fields_on_query_type() {
+        let schema = parse(
+            "
+            interface Node { id: ID!, name: String! }
+            type User implements Node @entity { id: ID!, name: String!, email: String }
+            ",
+        );
+
+        let query_type = schema
+            .get_named_type("Query")
+            .expect("Query type is missing in derived API schema");
+
+        let singular_field = match query_type {
+            s::TypeDefinition::Object(t) => ast::get_field(t, "node"),
+            _ => None,
+        }
+        .expect("\"node\" field is missing on Query type");
+
+        assert_eq!(
+            singular_field.field_type,
+            s::Type::NamedType("Node".to_string())
+        );
+
+        assert_eq!(
+            singular_field
+                .arguments
+                .iter()
+                .map(|input_value| input_value.name.clone())
+                .collect::<Vec<String>>(),
+            vec![
+                "id".to_string(),
+                "block".to_string(),
+                "subgraphError".to_string()
+            ],
+        );
+
+        let plural_field = match query_type {
+            s::TypeDefinition::Object(t) => ast::get_field(t, "nodes"),
+            _ => None,
+        }
+        .expect("\"nodes\" field is missing on Query type");
+
+        assert_eq!(
+            plural_field.field_type,
+            s::Type::NonNullType(Box::new(s::Type::ListType(Box::new(s::Type::NonNullType(
+                Box::new(s::Type::NamedType("Node".to_string()))
+            )))))
+        );
+
+        assert_eq!(
+            plural_field
+                .arguments
+                .iter()
+                .map(|input_value| input_value.name.clone())
+                .collect::<Vec<String>>(),
+            [
+                "skip",
+                "first",
+                "orderBy",
+                "orderDirection",
+                "where",
+                "block",
+                "subgraphError"
+            ]
+            .iter()
+            .map(ToString::to_string)
+            .collect::<Vec<String>>()
+        );
+    }
+
+    #[test]
+    fn api_schema_contains_fulltext_query_field_on_query_type() {
+        const SCHEMA: &str = r#"
+type _Schema_ @fulltext(
+  name: "metadata"
+  language: en
+  algorithm: rank
+  include: [
+    {
+      entity: "Gravatar",
+      fields: [
+        { name: "displayName"},
+        { name: "imageUrl"},
+      ]
+    }
+  ]
+)
+type Gravatar @entity {
+  id: ID!
+  owner: Bytes!
+  displayName: String!
+  imageUrl: String!
+}
+"#;
+        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 {
+            s::TypeDefinition::Object(t) => ast::get_field(t, &String::from("metadata")),
+            _ => None,
+        }
+        .expect("\"metadata\" field is missing on Query type");
+    }
+
+    #[test]
+    fn intf_implements_intf() {
+        const SCHEMA: &str = r#"
+          interface Legged {
+            legs: Int!
+          }
+
+          interface Animal implements Legged {
+            id: Bytes!
+            legs: Int!
+          }
+
+          type Zoo @entity {
+            id: Bytes!
+            animals: [Animal!]
+          }
+          "#;
+        // This used to fail in API schema construction; we just want to
+        // make sure that generating an API schema works. The issue was that
+        // `Zoo.animals` has an interface type, and that interface
+        // implements another interface which we tried to look up as an
+        // 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/graphql/src/schema/ast.rs b/graph/src/schema/ast.rs
similarity index 81%
rename from graphql/src/schema/ast.rs
rename to graph/src/schema/ast.rs
index c78904fbe69..fc9b97430c0 100644
--- a/graphql/src/schema/ast.rs
+++ b/graph/src/schema/ast.rs
@@ -1,18 +1,17 @@
-use graph::cheap_clone::CheapClone;
-use graphql_parser::Pos;
 use lazy_static::lazy_static;
 use std::ops::Deref;
 use std::str::FromStr;
 use std::sync::Arc;
 
-use graph::data::graphql::ext::DirectiveFinder;
-use graph::data::graphql::{DocumentExt, ObjectOrInterface};
-use graph::prelude::anyhow::anyhow;
-use graph::prelude::{s, Error, ValueType};
+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::{Error, ValueType, s};
 
-use crate::query::ast as qast;
+use super::AsEntityTypeName;
 
-pub(crate) enum FilterOp {
+pub enum FilterOp {
     Not,
     GreaterThan,
     LessThan,
@@ -39,7 +38,7 @@ pub(crate) enum FilterOp {
 }
 
 /// Split a "name_eq" style name into an attribute ("name") and a filter op (`Equal`).
-pub(crate) fn parse_field_as_filter(key: &str) -> (String, FilterOp) {
+pub fn parse_field_as_filter(key: &str) -> (String, FilterOp) {
     let (suffix, op) = match key {
         k if k.ends_with("_not") => ("_not", FilterOp::Not),
         k if k.ends_with("_gt") => ("_gt", FilterOp::GreaterThan),
@@ -74,16 +73,16 @@ pub(crate) 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 {
@@ -94,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))
     }
 }
 
@@ -132,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 {
@@ -157,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),
@@ -170,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),
@@ -185,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()))),
@@ -208,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")),
     }
@@ -257,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()))),
@@ -299,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.
@@ -313,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),
@@ -329,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),
     }
@@ -355,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,
     }
 }
@@ -389,7 +388,7 @@ pub fn get_derived_from_field<'a>(
     field_definition: &'a s::Field,
 ) -> Option<&'a s::Field> {
     get_derived_from_directive(field_definition)
-        .and_then(|directive| qast::get_argument_value(&directive.arguments, "field"))
+        .and_then(|directive| directive.argument("field"))
         .and_then(|value| match value {
             s::Value::String(s) => Some(s),
             _ => None,
@@ -407,45 +406,44 @@ pub fn is_list(field_type: &s::Type) -> bool {
 
 #[test]
 fn entity_validation() {
-    use graph::components::store::EntityKey;
-    use graph::data::store;
-    use graph::prelude::{DeploymentHash, Entity};
+    use crate::data::store;
+    use crate::entity;
+    use crate::prelude::{DeploymentHash, Entity};
+    use crate::schema::{EntityType, InputSchema};
+
+    const DOCUMENT: &str = "
+    enum Color { red, yellow, blue }
+    interface Stuff { id: ID!, name: String! }
+    type Cruft @entity {
+        id: ID!,
+        thing: Thing!
+    }
+    type Thing @entity {
+        id: ID!,
+        name: String!,
+        favorite_color: Color,
+        stuff: Stuff,
+        things: [Thing!]!
+        # Make sure we do not validate derived fields; it's ok
+        # to store a thing with a null Cruft
+        cruft: Cruft! @derivedFrom(field: \"thing\")
+    }";
+
+    lazy_static! {
+        static ref SUBGRAPH: DeploymentHash = DeploymentHash::new("doesntmatter").unwrap();
+        static ref SCHEMA: InputSchema = InputSchema::raw(DOCUMENT, "doesntmatter");
+        static ref THING_TYPE: EntityType = SCHEMA.entity_type("Thing").unwrap();
+    }
 
     fn make_thing(name: &str) -> Entity {
-        let mut thing = Entity::new();
-        thing.set("id", name);
-        thing.set("name", name);
-        thing.set("stuff", "less");
-        thing.set("favorite_color", "red");
-        thing.set("things", store::Value::List(vec![]));
-        thing
+        entity! { SCHEMA => id: name, name: name, stuff: "less", favorite_color: "red", things: store::Value::List(vec![]) }
     }
 
     fn check(thing: Entity, errmsg: &str) {
-        const DOCUMENT: &str = "
-      enum Color { red, yellow, blue }
-      interface Stuff { id: ID!, name: String! }
-      type Cruft @entity {
-          id: ID!,
-          thing: Thing!
-      }
-      type Thing @entity {
-          id: ID!,
-          name: String!,
-          favorite_color: Color,
-          stuff: Stuff,
-          things: [Thing!]!
-          # Make sure we do not validate derived fields; it's ok
-          # to store a thing with a null Cruft
-          cruft: Cruft! @derivedFrom(field: \"thing\")
-      }";
-        let subgraph = DeploymentHash::new("doesntmatter").unwrap();
-        let schema =
-            graph::prelude::Schema::parse(DOCUMENT, subgraph).expect("Failed to parse test schema");
-        let id = thing.id().unwrap_or("none".to_owned());
-        let key = EntityKey::data("Thing".to_owned(), id.clone());
-
-        let err = thing.validate(&schema, &key);
+        let id = thing.id();
+        let key = THING_TYPE.key(id.clone());
+
+        let err = thing.validate(&key);
         if errmsg.is_empty() {
             assert!(
                 err.is_ok(),
@@ -464,7 +462,9 @@ fn entity_validation() {
     }
 
     let mut thing = make_thing("t1");
-    thing.set("things", store::Value::from(vec!["thing1", "thing2"]));
+    thing
+        .set("things", store::Value::from(vec!["thing1", "thing2"]))
+        .unwrap();
     check(thing, "");
 
     let thing = make_thing("t2");
@@ -485,7 +485,7 @@ fn entity_validation() {
     );
 
     let mut thing = make_thing("t5");
-    thing.set("name", store::Value::Int(32));
+    thing.set("name", store::Value::Int(32)).unwrap();
     check(
         thing,
         "Entity Thing[t5]: the value `32` for field `name` must \
@@ -493,10 +493,12 @@ fn entity_validation() {
     );
 
     let mut thing = make_thing("t6");
-    thing.set(
-        "things",
-        store::Value::List(vec!["thing1".into(), 17.into()]),
-    );
+    thing
+        .set(
+            "things",
+            store::Value::List(vec!["thing1".into(), 17.into()]),
+        )
+        .unwrap();
     check(
         thing,
         "Entity Thing[t6]: field `things` is of type [Thing!]!, \
@@ -509,9 +511,9 @@ fn entity_validation() {
     check(thing, "");
 
     let mut thing = make_thing("t8");
-    thing.set("cruft", "wat");
+    thing.set("cruft", "wat").unwrap();
     check(
         thing,
-        "Entity Thing[t8]: field `cruft` is derived and can not be set",
+        "Entity Thing[t8]: field `cruft` is derived and cannot be set",
     );
 }
diff --git a/graph/src/schema/entity_key.rs b/graph/src/schema/entity_key.rs
new file mode 100644
index 00000000000..3a5a8581a3c
--- /dev/null
+++ b/graph/src/schema/entity_key.rs
@@ -0,0 +1,75 @@
+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, CacheWeight, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[non_exhaustive]
+pub struct EntityKey {
+    /// Name of the entity type.
+    pub entity_type: EntityType,
+
+    /// ID of the individual entity.
+    pub entity_id: Id,
+
+    /// This is the causality region of the data source that created the entity.
+    ///
+    /// In the case of an entity lookup, this is the causality region of the data source that is
+    /// 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,
+}
+
+impl EntityKey {
+    pub fn unknown_attribute(&self, err: intern::Error) -> StoreError {
+        StoreError::UnknownAttribute(self.entity_type.to_string(), err.not_interned())
+    }
+}
+
+impl EntityKey {
+    pub(in crate::schema) fn new(
+        entity_type: EntityType,
+        entity_id: Id,
+        causality_region: CausalityRegion,
+    ) -> Self {
+        Self {
+            entity_type,
+            entity_id,
+            causality_region,
+        }
+    }
+
+    pub fn id_value(&self) -> Value {
+        Value::from(self.entity_id.clone())
+    }
+}
+
+impl std::fmt::Debug for EntityKey {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "EntityKey({}[{}], cr={})",
+            self.entity_type, self.entity_id, self.causality_region
+        )
+    }
+}
+
+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
new file mode 100644
index 00000000000..c46f68681c9
--- /dev/null
+++ b/graph/src/schema/entity_type.rs
@@ -0,0 +1,256 @@
+use std::{borrow::Borrow, fmt, sync::Arc};
+
+use anyhow::{Context, Error};
+
+use crate::{
+    cheap_clone::CheapClone,
+    data::store::{Id, IdList},
+    data::{graphql::ObjectOrInterface, store::IdType, value::Word},
+    data_source::causality_region::CausalityRegion,
+    prelude::s,
+    util::intern::Atom,
+};
+
+use super::{EntityKey, Field, InputSchema, InterfaceType, ObjectType, POI_OBJECT};
+
+use graph_derive::CheapClone;
+
+/// 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, CheapClone)]
+pub struct EntityType {
+    schema: InputSchema,
+    pub(in crate::schema) atom: Atom,
+}
+
+impl EntityType {
+    pub(in crate::schema) fn new(schema: InputSchema, atom: Atom) -> Self {
+        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
+    }
+
+    pub fn has_field(&self, field: Atom) -> bool {
+        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)
+    }
+
+    /// Return the object type for this entity type. It is an error to call
+    /// this if `entity_type` refers to an interface or an aggregation as
+    /// they don't have an underlying type that stores daa directly
+    pub fn object_type(&self) -> Result<&ObjectType, Error> {
+        self.schema.object_type(self.atom)
+    }
+
+    /// Create a key from this type for an onchain entity
+    pub fn key(&self, id: Id) -> EntityKey {
+        self.key_in(id, CausalityRegion::ONCHAIN)
+    }
+
+    /// Create a key from this type for an entity in the given causality region
+    pub fn key_in(&self, id: Id, causality_region: CausalityRegion) -> EntityKey {
+        EntityKey::new(self.cheap_clone(), id, causality_region)
+    }
+
+    /// Construct an `Id` from the given string and parse it into the
+    /// correct type if necessary
+    pub fn parse_id(&self, id: impl Into<Word>) -> Result<Id, Error> {
+        let id = id.into();
+        let id_type = self
+            .schema
+            .id_type(self.atom)
+            .with_context(|| format!("error determining id_type for {}[{}]", self.as_str(), id))?;
+        id_type.parse(id)
+    }
+
+    /// Construct an `IdList` from a list of given strings and parse them
+    /// into the correct type if necessary
+    pub fn parse_ids(&self, ids: Vec<impl Into<Word>>) -> Result<IdList, Error> {
+        let ids: Vec<_> = ids
+            .into_iter()
+            .map(|id| self.parse_id(id))
+            .collect::<Result<_, _>>()?;
+        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
+    /// entity from it
+    pub fn parse_key(&self, id: impl Into<Word>) -> Result<EntityKey, Error> {
+        let id_value = self.parse_id(id)?;
+        Ok(self.key(id_value))
+    }
+
+    /// Parse the given `id` into an `Id` and construct a key for an entity
+    /// in the give causality region from it
+    pub fn parse_key_in(
+        &self,
+        id: impl Into<Word>,
+        causality_region: CausalityRegion,
+    ) -> Result<EntityKey, Error> {
+        let id_value = self.parse_id(id.into())?;
+        Ok(self.key_in(id_value, causality_region))
+    }
+
+    fn same_pool(&self, other: &EntityType) -> bool {
+        Arc::ptr_eq(self.schema.pool(), other.schema.pool())
+    }
+
+    pub fn interfaces(&self) -> impl Iterator<Item = &InterfaceType> {
+        self.schema.interfaces(self.atom)
+    }
+
+    /// Return a list of all entity types that implement one of the
+    /// interfaces that `self` implements; the result does not include
+    /// `self`
+    pub fn share_interfaces(&self) -> Result<Vec<EntityType>, Error> {
+        self.schema.share_interfaces(self.atom)
+    }
+
+    /// 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()
+    }
+}
+
+impl fmt::Display for EntityType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.as_str())
+    }
+}
+
+impl Borrow<str> for EntityType {
+    fn borrow(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl std::fmt::Debug for EntityType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "EntityType({})", self.as_str())
+    }
+}
+
+impl PartialEq for EntityType {
+    fn eq(&self, other: &Self) -> bool {
+        if self.same_pool(other) && self.atom == other.atom {
+            return true;
+        }
+        self.as_str() == other.as_str()
+    }
+}
+
+impl Eq for EntityType {}
+
+impl PartialOrd for EntityType {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for EntityType {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.as_str().cmp(other.as_str())
+    }
+}
+
+impl std::hash::Hash for EntityType {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.as_str().hash(state)
+    }
+}
+
+/// A trait to mark types that can reasonably turned into the name of an
+/// entity type
+pub trait AsEntityTypeName {
+    fn name(&self) -> &str;
+}
+
+impl AsEntityTypeName for &str {
+    fn name(&self) -> &str {
+        self
+    }
+}
+
+impl AsEntityTypeName for &String {
+    fn name(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl AsEntityTypeName for &Word {
+    fn name(&self) -> &str {
+        self.as_str()
+    }
+}
+
+impl AsEntityTypeName for &s::ObjectType {
+    fn name(&self) -> &str {
+        &self.name
+    }
+}
+
+impl AsEntityTypeName for &s::InterfaceType {
+    fn name(&self) -> &str {
+        &self.name
+    }
+}
+
+impl AsEntityTypeName for ObjectOrInterface<'_> {
+    fn name(&self) -> &str {
+        match self {
+            ObjectOrInterface::Object(object) => &object.name,
+            ObjectOrInterface::Interface(interface) => &interface.name,
+        }
+    }
+}
diff --git a/graph/src/schema/fulltext.rs b/graph/src/schema/fulltext.rs
new file mode 100644
index 00000000000..074e843dce9
--- /dev/null
+++ b/graph/src/schema/fulltext.rs
@@ -0,0 +1,155 @@
+use std::collections::HashSet;
+use std::convert::TryFrom;
+
+use crate::data::graphql::{DirectiveExt, ValueExt};
+use crate::prelude::s;
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum FulltextLanguage {
+    Simple,
+    Danish,
+    Dutch,
+    English,
+    Finnish,
+    French,
+    German,
+    Hungarian,
+    Italian,
+    Norwegian,
+    Portugese,
+    Romanian,
+    Russian,
+    Spanish,
+    Swedish,
+    Turkish,
+}
+
+impl TryFrom<&str> for FulltextLanguage {
+    type Error = String;
+    fn try_from(language: &str) -> Result<Self, Self::Error> {
+        match language {
+            "simple" => Ok(FulltextLanguage::Simple),
+            "da" => Ok(FulltextLanguage::Danish),
+            "nl" => Ok(FulltextLanguage::Dutch),
+            "en" => Ok(FulltextLanguage::English),
+            "fi" => Ok(FulltextLanguage::Finnish),
+            "fr" => Ok(FulltextLanguage::French),
+            "de" => Ok(FulltextLanguage::German),
+            "hu" => Ok(FulltextLanguage::Hungarian),
+            "it" => Ok(FulltextLanguage::Italian),
+            "no" => Ok(FulltextLanguage::Norwegian),
+            "pt" => Ok(FulltextLanguage::Portugese),
+            "ro" => Ok(FulltextLanguage::Romanian),
+            "ru" => Ok(FulltextLanguage::Russian),
+            "es" => Ok(FulltextLanguage::Spanish),
+            "sv" => Ok(FulltextLanguage::Swedish),
+            "tr" => Ok(FulltextLanguage::Turkish),
+            invalid => Err(format!(
+                "Provided language for fulltext search is invalid: {}",
+                invalid
+            )),
+        }
+    }
+}
+
+impl FulltextLanguage {
+    /// Return the language as a valid SQL string. The string is safe to
+    /// directly use verbatim in a query, i.e., doesn't require being passed
+    /// through a bind variable
+    pub fn as_sql(&self) -> &'static str {
+        match self {
+            Self::Simple => "'simple'",
+            Self::Danish => "'danish'",
+            Self::Dutch => "'dutch'",
+            Self::English => "'english'",
+            Self::Finnish => "'finnish'",
+            Self::French => "'french'",
+            Self::German => "'german'",
+            Self::Hungarian => "'hungarian'",
+            Self::Italian => "'italian'",
+            Self::Norwegian => "'norwegian'",
+            Self::Portugese => "'portugese'",
+            Self::Romanian => "'romanian'",
+            Self::Russian => "'russian'",
+            Self::Spanish => "'spanish'",
+            Self::Swedish => "'swedish'",
+            Self::Turkish => "'turkish'",
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub enum FulltextAlgorithm {
+    Rank,
+    ProximityRank,
+}
+
+impl TryFrom<&str> for FulltextAlgorithm {
+    type Error = String;
+    fn try_from(algorithm: &str) -> Result<Self, Self::Error> {
+        match algorithm {
+            "rank" => Ok(FulltextAlgorithm::Rank),
+            "proximityRank" => Ok(FulltextAlgorithm::ProximityRank),
+            invalid => Err(format!(
+                "The provided fulltext search algorithm {} is invalid. It must be one of: rank, proximityRank",
+                invalid,
+            )),
+        }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct FulltextConfig {
+    pub language: FulltextLanguage,
+    pub algorithm: FulltextAlgorithm,
+}
+
+pub struct FulltextDefinition {
+    pub config: FulltextConfig,
+    pub included_fields: HashSet<String>,
+    pub name: String,
+}
+
+impl From<&s::Directive> for FulltextDefinition {
+    // Assumes the input is a Fulltext Directive that has already been validated because it makes
+    // liberal use of unwrap() where specific types are expected
+    fn from(directive: &s::Directive) -> Self {
+        let name = directive.argument("name").unwrap().as_str().unwrap();
+
+        let algorithm = FulltextAlgorithm::try_from(
+            directive.argument("algorithm").unwrap().as_enum().unwrap(),
+        )
+        .unwrap();
+
+        let language =
+            FulltextLanguage::try_from(directive.argument("language").unwrap().as_enum().unwrap())
+                .unwrap();
+
+        let included_entity_list = directive.argument("include").unwrap().as_list().unwrap();
+        // Currently fulltext query fields are limited to 1 entity, so we just take the first (and only) included Entity
+        let included_entity = included_entity_list.first().unwrap().as_object().unwrap();
+        let included_field_values = included_entity.get("fields").unwrap().as_list().unwrap();
+        let included_fields: HashSet<String> = included_field_values
+            .iter()
+            .map(|field| {
+                field
+                    .as_object()
+                    .unwrap()
+                    .get("name")
+                    .unwrap()
+                    .as_str()
+                    .unwrap()
+                    .into()
+            })
+            .collect();
+
+        FulltextDefinition {
+            config: FulltextConfig {
+                language,
+                algorithm,
+            },
+            included_fields,
+            name: name.into(),
+        }
+    }
+}
diff --git a/graph/src/schema/input/mod.rs b/graph/src/schema/input/mod.rs
new file mode 100644
index 00000000000..905a46dbea5
--- /dev/null
+++ b/graph/src/schema/input/mod.rs
@@ -0,0 +1,3372 @@
+use std::collections::{BTreeMap, BTreeSet};
+use std::ops::Range;
+use std::str::FromStr;
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::{Error, anyhow};
+use semver::Version;
+use store::Entity;
+
+use crate::bail;
+use crate::blockchain::BlockTime;
+use crate::cheap_clone::CheapClone;
+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, 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::{DeploymentHash, s};
+use crate::schema::api::api_schema;
+use crate::util::intern::{Atom, AtomPool};
+
+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$";
+/// The name of the digest attribute of POI entities
+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";
+
+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";
+    pub const SOURCE: &str = "source";
+    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
+/// `schema.graphql` file that is part of a subgraph. Any code that deals
+/// with writing a subgraph should use this struct. Code that deals with
+/// querying subgraphs will instead want to use an `ApiSchema` which can be
+/// generated with the `api_schema` method on `InputSchema`
+///
+/// There's no need to put this into an `Arc`, since `InputSchema` already
+/// does that internally and is `CheapClone`
+#[derive(Clone, CheapClone, Debug, PartialEq)]
+pub struct InputSchema {
+    inner: Arc<Inner>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TypeKind {
+    /// The type is a normal @entity
+    Object,
+    /// The type is an interface
+    Interface,
+    /// The type is an aggregation
+    Aggregation,
+}
+
+#[derive(Debug, PartialEq)]
+enum TypeInfo {
+    Object(ObjectType),
+    Interface(InterfaceType),
+    Aggregation(Aggregation),
+}
+
+impl TypeInfo {
+    fn is_object(&self) -> bool {
+        match self {
+            TypeInfo::Object(_) => true,
+            TypeInfo::Interface(_) | TypeInfo::Aggregation(_) => false,
+        }
+    }
+
+    fn is_interface(&self) -> bool {
+        match self {
+            TypeInfo::Object(_) | TypeInfo::Aggregation(_) => false,
+            TypeInfo::Interface(_) => true,
+        }
+    }
+
+    fn id_type(&self) -> Option<IdType> {
+        match self {
+            TypeInfo::Object(obj_type) => Some(obj_type.id_type),
+            TypeInfo::Interface(intf_type) => Some(intf_type.id_type),
+            TypeInfo::Aggregation(agg_type) => Some(agg_type.id_type),
+        }
+    }
+
+    fn fields(&self) -> &[Field] {
+        match self {
+            TypeInfo::Object(obj_type) => &obj_type.fields,
+            TypeInfo::Interface(intf_type) => &intf_type.fields,
+            TypeInfo::Aggregation(agg_type) => &agg_type.fields,
+        }
+    }
+
+    fn name(&self) -> Atom {
+        match self {
+            TypeInfo::Object(obj_type) => obj_type.name,
+            TypeInfo::Interface(intf_type) => intf_type.name,
+            TypeInfo::Aggregation(agg_type) => agg_type.name,
+        }
+    }
+
+    fn is_immutable(&self) -> bool {
+        match self {
+            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,
+            TypeInfo::Interface(_) => TypeKind::Interface,
+            TypeInfo::Aggregation(_) => TypeKind::Aggregation,
+        }
+    }
+
+    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),
+            TypeInfo::Interface(_) | TypeInfo::Object(_) => None,
+        }
+    }
+}
+
+impl TypeInfo {
+    fn for_object(schema: &Schema, pool: &AtomPool, obj_type: &s::ObjectType) -> Self {
+        let shared_interfaces: Vec<_> = match schema.interfaces_for_type(&obj_type.name) {
+            Some(intfs) => {
+                let mut shared_interfaces: Vec<_> = intfs
+                    .iter()
+                    .flat_map(|intf| &schema.types_for_interface[&intf.name])
+                    .filter(|other| other.name != obj_type.name)
+                    .map(|obj_type| pool.lookup(&obj_type.name).unwrap())
+                    .collect();
+                shared_interfaces.sort();
+                shared_interfaces.dedup();
+                shared_interfaces
+            }
+            None => Vec::new(),
+        };
+        let object_type =
+            ObjectType::new(schema, pool, obj_type, shared_interfaces.into_boxed_slice());
+        TypeInfo::Object(object_type)
+    }
+
+    fn for_interface(schema: &Schema, pool: &AtomPool, intf_type: &s::InterfaceType) -> Self {
+        static EMPTY_VEC: [s::ObjectType; 0] = [];
+        let implementers = schema
+            .types_for_interface
+            .get(&intf_type.name)
+            .map(|impls| impls.as_slice())
+            .unwrap_or_else(|| EMPTY_VEC.as_slice());
+        let intf_type = InterfaceType::new(schema, pool, intf_type, implementers);
+        TypeInfo::Interface(intf_type)
+    }
+
+    fn for_poi(pool: &AtomPool) -> Self {
+        // The way we handle the PoI type is a bit of a hack. We pretend
+        // it's an object type, but trying to look up the `s::ObjectType`
+        // for it will turn up nothing.
+        // See also https://github.com/graphprotocol/graph-node/issues/4873
+        TypeInfo::Object(ObjectType::for_poi(pool))
+    }
+
+    fn for_aggregation(schema: &Schema, pool: &AtomPool, agg_type: &s::ObjectType) -> Self {
+        let agg_type = Aggregation::new(schema, pool, agg_type);
+        TypeInfo::Aggregation(agg_type)
+    }
+
+    fn interfaces(&self) -> impl Iterator<Item = &str> {
+        const NO_INTF: [Word; 0] = [];
+        let interfaces = match &self {
+            TypeInfo::Object(obj_type) => &obj_type.interfaces,
+            TypeInfo::Interface(_) | TypeInfo::Aggregation(_) => NO_INTF.as_slice(),
+        };
+        interfaces.iter().map(|interface| interface.as_str())
+    }
+}
+
+#[derive(PartialEq, Debug, Clone)]
+pub struct Field {
+    pub name: Word,
+    pub field_type: s::Type,
+    pub value_type: ValueType,
+    derived_from: Option<Word>,
+}
+
+impl Field {
+    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,
+            derived_from,
+        }
+    }
+
+    fn scalar_value_type(schema: &Schema, field_type: &s::Type) -> ValueType {
+        use s::TypeDefinition as t;
+        match field_type {
+            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");
+                        Self::scalar_value_type(schema, &id.field_type)
+                    }
+                    Some(t::Interface(intf)) => {
+                        // Validation checks that all implementors of an
+                        // interface use the same type for `id`. It is
+                        // therefore enough to use the id type of one of
+                        // the implementors
+                        match schema
+                            .types_for_interface
+                            .get(&intf.name)
+                            .expect("interface type names are known")
+                            .first()
+                        {
+                            None => {
+                                // Nothing is implementing this interface; we assume it's of type string
+                                // see also: id-type-for-unimplemented-interfaces
+                                ValueType::String
+                            }
+                            Some(obj_type) => {
+                                let id = obj_type.field(&ID).expect("all object types have an id");
+                                Self::scalar_value_type(schema, &id.field_type)
+                            }
+                        }
+                    }
+                    Some(t::Enum(_)) => ValueType::String,
+                    Some(t::Scalar(_)) => unreachable!("user-defined scalars are not used"),
+                    Some(t::Union(_)) => unreachable!("unions are not used"),
+                    Some(t::InputObject(_)) => unreachable!("inputObjects are not used"),
+                    None => unreachable!("names of field types have been validated"),
+                }
+            }),
+            s::Type::NonNullType(inner) => Self::scalar_value_type(schema, inner),
+            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)]
+pub struct ObjectType {
+    pub name: Atom,
+    pub id_type: IdType,
+    pub fields: Box<[Field]>,
+    pub mutability: ObjectMutability,
+    /// The name of the aggregation to which this object type belongs if it
+    /// is part of an aggregation
+    aggregation: Option<Atom>,
+    pub timeseries: bool,
+    interfaces: Box<[Word]>,
+    shared_interfaces: Box<[Atom]>,
+}
+
+impl ObjectType {
+    fn new(
+        schema: &Schema,
+        pool: &AtomPool,
+        object_type: &s::ObjectType,
+        shared_interfaces: Box<[Atom]>,
+    ) -> Self {
+        let id_type = IdType::try_from(object_type).expect("validation caught any issues here");
+        let fields = object_type
+            .fields
+            .iter()
+            .map(|field| {
+                let derived_from = field.derived_from().map(Word::from);
+                Field::new(schema, &field.name, &field.field_type, derived_from)
+            })
+            .collect();
+        let interfaces = object_type
+            .implements_interfaces
+            .iter()
+            .map(|intf| Word::from(intf.to_owned()))
+            .collect();
+        let name = pool
+            .lookup(&object_type.name)
+            .expect("object type names have been interned");
+        let dir = object_type.find_directive("entity").unwrap();
+        let timeseries = match dir.argument("timeseries") {
+            Some(Value::Boolean(ts)) => *ts,
+            None => false,
+            _ => unreachable!("validations ensure we don't get here"),
+        };
+        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,
+            mutability,
+            aggregation: None,
+            timeseries,
+            interfaces,
+            shared_interfaces,
+        }
+    }
+
+    fn for_poi(pool: &AtomPool) -> Self {
+        let fields = vec![
+            Field {
+                name: ID.clone(),
+                field_type: s::Type::NamedType("ID".to_string()),
+                value_type: ValueType::String,
+                derived_from: None,
+            },
+            Field {
+                name: Word::from(POI_DIGEST),
+                field_type: s::Type::NamedType("String".to_string()),
+                value_type: ValueType::String,
+                derived_from: None,
+            },
+        ]
+        .into_boxed_slice();
+        let name = pool
+            .lookup(POI_OBJECT)
+            .expect("POI_OBJECT has been interned");
+        Self {
+            name,
+            interfaces: Box::new([]),
+            id_type: IdType::String,
+            mutability: ObjectMutability::Mutable,
+            aggregation: None,
+            timeseries: false,
+            fields,
+            shared_interfaces: Box::new([]),
+        }
+    }
+
+    pub fn field(&self, name: &str) -> Option<&Field> {
+        self.fields.iter().find(|field| field.name == name)
+    }
+
+    /// Return `true` if this object type is part of an aggregation
+    pub fn is_aggregation(&self) -> bool {
+        self.aggregation.is_some()
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum ObjectMutability {
+    Mutable,
+    Immutable { skip_duplicates: bool },
+}
+
+#[derive(PartialEq, Debug)]
+pub struct InterfaceType {
+    pub name: Atom,
+    /// For interfaces, the type of the `id` field is the type of the `id`
+    /// field of the object types that implement it; validations ensure that
+    /// it is the same for all implementers of an interface. If an interface
+    /// is not implemented at all, we arbitrarily use `String`
+    pub id_type: IdType,
+    pub fields: Box<[Field]>,
+    implementers: Box<[Atom]>,
+}
+
+impl InterfaceType {
+    fn new(
+        schema: &Schema,
+        pool: &AtomPool,
+        interface_type: &s::InterfaceType,
+        implementers: &[s::ObjectType],
+    ) -> Self {
+        let fields = interface_type
+            .fields
+            .iter()
+            .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)
+            .expect("interface type names have been interned");
+        let id_type = implementers
+            .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)]
+struct EnumMap(BTreeMap<String, Arc<BTreeSet<String>>>);
+
+impl EnumMap {
+    fn new(schema: &Schema) -> Self {
+        let map = schema
+            .document
+            .get_enum_definitions()
+            .iter()
+            .map(|enum_type| {
+                (
+                    enum_type.name.clone(),
+                    Arc::new(
+                        enum_type
+                            .values
+                            .iter()
+                            .map(|value| value.name.clone())
+                            .collect::<BTreeSet<_>>(),
+                    ),
+                )
+            })
+            .collect();
+        EnumMap(map)
+    }
+
+    fn names(&self) -> impl Iterator<Item = &str> {
+        self.0.keys().map(|name| name.as_str())
+    }
+
+    fn contains_key(&self, name: &str) -> bool {
+        self.0.contains_key(name)
+    }
+
+    fn values(&self, name: &str) -> Option<Arc<BTreeSet<String>>> {
+        self.0.get(name).cloned()
+    }
+}
+
+#[derive(PartialEq, Debug, Clone)]
+pub enum AggregateFn {
+    Sum,
+    Max,
+    Min,
+    Count,
+    First,
+    Last,
+}
+
+impl FromStr for AggregateFn {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "sum" => Ok(AggregateFn::Sum),
+            "max" => Ok(AggregateFn::Max),
+            "min" => Ok(AggregateFn::Min),
+            "count" => Ok(AggregateFn::Count),
+            "first" => Ok(AggregateFn::First),
+            "last" => Ok(AggregateFn::Last),
+            _ => Err(anyhow!("invalid aggregate function `{}`", s)),
+        }
+    }
+}
+
+impl AggregateFn {
+    pub fn has_arg(&self) -> bool {
+        use AggregateFn::*;
+        match self {
+            Sum | Max | Min | First | Last => true,
+            Count => false,
+        }
+    }
+
+    fn as_str(&self) -> &'static str {
+        use AggregateFn::*;
+        match self {
+            Sum => "sum",
+            Max => "max",
+            Min => "min",
+            Count => "count",
+            First => "first",
+            Last => "last",
+        }
+    }
+}
+
+/// The supported intervals for timeseries in order of decreasing
+/// granularity. The intervals must all be divisible by the smallest
+/// interval
+#[derive(Clone, Copy, PartialEq, Eq, Debug, PartialOrd, Ord, Hash)]
+pub enum AggregationInterval {
+    Hour,
+    Day,
+}
+
+impl AggregationInterval {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            AggregationInterval::Hour => "hour",
+            AggregationInterval::Day => "day",
+        }
+    }
+
+    pub fn as_duration(&self) -> Duration {
+        use AggregationInterval::*;
+        match self {
+            Hour => Duration::from_secs(3600),
+            Day => Duration::from_secs(3600 * 24),
+        }
+    }
+
+    /// Return time ranges for all buckets that intersect `from..to` except
+    /// the last one. In other words, return time ranges for all buckets
+    /// that overlap `from..to` and end before `to`. The ranges are in
+    /// increasing order of the start time
+    pub fn buckets(&self, from: BlockTime, to: BlockTime) -> Vec<Range<BlockTime>> {
+        let first = from.bucket(self.as_duration());
+        let last = to.bucket(self.as_duration());
+        (first..last)
+            .map(|nr| self.as_duration() * nr as u32)
+            .map(|start| {
+                let lower = BlockTime::from(start);
+                let upper = BlockTime::from(start + self.as_duration());
+                lower..upper
+            })
+            .collect()
+    }
+}
+
+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
+    const START: i64 = 1153035600;
+    // 2006-07-16 08:00Z, the start of the next hourly bucket after `START`
+    const EIGHT_AM: i64 = 1153036800;
+
+    let start = BlockTime::since_epoch(START, 0);
+    let seven_am = BlockTime::since_epoch(START - 40 * 60, 0);
+    let eight_am = BlockTime::since_epoch(EIGHT_AM, 0);
+    let nine_am = BlockTime::since_epoch(EIGHT_AM + 3600, 0);
+
+    // One hour and two hours after `START`
+    let one_hour = BlockTime::since_epoch(START + 3600, 0);
+    let two_hour = BlockTime::since_epoch(START + 2 * 3600, 0);
+
+    use AggregationInterval::*;
+    assert_eq!(vec![seven_am..eight_am], Hour.buckets(start, eight_am));
+    assert_eq!(vec![seven_am..eight_am], Hour.buckets(start, one_hour),);
+    assert_eq!(
+        vec![seven_am..eight_am, eight_am..nine_am],
+        Hour.buckets(start, two_hour),
+    );
+    assert_eq!(vec![eight_am..nine_am], Hour.buckets(one_hour, two_hour));
+    assert_eq!(Vec::<Range<BlockTime>>::new(), Day.buckets(start, two_hour));
+}
+
+impl FromStr for AggregationInterval {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "hour" => Ok(AggregationInterval::Hour),
+            "day" => Ok(AggregationInterval::Day),
+            _ => Err(anyhow!("invalid aggregation interval `{}`", s)),
+        }
+    }
+}
+
+/// The connection between the object type that stores the data points for
+/// an aggregation and the type that stores the finalised aggregations.
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct AggregationMapping {
+    pub interval: AggregationInterval,
+    // Index of aggregation type in `type_infos`
+    aggregation: usize,
+    // Index of the object type for the interval in the aggregation's `obj_types`
+    agg_type: usize,
+}
+
+impl AggregationMapping {
+    pub fn source_type(&self, schema: &InputSchema) -> EntityType {
+        let source = self.aggregation(schema).source;
+        EntityType::new(schema.cheap_clone(), source)
+    }
+
+    pub fn aggregation<'a>(&self, schema: &'a InputSchema) -> &'a Aggregation {
+        schema.inner.type_infos[self.aggregation]
+            .aggregation()
+            .expect("the aggregation source is an object type")
+    }
+
+    pub fn agg_type(&self, schema: &InputSchema) -> EntityType {
+        let agg_type = self.aggregation(schema).obj_types[self.agg_type].name;
+        EntityType::new(schema.cheap_clone(), agg_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,
+    /// 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, name: &str, field_type: &s::Type, dir: &s::Directive) -> Self {
+        let func = dir
+            .argument("fn")
+            .unwrap()
+            .as_str()
+            .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()))
+            .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::scalar_value_type(schema, field_type),
+        }
+    }
+
+    /// The field needed for the finalised aggregation for hourly/daily
+    /// values
+    pub fn as_agg_field(&self) -> Field {
+        Field {
+            name: self.name.clone(),
+            field_type: self.field_type.clone(),
+            value_type: self.value_type,
+            derived_from: None,
+        }
+    }
+}
+
+#[derive(PartialEq, Debug)]
+pub struct Aggregation {
+    pub name: Atom,
+    pub id_type: IdType,
+    pub intervals: Box<[AggregationInterval]>,
+    pub source: Atom,
+    /// The non-aggregation fields of the time series
+    pub fields: Box<[Field]>,
+    pub aggregates: Box<[Aggregate]>,
+    /// The object types for the aggregated data, one for each interval, in
+    /// the same order as `intervals`
+    obj_types: Box<[ObjectType]>,
+}
+
+impl Aggregation {
+    pub fn new(schema: &Schema, pool: &AtomPool, agg_type: &s::ObjectType) -> Self {
+        let name = pool.lookup(&agg_type.name).unwrap();
+        let id_type = IdType::try_from(agg_type).expect("validation caught any issues here");
+        let intervals = Self::parse_intervals(agg_type).into_boxed_slice();
+        let source = agg_type
+            .find_directive(kw::AGGREGATION)
+            .unwrap()
+            .argument("source")
+            .unwrap()
+            .as_str()
+            .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, 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, &field.name, &field.field_type, dir))
+            .collect();
+
+        let obj_types = intervals
+            .iter()
+            .map(|interval| {
+                let name = format!("{}_{}", &agg_type.name, interval.as_str());
+                let name = pool.lookup(&name).unwrap();
+                ObjectType {
+                    name,
+                    id_type,
+                    fields: fields
+                        .iter()
+                        .cloned()
+                        .chain(aggregates.iter().map(Aggregate::as_agg_field))
+                        .collect(),
+                    mutability: ObjectMutability::Immutable {
+                        skip_duplicates: false,
+                    },
+                    aggregation: Some(name),
+                    timeseries: false,
+                    interfaces: Box::new([]),
+                    shared_interfaces: Box::new([]),
+                }
+            })
+            .collect();
+        Self {
+            name,
+            id_type,
+            intervals,
+            source,
+            fields,
+            aggregates,
+            obj_types,
+        }
+    }
+
+    fn parse_intervals(agg_type: &s::ObjectType) -> Vec<AggregationInterval> {
+        let dir = agg_type.find_directive(kw::AGGREGATION).unwrap();
+        let mut intervals: Vec<_> = dir
+            .argument(kw::INTERVALS)
+            .unwrap()
+            .as_list()
+            .unwrap()
+            .iter()
+            .map(|interval| interval.as_str().unwrap().parse().unwrap())
+            .collect();
+        intervals.sort();
+        intervals.dedup();
+        intervals
+    }
+
+    fn has_object_type(&self, atom: Atom) -> bool {
+        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
+            .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)
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub struct Inner {
+    schema: Schema,
+    /// A list of all the object and interface types in the `schema` with
+    /// some important information extracted from the schema. The list is
+    /// sorted by the name atom (not the string name) of the types
+    type_infos: Box<[TypeInfo]>,
+    enum_map: EnumMap,
+    pool: Arc<AtomPool>,
+    /// A list of all timeseries types by interval
+    agg_mappings: Box<[AggregationMapping]>,
+    spec_version: Version,
+}
+
+impl InputSchema {
+    /// A convenience function for creating an `InputSchema` from the string
+    /// representation of the subgraph's GraphQL schema `raw` and its
+    /// deployment hash `id`. The returned schema is fully validated.
+    pub fn parse(spec_version: &Version, raw: &str, id: DeploymentHash) -> Result<Self, Error> {
+        fn agg_mappings(ts_types: &[TypeInfo]) -> Box<[AggregationMapping]> {
+            let mut mappings: Vec<_> = ts_types
+                .iter()
+                .enumerate()
+                .filter_map(|(idx, ti)| ti.aggregation().map(|agg_type| (idx, agg_type)))
+                .flat_map(|(aggregation, agg_type)| {
+                    agg_type
+                        .intervals
+                        .iter()
+                        .enumerate()
+                        .map(move |(agg_type, interval)| AggregationMapping {
+                            interval: *interval,
+                            aggregation,
+                            agg_type,
+                        })
+                })
+                .collect();
+            mappings.sort();
+            mappings.into_boxed_slice()
+        }
+
+        let schema = Schema::parse(raw, id.clone())?;
+        validations::validate(spec_version, &schema).map_err(|errors| {
+            anyhow!(
+                "Validation errors in subgraph `{}`:\n{}",
+                id,
+                errors
+                    .into_iter()
+                    .enumerate()
+                    .map(|(n, e)| format!("  ({}) - {}", n + 1, e))
+                    .collect::<Vec<_>>()
+                    .join("\n")
+            )
+        })?;
+
+        let pool = Arc::new(atom_pool(&schema.document));
+
+        // There are a lot of unwraps in this code; they are all safe
+        // because the validations check for all the ways in which the
+        // unwrapping could go wrong. It would be better to rewrite all this
+        // code so that validation and construction of the internal data
+        // structures happen in one pass which would eliminate the need for
+        // unwrapping
+        let obj_types = schema
+            .document
+            .get_object_type_definitions()
+            .into_iter()
+            .filter(|obj_type| obj_type.find_directive("entity").is_some())
+            .map(|obj_type| TypeInfo::for_object(&schema, &pool, obj_type));
+        let intf_types = schema
+            .document
+            .get_interface_type_definitions()
+            .into_iter()
+            .map(|intf_type| TypeInfo::for_interface(&schema, &pool, intf_type));
+        let agg_types = schema
+            .document
+            .get_object_type_definitions()
+            .into_iter()
+            .filter(|obj_type| obj_type.find_directive(kw::AGGREGATION).is_some())
+            .map(|agg_type| TypeInfo::for_aggregation(&schema, &pool, agg_type));
+        let mut type_infos: Vec<_> = obj_types
+            .chain(intf_types)
+            .chain(agg_types)
+            .chain(vec![TypeInfo::for_poi(&pool)])
+            .collect();
+        type_infos.sort_by_key(|ti| ti.name());
+        let type_infos = type_infos.into_boxed_slice();
+
+        let enum_map = EnumMap::new(&schema);
+
+        let agg_mappings = agg_mappings(&type_infos);
+
+        Ok(Self {
+            inner: Arc::new(Inner {
+                schema,
+                type_infos,
+                enum_map,
+                pool,
+                agg_mappings,
+                spec_version: spec_version.clone(),
+            }),
+        })
+    }
+
+    /// Parse with the latest spec version
+    pub fn parse_latest(raw: &str, id: DeploymentHash) -> Result<Self, Error> {
+        use crate::data::subgraph::LATEST_VERSION;
+
+        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
+    ///
+    /// If the `document` or `hash` can not be successfully converted
+    #[cfg(debug_assertions)]
+    #[track_caller]
+    pub fn raw(document: &str, hash: &str) -> Self {
+        let hash = DeploymentHash::new(hash).unwrap();
+        Self::parse_latest(document, hash).unwrap()
+    }
+
+    pub fn schema(&self) -> &Schema {
+        &self.inner.schema
+    }
+
+    /// Generate the `ApiSchema` for use with GraphQL queries for this
+    /// `InputSchema`
+    pub fn api_schema(&self) -> Result<ApiSchema, anyhow::Error> {
+        let mut schema = self.inner.schema.clone();
+        schema.document = api_schema(self)?;
+        schema.add_subgraph_id_directives(schema.id.clone());
+        ApiSchema::from_api_schema(schema)
+    }
+
+    /// Returns the field that has the relationship with the key requested
+    /// This works as a reverse search for the Field related to the query
+    ///
+    /// example:
+    ///
+    /// type Account @entity {
+    ///     wallets: [Wallet!]! @derivedFrom(field: "account")
+    /// }
+    /// type Wallet {
+    ///     account: Account!
+    ///     balance: Int!
+    /// }
+    ///
+    /// When asked to load the related entities from "Account" in the field "wallets"
+    /// This function will return the type "Wallet" with the field "account"
+    pub fn get_field_related(
+        &self,
+        key: &LoadRelatedRequest,
+    ) -> Result<(EntityType, &Field), Error> {
+        fn field_err(key: &LoadRelatedRequest, err: &str) -> Error {
+            anyhow!(
+                "Entity {}[{}]: {err} `{}`",
+                key.entity_type,
+                key.entity_id,
+                key.entity_field,
+            )
+        }
+
+        let field = self
+            .inner
+            .schema
+            .document
+            .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"))?;
+        if !field.is_derived() {
+            return Err(field_err(key, "field is not derived"));
+        }
+
+        let derived_from = field.find_directive("derivedFrom").unwrap();
+        let entity_type = self.entity_type(field.field_type.get_base_type())?;
+        let field_name = derived_from.argument("field").unwrap();
+
+        let field = self
+            .object_type(entity_type.atom)?
+            .field(field_name.as_str().unwrap())
+            .ok_or_else(|| field_err(key, "unknown field"))?;
+
+        Ok((entity_type, field))
+    }
+
+    /// 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 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 {
+                TypeInfo::Object(obj_type) => {
+                    if obj_type.name == atom {
+                        return Ok(ti);
+                    }
+                }
+                TypeInfo::Interface(intf_type) => {
+                    if intf_type.name == atom {
+                        return Ok(ti);
+                    }
+                }
+                TypeInfo::Aggregation(agg_type) => {
+                    if agg_type.name == atom || agg_type.has_object_type(atom) {
+                        return Ok(ti);
+                    }
+                }
+            }
+        }
+
+        let err = match self.inner.pool.get(atom) {
+            Some(name) => anyhow!(
+                "internal error: entity type `{}` does not exist in {}",
+                name,
+                self.inner.schema.id
+            ),
+            None => anyhow!(
+                "Invalid atom {atom:?} for type_info lookup in {} (atom is probably from a different pool)",
+                self.inner.schema.id
+            ),
+        };
+        Err(err)
+    }
+
+    pub(in crate::schema) fn id_type(&self, entity_type: Atom) -> Result<store::IdType, Error> {
+        let type_info = self.type_info(entity_type)?;
+
+        type_info.id_type().ok_or_else(|| {
+            let name = self.inner.pool.get(entity_type).unwrap();
+            anyhow!("Entity type `{}` does not have an `id` field", name)
+        })
+    }
+
+    /// Check if `entity_type` is an immutable object type
+    pub(in crate::schema) fn is_immutable(&self, entity_type: Atom) -> bool {
+        self.type_info(entity_type)
+            .ok()
+            .map(|ti| ti.is_immutable())
+            .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
+            .pool
+            .lookup(type_name)
+            .and_then(|atom| {
+                self.type_info(atom)
+                    .ok()
+                    .map(|ti| ti.is_object() || ti.is_interface())
+            })
+            .unwrap_or(false)
+    }
+
+    /// Return a list of the interfaces that `entity_type` implements
+    pub fn interfaces(&self, entity_type: Atom) -> impl Iterator<Item = &InterfaceType> {
+        let obj_type = self.type_info(entity_type).unwrap();
+        obj_type.interfaces().map(|intf| {
+            let atom = self.inner.pool.lookup(intf).unwrap();
+            match self.type_info(atom).unwrap() {
+                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(
+        &self,
+        entity_type: Atom,
+    ) -> Result<Vec<EntityType>, Error> {
+        let obj_type = match &self.type_info(entity_type)? {
+            TypeInfo::Object(obj_type) => obj_type,
+            TypeInfo::Aggregation(_) => {
+                /* aggregations don't implement interfaces */
+                return Ok(Vec::new());
+            }
+            _ => bail!(
+                "expected `{}` to refer to an object type",
+                self.inner.pool.get(entity_type).unwrap_or("<unknown>")
+            ),
+        };
+        Ok(obj_type
+            .shared_interfaces
+            .iter()
+            .map(|atom| EntityType::new(self.cheap_clone(), *atom))
+            .collect())
+    }
+
+    /// Return the object type with name `entity_type`. It is an error to
+    /// call this if `entity_type` refers to an interface or an aggregation
+    /// as they don't have an underlying type that stores data directly
+    pub(in crate::schema) fn object_type(&self, entity_type: Atom) -> Result<&ObjectType, Error> {
+        let ti = self.type_info(entity_type)?;
+        match ti {
+            TypeInfo::Object(obj_type) => Ok(obj_type),
+            TypeInfo::Interface(_) => {
+                let name = self.inner.pool.get(entity_type).unwrap();
+                bail!(
+                    "expected `{}` to refer to an object type but it's an interface",
+                    name
+                )
+            }
+            TypeInfo::Aggregation(agg_type) => {
+                agg_type.obj_types
+                    .iter()
+                    .find(|obj_type| obj_type.name == entity_type)
+                    .ok_or_else(|| anyhow!("type_info returns an aggregation only when it has the requested object type"))
+            }
+        }
+    }
+
+    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()
+    }
+
+    /// Check if `name` is the name of an enum type
+    pub fn is_enum_type(&self, name: &str) -> bool {
+        self.inner.enum_map.contains_key(name)
+    }
+
+    /// Return a list of the values of the enum type `name`
+    pub fn enum_values(&self, name: &str) -> Option<Arc<BTreeSet<String>>> {
+        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
+    pub fn entity_types(&self) -> Vec<EntityType> {
+        self.inner
+            .type_infos
+            .iter()
+            .filter_map(|ti| match ti {
+                TypeInfo::Object(obj_type) => Some(obj_type),
+                TypeInfo::Interface(_) | TypeInfo::Aggregation(_) => None,
+            })
+            .map(|obj_type| EntityType::new(self.cheap_clone(), obj_type.name))
+            .filter(|entity_type| !entity_type.is_poi())
+            .collect()
+    }
+
+    /// Return a list of all the entity types for aggregations; these are
+    /// types derived from types with `@aggregation` annotations
+    pub fn ts_entity_types(&self) -> Vec<EntityType> {
+        self.inner
+            .type_infos
+            .iter()
+            .filter_map(TypeInfo::aggregation)
+            .flat_map(|ts_type| ts_type.obj_types.iter())
+            .map(|obj_type| EntityType::new(self.cheap_clone(), obj_type.name))
+            .collect()
+    }
+
+    /// Return a list of all the aggregation mappings for this schema. The
+    /// `interval` of the aggregations are non-decreasing
+    pub fn agg_mappings(&self) -> impl Iterator<Item = &AggregationMapping> {
+        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
+            .iter()
+            .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,
+    ) -> Result<Vec<FulltextDefinition>, anyhow::Error> {
+        Self::fulltext_definitions(&self.inner.schema.document, entity)
+    }
+
+    fn fulltext_definitions(
+        document: &s::Document,
+        entity: &str,
+    ) -> Result<Vec<FulltextDefinition>, anyhow::Error> {
+        Ok(document
+            .get_fulltext_directives()?
+            .into_iter()
+            .filter(|directive| match directive.argument("include") {
+                Some(Value::List(includes)) if !includes.is_empty() => {
+                    includes.iter().any(|include| match include {
+                        Value::Object(include) => matches!(include.get("entity"), Some(Value::String(fulltext_entity)) if fulltext_entity == entity),
+                        _ => false,
+                    })
+                }
+                _ => false,
+            })
+            .map(FulltextDefinition::from)
+            .collect())
+    }
+
+    pub fn id(&self) -> &DeploymentHash {
+        &self.inner.schema.id
+    }
+
+    pub fn document_string(&self) -> String {
+        self.inner.schema.document.to_string()
+    }
+
+    pub fn get_fulltext_directives(&self) -> Result<Vec<&s::Directive>, Error> {
+        self.inner.schema.document.get_fulltext_directives()
+    }
+
+    pub fn make_entity<I: IntoEntityIterator>(
+        &self,
+        iter: I,
+    ) -> Result<Entity, EntityValidationError> {
+        Entity::make(self.inner.pool.clone(), iter)
+    }
+
+    pub fn try_make_entity<
+        E: std::error::Error + Send + Sync + 'static,
+        I: TryIntoEntityIterator<E>,
+    >(
+        &self,
+        iter: I,
+    ) -> Result<Entity, Error> {
+        Entity::try_make(self.inner.pool.clone(), iter)
+    }
+
+    /// Check if `entity_type` is an object type and has a field `field`
+    pub(in crate::schema) fn has_field(&self, entity_type: Atom, name: Atom) -> bool {
+        let name = self.inner.pool.get(name).unwrap();
+        self.type_info(entity_type)
+            .map(|ti| ti.is_object() && ti.fields().iter().any(|field| field.name == name))
+            .unwrap_or(false)
+    }
+
+    pub fn poi_type(&self) -> EntityType {
+        // unwrap: we make sure to put POI_OBJECT into the pool
+        let atom = self.inner.pool.lookup(POI_OBJECT).unwrap();
+        EntityType::new(self.cheap_clone(), atom)
+    }
+
+    pub fn poi_digest(&self) -> Word {
+        Word::from(POI_DIGEST)
+    }
+
+    pub fn poi_block_time(&self) -> Word {
+        Word::from(POI_BLOCK_TIME)
+    }
+
+    // A helper for the `EntityType` constructor
+    pub(in crate::schema) fn pool(&self) -> &Arc<AtomPool> {
+        &self.inner.pool
+    }
+
+    /// Return the entity type for `named`. If the entity type does not
+    /// exist, return an error. Generally, an error should only be possible
+    /// if `named` is based on user input. If `named` is an internal object,
+    /// like a `ObjectType`, it is safe to unwrap the result
+    pub fn entity_type<N: AsEntityTypeName>(&self, named: N) -> Result<EntityType, Error> {
+        let name = named.name();
+        let atom = self.inner.pool.lookup(name).ok_or_else(|| {
+            anyhow!("internal error: unknown name {name} when looking up entity type")
+        })?;
+
+        // This is a little subtle: we use `type_info` to check that `atom`
+        // is a known type, but use `atom` and not the name of the
+        // `TypeInfo` in the returned entity type so that passing the name
+        // of the object type from an aggregation, say `Stats_hour`
+        // references that object type, and not the aggregation.
+        self.type_info(atom)
+            .map(|_| EntityType::new(self.cheap_clone(), atom))
+    }
+
+    pub fn has_field_with_name(&self, entity_type: &EntityType, field: &str) -> bool {
+        let field = self.inner.pool.lookup(field);
+
+        match field {
+            Some(field) => self.has_field(entity_type.atom, field),
+            None => false,
+        }
+    }
+
+    /// 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
+    }
+}
+
+/// Create a new pool that contains the names of all the types defined
+/// in the document and the names of all their fields
+fn atom_pool(document: &s::Document) -> AtomPool {
+    let mut pool = AtomPool::new();
+
+    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 {
+                s::TypeDefinition::Object(t) => {
+                    static NO_VALUE: Vec<Value> = Vec::new();
+
+                    pool.intern(&t.name);
+
+                    // For timeseries, also intern the names of the
+                    // additional types we generate.
+                    let intervals = t
+                        .find_directive(kw::AGGREGATION)
+                        .and_then(|dir| dir.argument(kw::INTERVALS))
+                        .and_then(Value::as_list)
+                        .unwrap_or(&NO_VALUE);
+                    for interval in intervals {
+                        if let Some(interval) = interval.as_str() {
+                            pool.intern(&format!("{}_{}", t.name, interval));
+                        }
+                    }
+                    for field in &t.fields {
+                        pool.intern(&field.name);
+                    }
+                }
+                s::TypeDefinition::Enum(t) => {
+                    pool.intern(&t.name);
+                }
+                s::TypeDefinition::Interface(t) => {
+                    pool.intern(&t.name);
+                    for field in &t.fields {
+                        pool.intern(&field.name);
+                    }
+                }
+                s::TypeDefinition::InputObject(input_object) => {
+                    pool.intern(&input_object.name);
+                    for field in &input_object.fields {
+                        pool.intern(&field.name);
+                    }
+                }
+                s::TypeDefinition::Scalar(scalar_type) => {
+                    pool.intern(&scalar_type.name);
+                }
+                s::TypeDefinition::Union(union_type) => {
+                    pool.intern(&union_type.name);
+                    for typ in &union_type.types {
+                        pool.intern(typ);
+                    }
+                }
+            },
+            s::Definition::SchemaDefinition(_)
+            | s::Definition::TypeExtension(_)
+            | s::Definition::DirectiveDefinition(_) => { /* ignore, these only happen for introspection schemas */
+            }
+        }
+    }
+
+    for object_type in document.get_object_type_definitions() {
+        for defn in InputSchema::fulltext_definitions(document, &object_type.name).unwrap() {
+            pool.intern(defn.name.as_str());
+        }
+    }
+
+    pool
+}
+
+/// Validations for an `InputSchema`.
+mod validations {
+    use std::{collections::HashSet, str::FromStr};
+
+    use itertools::Itertools;
+    use semver::Version;
+
+    use crate::{
+        data::{
+            graphql::{
+                DirectiveExt, DocumentExt, ObjectTypeExt, TypeExt, ValueExt,
+                ext::{DirectiveFinder, FieldExt},
+            },
+            store::{ID, IdType, ValueType},
+            subgraph::SPEC_VERSION_1_1_0,
+        },
+        prelude::s,
+        schema::{
+            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> {
+        spec_version: &'a Version,
+        schema: &'a BaseSchema,
+        subgraph_schema_type: Option<&'a s::ObjectType>,
+        // All entity types, excluding the subgraph schema type
+        entity_types: Vec<&'a s::ObjectType>,
+        aggregations: Vec<&'a s::ObjectType>,
+    }
+
+    pub(super) fn validate(
+        spec_version: &Version,
+        schema: &BaseSchema,
+    ) -> Result<(), Vec<SchemaValidationError>> {
+        let schema = Schema::new(spec_version, schema);
+
+        let mut errors: Vec<SchemaValidationError> = [
+            schema.validate_no_extra_types(),
+            schema.validate_derived_from(),
+            schema.validate_schema_type_has_no_fields(),
+            schema.validate_directives_on_schema_type(),
+            schema.validate_reserved_types_usage(),
+            schema.validate_interface_id_type(),
+        ]
+        .into_iter()
+        .filter(Result::is_err)
+        // Safe unwrap due to the filter above
+        .map(Result::unwrap_err)
+        .collect();
+
+        errors.append(&mut schema.validate_entity_directives());
+        errors.append(&mut schema.validate_entity_type_ids());
+        errors.append(&mut schema.validate_fields());
+        errors.append(&mut schema.validate_fulltext_directives());
+        errors.append(&mut schema.validate_aggregations());
+        if errors.is_empty() {
+            Ok(())
+        } else {
+            Err(errors)
+        }
+    }
+
+    impl<'a> Schema<'a> {
+        fn new(spec_version: &'a Version, schema: &'a BaseSchema) -> Self {
+            let subgraph_schema_type = schema.subgraph_schema_object_type();
+            let mut entity_types = schema.document.get_object_type_definitions();
+            entity_types.retain(|obj_type| obj_type.find_directive(kw::ENTITY).is_some());
+            let mut aggregations = schema.document.get_object_type_definitions();
+            aggregations.retain(|obj_type| obj_type.find_directive(kw::AGGREGATION).is_some());
+
+            Schema {
+                spec_version,
+                schema,
+                subgraph_schema_type,
+                entity_types,
+                aggregations,
+            }
+        }
+
+        fn validate_schema_type_has_no_fields(&self) -> Result<(), SchemaValidationError> {
+            match self.subgraph_schema_type.and_then(|subgraph_schema_type| {
+                if !subgraph_schema_type.fields.is_empty() {
+                    Some(SchemaValidationError::SchemaTypeWithFields)
+                } else {
+                    None
+                }
+            }) {
+                Some(err) => Err(err),
+                None => Ok(()),
+            }
+        }
+
+        fn validate_directives_on_schema_type(&self) -> Result<(), SchemaValidationError> {
+            match self.subgraph_schema_type.and_then(|subgraph_schema_type| {
+                if subgraph_schema_type
+                    .directives
+                    .iter()
+                    .any(|directive| !directive.name.eq("fulltext"))
+                {
+                    Some(SchemaValidationError::InvalidSchemaTypeDirectives)
+                } else {
+                    None
+                }
+            }) {
+                Some(err) => Err(err),
+                None => Ok(()),
+            }
+        }
+
+        fn validate_fulltext_directives(&self) -> Vec<SchemaValidationError> {
+            self.subgraph_schema_type
+                .map_or(vec![], |subgraph_schema_type| {
+                    subgraph_schema_type
+                        .directives
+                        .iter()
+                        .filter(|directives| directives.name.eq("fulltext"))
+                        .fold(vec![], |mut errors, fulltext| {
+                            errors.extend(self.validate_fulltext_directive_name(fulltext));
+                            errors.extend(self.validate_fulltext_directive_language(fulltext));
+                            errors.extend(self.validate_fulltext_directive_algorithm(fulltext));
+                            errors.extend(self.validate_fulltext_directive_includes(fulltext));
+                            errors
+                        })
+                })
+        }
+
+        fn validate_fulltext_directive_name(
+            &self,
+            fulltext: &s::Directive,
+        ) -> Vec<SchemaValidationError> {
+            let name = match fulltext.argument("name") {
+                Some(s::Value::String(name)) => name,
+                _ => return vec![SchemaValidationError::FulltextNameUndefined],
+            };
+
+            // Validate that the fulltext field doesn't collide with any top-level Query fields
+            // generated for entity types. The field name conversions should always align with those used
+            // 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| {
+                    let (singular, plural) = field.camel_cased_names();
+                    name == &singular || name == &plural || field.name.eq(name)
+                })
+            }) {
+                return vec![SchemaValidationError::FulltextNameCollision(
+                    name.to_string(),
+                )];
+            }
+
+            // Validate that each fulltext directive has a distinct name
+            if self
+                .subgraph_schema_type
+                .unwrap()
+                .directives
+                .iter()
+                .filter(|directive| directive.name.eq("fulltext"))
+                .filter_map(|fulltext| {
+                    // Collect all @fulltext directives with the same name
+                    match fulltext.argument("name") {
+                        Some(s::Value::String(n)) if name.eq(n) => Some(n.as_str()),
+                        _ => None,
+                    }
+                })
+                .count()
+                > 1
+            {
+                vec![SchemaValidationError::FulltextNameConflict(
+                    name.to_string(),
+                )]
+            } else {
+                vec![]
+            }
+        }
+
+        fn validate_fulltext_directive_language(
+            &self,
+            fulltext: &s::Directive,
+        ) -> Vec<SchemaValidationError> {
+            let language = match fulltext.argument("language") {
+                Some(s::Value::Enum(language)) => language,
+                _ => return vec![SchemaValidationError::FulltextLanguageUndefined],
+            };
+            match FulltextLanguage::try_from(language.as_str()) {
+                Ok(_) => vec![],
+                Err(_) => vec![SchemaValidationError::FulltextLanguageInvalid(
+                    language.to_string(),
+                )],
+            }
+        }
+
+        fn validate_fulltext_directive_algorithm(
+            &self,
+            fulltext: &s::Directive,
+        ) -> Vec<SchemaValidationError> {
+            let algorithm = match fulltext.argument("algorithm") {
+                Some(s::Value::Enum(algorithm)) => algorithm,
+                _ => return vec![SchemaValidationError::FulltextAlgorithmUndefined],
+            };
+            match FulltextAlgorithm::try_from(algorithm.as_str()) {
+                Ok(_) => vec![],
+                Err(_) => vec![SchemaValidationError::FulltextAlgorithmInvalid(
+                    algorithm.to_string(),
+                )],
+            }
+        }
+
+        fn validate_fulltext_directive_includes(
+            &self,
+            fulltext: &s::Directive,
+        ) -> Vec<SchemaValidationError> {
+            // Validate that each entity in fulltext.include exists
+            let includes = match fulltext.argument("include") {
+                Some(s::Value::List(includes)) if !includes.is_empty() => includes,
+                _ => return vec![SchemaValidationError::FulltextIncludeUndefined],
+            };
+
+            for include in includes {
+                match include.as_object() {
+                    None => return vec![SchemaValidationError::FulltextIncludeObjectMissing],
+                    Some(include_entity) => {
+                        let (entity, fields) =
+                        match (include_entity.get("entity"), include_entity.get("fields")) {
+                            (Some(s::Value::String(entity)), Some(s::Value::List(fields))) => {
+                                (entity, fields)
+                            }
+                            _ => return vec![SchemaValidationError::FulltextIncludeEntityMissingOrIncorrectAttributes],
+                        };
+
+                        // Validate the included entity type is one of the local types
+                        let entity_type = match self
+                            .entity_types
+                            .iter()
+                            .cloned()
+                            .find(|typ| typ.name[..].eq(entity))
+                        {
+                            None => {
+                                return vec![SchemaValidationError::FulltextIncludedEntityNotFound];
+                            }
+                            Some(t) => t,
+                        };
+
+                        for field_value in fields {
+                            let field_name = match field_value {
+                            s::Value::Object(field_map) => match field_map.get("name") {
+                                Some(s::Value::String(name)) => name,
+                                _ => return vec![SchemaValidationError::FulltextIncludedFieldMissingRequiredProperty],
+                            },
+                            _ => return vec![SchemaValidationError::FulltextIncludeEntityMissingOrIncorrectAttributes],
+                        };
+
+                            // Validate the included field is a String field on the local entity types specified
+                            if !&entity_type
+                            .fields
+                            .iter()
+                            .any(|field| {
+                                let base_type: &str = field.field_type.get_base_type();
+                                matches!(ValueType::from_str(base_type), Ok(ValueType::String) if field.name.eq(field_name))
+                            })
+                        {
+                            return vec![SchemaValidationError::FulltextIncludedFieldInvalid(
+                                field_name.clone(),
+                            )];
+                        };
+                        }
+                    }
+                }
+            }
+            // Fulltext include validations all passed, so we return an empty vector
+            vec![]
+        }
+
+        fn validate_fields(&self) -> Vec<SchemaValidationError> {
+            let local_types = self.schema.document.get_object_and_interface_type_fields();
+            let local_enums = self
+                .schema
+                .document
+                .get_enum_definitions()
+                .iter()
+                .map(|enu| enu.name.clone())
+                .collect::<Vec<String>>();
+            local_types
+                .iter()
+                .fold(vec![], |errors, (type_name, fields)| {
+                    fields.iter().fold(errors, |mut errors, field| {
+                        let base = field.field_type.get_base_type();
+                        if ValueType::is_scalar(base) {
+                            return errors;
+                        }
+                        if local_types.contains_key(base) {
+                            return errors;
+                        }
+                        if local_enums.iter().any(|enu| enu.eq(base)) {
+                            return errors;
+                        }
+                        errors.push(SchemaValidationError::FieldTypeUnknown(
+                            type_name.to_string(),
+                            field.name.to_string(),
+                            base.to_string(),
+                        ));
+                        errors
+                    })
+                })
+        }
+
+        /// 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` 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,
+            ) -> Result<Option<bool>, SchemaValidationError> {
+                let arg = dir.argument(name);
+                match arg {
+                    Some(s::Value::Boolean(b)) => Ok(Some(*b)),
+                    Some(_) => Err(SchemaValidationError::EntityDirectiveNonBooleanArgValue(
+                        name.to_owned(),
+                    )),
+                    None => Ok(None),
+                }
+            }
+
+            self.entity_types
+                .iter()
+                .filter_map(|object_type| {
+                    let dir = object_type.find_directive(kw::ENTITY).unwrap();
+                    let timeseries = match bool_arg(dir, kw::TIMESERIES) {
+                        Ok(b) => b.unwrap_or(false),
+                        Err(e) => return Some(e),
+                    };
+                    let immutable = match bool_arg(dir, kw::IMMUTABLE) {
+                        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 {
+                            id_type_is_int8(object_type)
+                                .or_else(|| Self::valid_timestamp_field(object_type))
+                        }
+                    } else {
+                        None
+                    }
+                })
+                .collect()
+        }
+
+        /// 1. All object types besides `_Schema_` must have an id field
+        /// 2. The id field must be recognized by IdType
+        fn validate_entity_type_ids(&self) -> Vec<SchemaValidationError> {
+            self.entity_types
+                .iter()
+                .fold(vec![], |mut errors, object_type| {
+                    match object_type.field(&ID) {
+                        None => errors.push(SchemaValidationError::IdFieldMissing(
+                            object_type.name.clone(),
+                        )),
+                        Some(_) => match IdType::try_from(*object_type) {
+                            Ok(IdType::Int8) => {
+                                if self.spec_version < &SPEC_VERSION_1_1_0 {
+                                    errors.push(SchemaValidationError::IdTypeInt8NotSupported(
+                                        self.spec_version.clone(),
+                                    ))
+                                }
+                            }
+                            Ok(IdType::String | IdType::Bytes) => { /* ok at any spec version */ }
+                            Err(e) => {
+                                errors.push(SchemaValidationError::IllegalIdType(e.to_string()))
+                            }
+                        },
+                    }
+                    errors
+                })
+        }
+
+        /// Checks if the schema is using types that are reserved
+        /// by `graph-node`
+        fn validate_reserved_types_usage(&self) -> Result<(), SchemaValidationError> {
+            let document = &self.schema.document;
+            let object_types: Vec<_> = document
+                .get_object_type_definitions()
+                .into_iter()
+                .map(|obj_type| &obj_type.name)
+                .collect();
+
+            let interface_types: Vec<_> = document
+                .get_interface_type_definitions()
+                .into_iter()
+                .map(|iface_type| &iface_type.name)
+                .collect();
+
+            // TYPE_NAME_filter types for all object and interface types
+            let mut filter_types: Vec<String> = object_types
+                .iter()
+                .chain(interface_types.iter())
+                .map(|type_name| format!("{}_filter", type_name))
+                .collect();
+
+            // TYPE_NAME_orderBy types for all object and interface types
+            let mut order_by_types: Vec<_> = object_types
+                .iter()
+                .chain(interface_types.iter())
+                .map(|type_name| format!("{}_orderBy", type_name))
+                .collect();
+
+            let mut reserved_types: Vec<String> = vec![
+                // The built-in scalar types
+                "Boolean".into(),
+                "ID".into(),
+                "Int".into(),
+                "BigDecimal".into(),
+                "String".into(),
+                "Bytes".into(),
+                "BigInt".into(),
+                // Reserved Query and Subscription types
+                "Query".into(),
+                "Subscription".into(),
+            ];
+
+            reserved_types.append(&mut filter_types);
+            reserved_types.append(&mut order_by_types);
+
+            // `reserved_types` will now only contain
+            // the reserved types that the given schema *is* using.
+            //
+            // That is, if the schema is compliant and not using any reserved
+            // types, then it'll become an empty vector
+            reserved_types.retain(|reserved_type| document.get_named_type(reserved_type).is_some());
+
+            if reserved_types.is_empty() {
+                Ok(())
+            } else {
+                Err(SchemaValidationError::UsageOfReservedTypes(Strings(
+                    reserved_types,
+                )))
+            }
+        }
+
+        fn validate_no_extra_types(&self) -> Result<(), SchemaValidationError> {
+            let extra_type = |t: &&s::ObjectType| {
+                t.find_directive(kw::ENTITY).is_none()
+                    && t.find_directive(kw::AGGREGATION).is_none()
+                    && !t.name.eq(SCHEMA_TYPE_NAME)
+            };
+            let types_without_entity_directive = self
+                .schema
+                .document
+                .get_object_type_definitions()
+                .into_iter()
+                .filter(extra_type)
+                .map(|t| t.name.clone())
+                .collect::<Vec<_>>();
+            if types_without_entity_directive.is_empty() {
+                Ok(())
+            } else {
+                Err(SchemaValidationError::EntityDirectivesMissing(Strings(
+                    types_without_entity_directive,
+                )))
+            }
+        }
+
+        fn validate_derived_from(&self) -> Result<(), SchemaValidationError> {
+            // Helper to construct a DerivedFromInvalid
+            fn invalid(
+                object_type: &s::ObjectType,
+                field_name: &str,
+                reason: &str,
+            ) -> SchemaValidationError {
+                SchemaValidationError::InvalidDerivedFrom(
+                    object_type.name.clone(),
+                    field_name.to_owned(),
+                    reason.to_owned(),
+                )
+            }
+
+            let object_and_interface_type_fields =
+                self.schema.document.get_object_and_interface_type_fields();
+
+            // Iterate over all derived fields in all entity types; include the
+            // interface types that the entity with the `@derivedFrom` implements
+            // and the `field` argument of @derivedFrom directive
+            for (object_type, interface_types, field, target_field) in self
+                .entity_types
+                .iter()
+                .flat_map(|object_type| {
+                    object_type
+                        .fields
+                        .iter()
+                        .map(move |field| (object_type, field))
+                })
+                .filter_map(|(object_type, field)| {
+                    field.find_directive("derivedFrom").map(|directive| {
+                        (
+                            object_type,
+                            object_type
+                                .implements_interfaces
+                                .iter()
+                                .filter(|iface| {
+                                    // Any interface that has `field` can be used
+                                    // as the type of the field
+                                    self.schema
+                                        .document
+                                        .find_interface(iface)
+                                        .map(|iface| {
+                                            iface
+                                                .fields
+                                                .iter()
+                                                .any(|ifield| ifield.name.eq(&field.name))
+                                        })
+                                        .unwrap_or(false)
+                                })
+                                .collect::<Vec<_>>(),
+                            field,
+                            directive.argument("field"),
+                        )
+                    })
+                })
+            {
+                // Turn `target_field` into the string name of the field
+                let target_field = target_field.ok_or_else(|| {
+                    invalid(
+                        object_type,
+                        &field.name,
+                        "the @derivedFrom directive must have a `field` argument",
+                    )
+                })?;
+                let target_field = match target_field {
+                    s::Value::String(s) => s,
+                    _ => {
+                        return Err(invalid(
+                            object_type,
+                            &field.name,
+                            "the @derivedFrom `field` argument must be a string",
+                        ));
+                    }
+                };
+
+                // Check that the type we are deriving from exists
+                let target_type_name = field.field_type.get_base_type();
+                let target_fields = object_and_interface_type_fields
+                    .get(target_type_name)
+                    .ok_or_else(|| {
+                        invalid(
+                            object_type,
+                            &field.name,
+                            "type must be an existing entity or interface",
+                        )
+                    })?;
+
+                // Check that the type we are deriving from has a field with the
+                // right name and type
+                let target_field = target_fields
+                    .iter()
+                    .find(|field| field.name.eq(target_field))
+                    .ok_or_else(|| {
+                        let msg = format!(
+                            "field `{}` does not exist on type `{}`",
+                            target_field, target_type_name
+                        );
+                        invalid(object_type, &field.name, &msg)
+                    })?;
+
+                // The field we are deriving from has to point back to us; as an
+                // exception, we allow deriving from the `id` of another type.
+                // For that, we will wind up comparing the `id`s of the two types
+                // 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()
+                    && !interface_types
+                        .iter()
+                        .any(|iface| target_field_type.eq(iface.as_str()))
+                {
+                    fn type_signatures(name: &str) -> Vec<String> {
+                        vec![
+                            format!("{}", name),
+                            format!("{}!", name),
+                            format!("[{}!]", name),
+                            format!("[{}!]!", name),
+                        ]
+                    }
+
+                    let mut valid_types = type_signatures(&object_type.name);
+                    valid_types.extend(
+                        interface_types
+                            .iter()
+                            .flat_map(|iface| type_signatures(iface)),
+                    );
+                    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,
+                    );
+                    return Err(invalid(object_type, &field.name, &msg));
+                }
+            }
+            Ok(())
+        }
+
+        fn validate_interface_id_type(&self) -> Result<(), SchemaValidationError> {
+            for (intf, obj_types) in &self.schema.types_for_interface {
+                let id_types: HashSet<&str> = HashSet::from_iter(
+                    obj_types
+                        .iter()
+                        .filter_map(|obj_type| obj_type.field(&ID))
+                        .map(|f| f.field_type.get_base_type())
+                        .map(|name| if name == "ID" { "String" } else { name }),
+                );
+                if id_types.len() > 1 {
+                    return Err(SchemaValidationError::InterfaceImplementorsMixId(
+                        intf.to_string(),
+                        id_types.iter().join(", "),
+                    ));
+                }
+            }
+            Ok(())
+        }
+
+        fn validate_aggregations(&self) -> Vec<SchemaValidationError> {
+            /// Aggregations must have an `id` field with the same type as
+            /// the id field for the source type
+            fn valid_id_field(
+                agg_type: &s::ObjectType,
+                src_id_type: IdType,
+                errors: &mut Vec<Err>,
+            ) {
+                match IdType::try_from(agg_type) {
+                    Ok(agg_id_type) => {
+                        if agg_id_type != src_id_type {
+                            errors.push(Err::IllegalIdType(format!(
+                                "The type of the `id` field for aggregation {} must be {}, the same as in the source, but is {}",
+                                agg_type.name, src_id_type, agg_id_type
+                            )))
+                        }
+                    }
+                    Err(e) => errors.push(Err::IllegalIdType(e.to_string())),
+                }
+            }
+
+            fn no_derived_fields(agg_type: &s::ObjectType, errors: &mut Vec<Err>) {
+                for field in &agg_type.fields {
+                    if field.find_directive("derivedFrom").is_some() {
+                        errors.push(Err::AggregationDerivedField(
+                            agg_type.name.to_owned(),
+                            field.name.to_owned(),
+                        ));
+                    }
+                }
+            }
+
+            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_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(),
+                                ))
+                            }
+                        }
+                    })
+                    .filter_map(|err| err.err());
+                errors.extend(errs);
+            }
+
+            /// * `source` is an existing timeseries type
+            /// * all non-aggregate fields are also fields on the `source`
+            ///   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`)
+            fn aggregate_directive(
+                schema: &Schema,
+                agg_type: &s::ObjectType,
+                errors: &mut Vec<Err>,
+            ) {
+                let source = match agg_type
+                    .find_directive(kw::AGGREGATION)
+                    .and_then(|dir| dir.argument(kw::SOURCE))
+                {
+                    Some(s::Value::String(source)) => source,
+                    Some(_) => {
+                        errors.push(Err::AggregationInvalidSource(agg_type.name.to_owned()));
+                        return;
+                    }
+                    None => {
+                        errors.push(Err::AggregationMissingSource(agg_type.name.to_owned()));
+                        return;
+                    }
+                };
+                let source = match schema.entity_types.iter().find(|ty| &ty.name == source) {
+                    Some(source) => *source,
+                    None => {
+                        errors.push(Err::AggregationUnknownSource(
+                            agg_type.name.to_owned(),
+                            source.to_owned(),
+                        ));
+                        return;
+                    }
+                };
+                match source
+                    .find_directive(kw::ENTITY)
+                    .and_then(|dir| dir.argument(kw::TIMESERIES))
+                {
+                    Some(s::Value::Boolean(true)) => { /* ok */ }
+                    Some(_) | None => {
+                        errors.push(Err::AggregationNonTimeseriesSource(
+                            agg_type.name.to_owned(),
+                            source.name.to_owned(),
+                        ));
+                        return;
+                    }
+                }
+                match IdType::try_from(source) {
+                    Ok(id_type) => valid_id_field(agg_type, id_type, errors),
+                    Err(e) => errors.push(Err::IllegalIdType(e.to_string())),
+                };
+
+                let mut has_aggregate = false;
+                for field in agg_type
+                    .fields
+                    .iter()
+                    .filter(|field| field.name != ID.as_str() && field.name != kw::TIMESTAMP)
+                {
+                    match field.find_directive(kw::AGGREGATE) {
+                        Some(agg) => {
+                            // The source field for an aggregate
+                            // must have the same type as the arg
+                            has_aggregate = true;
+                            let func = match agg.argument(kw::FUNC) {
+                                Some(s::Value::Enum(func) | s::Value::String(func)) => func,
+                                Some(v) => {
+                                    errors.push(Err::AggregationInvalidFn(
+                                        agg_type.name.to_owned(),
+                                        field.name.to_owned(),
+                                        v.to_string(),
+                                    ));
+                                    continue;
+                                }
+                                None => {
+                                    errors.push(Err::AggregationMissingFn(
+                                        agg_type.name.to_owned(),
+                                        field.name.to_owned(),
+                                    ));
+                                    continue;
+                                }
+                            };
+                            let func = match func.parse::<AggregateFn>() {
+                                Ok(func) => func,
+                                Err(_) => {
+                                    errors.push(Err::AggregationInvalidFn(
+                                        agg_type.name.to_owned(),
+                                        field.name.to_owned(),
+                                        func.to_owned(),
+                                    ));
+                                    continue;
+                                }
+                            };
+                            let arg = match agg.argument(kw::ARG) {
+                                Some(s::Value::String(arg)) => arg,
+                                Some(_) => {
+                                    errors.push(Err::AggregationInvalidArg(
+                                        agg_type.name.to_owned(),
+                                        field.name.to_owned(),
+                                    ));
+                                    continue;
+                                }
+                                None => {
+                                    if func.has_arg() {
+                                        errors.push(Err::AggregationMissingArg(
+                                            agg_type.name.to_owned(),
+                                            field.name.to_owned(),
+                                            func.as_str().to_owned(),
+                                        ));
+                                        continue;
+                                    } else {
+                                        // No arg for a function
+                                        // that does not take an arg
+                                        continue;
+                                    }
+                                }
+                            };
+                            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(),
+                                    ));
+                                    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 let Err(mut errs) = sqlexpr::parse(arg, check_ident) {
+                                errors.append(&mut errs);
+                            }
+                        }
+                        None => {
+                            // Non-aggregate fields must have the
+                            // same type as the type in the source
+                            let src_field = match source.field(&field.name) {
+                                Some(src_field) => src_field,
+                                None => {
+                                    errors.push(Err::AggregationUnknownField(
+                                        agg_type.name.to_owned(),
+                                        source.name.to_owned(),
+                                        field.name.to_owned(),
+                                    ));
+                                    continue;
+                                }
+                            };
+                            if field.field_type.get_base_type()
+                                != src_field.field_type.get_base_type()
+                            {
+                                errors.push(Err::AggregationNonMatchingType(
+                                    agg_type.name.to_owned(),
+                                    field.name.to_owned(),
+                                    field.field_type.get_base_type().to_owned(),
+                                    src_field.field_type.get_base_type().to_owned(),
+                                ));
+                            }
+                        }
+                    }
+                }
+                if !has_aggregate {
+                    errors.push(Err::PointlessAggregation(agg_type.name.to_owned()));
+                }
+            }
+
+            fn aggregation_intervals(agg_type: &s::ObjectType, errors: &mut Vec<Err>) {
+                let intervals = match agg_type
+                    .find_directive(kw::AGGREGATION)
+                    .and_then(|dir| dir.argument(kw::INTERVALS))
+                {
+                    Some(s::Value::List(intervals)) => intervals,
+                    Some(_) => {
+                        errors.push(Err::AggregationWrongIntervals(agg_type.name.to_owned()));
+                        return;
+                    }
+                    None => {
+                        errors.push(Err::AggregationMissingIntervals(agg_type.name.to_owned()));
+                        return;
+                    }
+                };
+                let intervals = intervals
+                    .iter()
+                    .map(|interval| match interval {
+                        s::Value::String(s) => Ok(s),
+                        _ => Err(Err::AggregationWrongIntervals(agg_type.name.to_owned())),
+                    })
+                    .collect::<Result<Vec<_>, _>>();
+                let intervals = match intervals {
+                    Ok(intervals) => intervals,
+                    Err(err) => {
+                        errors.push(err);
+                        return;
+                    }
+                };
+                if intervals.is_empty() {
+                    errors.push(Err::AggregationWrongIntervals(agg_type.name.to_owned()));
+                    return;
+                }
+                for interval in intervals {
+                    if interval.parse::<AggregationInterval>().is_err() {
+                        errors.push(Err::AggregationInvalidInterval(
+                            agg_type.name.to_owned(),
+                            interval.to_owned(),
+                        ));
+                    }
+                }
+            }
+
+            if !self.aggregations.is_empty() && self.spec_version < &SPEC_VERSION_1_1_0 {
+                return vec![SchemaValidationError::AggregationsNotSupported(
+                    self.spec_version.clone(),
+                )];
+            }
+
+            let mut errors = Vec::new();
+            for agg_type in &self.aggregations {
+                // FIXME: We could make it so that we silently add the `id` and
+                // `timestamp` fields instead of requiring users to always
+                // list them.
+                if let Some(err) = Self::valid_timestamp_field(agg_type) {
+                    errors.push(err);
+                }
+                no_derived_fields(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);
+            }
+            errors
+        }
+
+        /// 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,
+                None => {
+                    return Some(Err::TimestampFieldMissing(agg_type.name.to_owned()));
+                }
+            };
+
+            match field.field_type.value_type() {
+                Ok(ValueType::Timestamp) => None,
+                Ok(_) | Err(_) => Some(Err::InvalidTimestampType(
+                    agg_type.name.to_owned(),
+                    field.field_type.get_base_type().to_owned(),
+                )),
+            }
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use std::ffi::OsString;
+
+        use regex::Regex;
+
+        use crate::{data::subgraph::LATEST_VERSION, prelude::DeploymentHash};
+
+        use super::*;
+
+        fn parse(schema: &str) -> BaseSchema {
+            let hash = DeploymentHash::new("test").unwrap();
+            BaseSchema::parse(schema, hash).unwrap()
+        }
+
+        fn validate(schema: &BaseSchema) -> Result<(), Vec<SchemaValidationError>> {
+            super::validate(LATEST_VERSION, schema)
+        }
+
+        #[test]
+        fn object_types_have_id() {
+            const NO_ID: &str = "type User @entity { name: String! }";
+            const ID_BIGINT: &str = "type User @entity { id: BigInt! }";
+            const INTF_NO_ID: &str = "interface Person { name: String! }";
+            const ROOT_SCHEMA: &str = "type _Schema_";
+
+            let res = validate(&parse(NO_ID));
+            assert_eq!(
+                res,
+                Err(vec![SchemaValidationError::IdFieldMissing(
+                    "User".to_string()
+                )])
+            );
+
+            let res = validate(&parse(ID_BIGINT));
+            let errs = res.unwrap_err();
+            assert_eq!(1, errs.len());
+            assert!(matches!(errs[0], SchemaValidationError::IllegalIdType(_)));
+
+            let res = validate(&parse(INTF_NO_ID));
+            assert_eq!(Ok(()), res);
+
+            let res = validate(&parse(ROOT_SCHEMA));
+            assert_eq!(Ok(()), res);
+        }
+
+        #[test]
+        fn interface_implementations_id_type() {
+            fn check_schema(bar_id: &str, baz_id: &str, ok: bool) {
+                let schema = format!(
+                    "interface Foo {{ x: Int }}
+             type Bar implements Foo @entity {{
+                id: {bar_id}!
+                x: Int
+             }}
+
+             type Baz implements Foo @entity {{
+                id: {baz_id}!
+                x: Int
+            }}"
+                );
+                let schema =
+                    BaseSchema::parse(&schema, DeploymentHash::new("dummy").unwrap()).unwrap();
+                let res = validate(&schema);
+                if ok {
+                    assert!(res.is_ok());
+                } else {
+                    assert!(res.is_err());
+                    assert!(matches!(
+                        res.unwrap_err()[0],
+                        SchemaValidationError::InterfaceImplementorsMixId(_, _)
+                    ));
+                }
+            }
+            check_schema("ID", "ID", true);
+            check_schema("ID", "String", true);
+            check_schema("ID", "Bytes", false);
+            check_schema("Bytes", "String", false);
+        }
+
+        #[test]
+        fn test_derived_from_validation() {
+            const OTHER_TYPES: &str = "
+type B @entity { id: ID! }
+type C @entity { id: ID! }
+type D @entity { id: ID! }
+type E @entity { id: ID! }
+type F @entity { id: ID! }
+type G @entity { id: ID! a: BigInt }
+type H @entity { id: ID! a: A! }
+# This sets up a situation where we need to allow `Transaction.from` to
+# point to an interface because of `Account.txn`
+type Transaction @entity { from: Address! }
+interface Address { txn: Transaction! @derivedFrom(field: \"from\") }
+type Account implements Address @entity { id: ID!, txn: Transaction! @derivedFrom(field: \"from\") }";
+
+            fn validate(field: &str, errmsg: &str) {
+                let raw = format!("type A @entity {{ id: ID!\n {} }}\n{}", field, OTHER_TYPES);
+
+                let document = s::parse_schema(&raw)
+                    .expect("Failed to parse raw schema")
+                    .into_static();
+                let schema = BaseSchema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
+                let schema = Schema::new(LATEST_VERSION, &schema);
+                match schema.validate_derived_from() {
+                    Err(ref e) => match e {
+                        SchemaValidationError::InvalidDerivedFrom(_, _, msg) => {
+                            assert_eq!(errmsg, msg)
+                        }
+                        _ => panic!("expected variant SchemaValidationError::DerivedFromInvalid"),
+                    },
+                    Ok(_) => {
+                        if errmsg != "ok" {
+                            panic!("expected validation for `{}` to fail", field)
+                        }
+                    }
+                }
+            }
+
+            validate(
+                "b: B @derivedFrom(field: \"a\")",
+                "field `a` does not exist on type `B`",
+            );
+            validate(
+                "c: [C!]! @derivedFrom(field: \"a\")",
+                "field `a` does not exist on type `C`",
+            );
+            validate(
+                "d: D @derivedFrom",
+                "the @derivedFrom directive must have a `field` argument",
+            );
+            validate(
+                "e: E @derivedFrom(attr: \"a\")",
+                "the @derivedFrom directive must have a `field` argument",
+            );
+            validate(
+                "f: F @derivedFrom(field: 123)",
+                "the @derivedFrom `field` argument must be a string",
+            );
+            validate(
+                "g: G @derivedFrom(field: \"a\")",
+                "field `a` on type `G` must have one of the following types: A, A!, [A!], [A!]!",
+            );
+            validate("h: H @derivedFrom(field: \"a\")", "ok");
+            validate(
+                "i: NotAType @derivedFrom(field: \"a\")",
+                "type must be an existing entity or interface",
+            );
+            validate("j: B @derivedFrom(field: \"id\")", "ok");
+        }
+
+        #[test]
+        fn test_reserved_type_with_fields() {
+            const ROOT_SCHEMA: &str = "
+type _Schema_ { id: ID! }";
+
+            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_schema_type_has_no_fields().expect_err(
+                    "Expected validation to fail due to fields defined on the reserved type"
+                ),
+                SchemaValidationError::SchemaTypeWithFields
+            )
+        }
+
+        #[test]
+        fn test_reserved_type_directives() {
+            const ROOT_SCHEMA: &str = "
+type _Schema_ @illegal";
+
+            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_directives_on_schema_type().expect_err(
+                    "Expected validation to fail due to extra imports defined on the reserved type"
+                ),
+                SchemaValidationError::InvalidSchemaTypeDirectives
+            )
+        }
+
+        #[test]
+        fn test_enums_pass_field_validation() {
+            const ROOT_SCHEMA: &str = r#"
+enum Color {
+  RED
+  GREEN
+}
+
+type A @entity {
+  id: ID!
+  color: Color
+}"#;
+
+            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);
+        }
+
+        #[test]
+        fn test_reserved_types_validation() {
+            let reserved_types = [
+                // Built-in scalars
+                "Boolean",
+                "ID",
+                "Int",
+                "BigDecimal",
+                "String",
+                "Bytes",
+                "BigInt",
+                // Reserved keywords
+                "Query",
+                "Subscription",
+            ];
+
+            let dummy_hash = DeploymentHash::new("dummy").unwrap();
+
+            for reserved_type in reserved_types {
+                let schema = format!(
+                    "type {} @entity {{ id: String! _: Boolean }}\n",
+                    reserved_type
+                );
+
+                let schema = BaseSchema::parse(&schema, dummy_hash.clone()).unwrap();
+
+                let errors = validate(&schema).unwrap_err();
+                for error in errors {
+                    assert!(matches!(
+                        error,
+                        SchemaValidationError::UsageOfReservedTypes(_)
+                    ))
+                }
+            }
+        }
+
+        #[test]
+        fn test_reserved_filter_and_group_by_types_validation() {
+            const SCHEMA: &str = r#"
+    type Gravatar @entity {
+        id: String!
+        _: Boolean
+      }
+    type Gravatar_filter @entity {
+        id: String!
+        _: Boolean
+    }
+    type Gravatar_orderBy @entity {
+        id: String!
+        _: Boolean
+    }
+    "#;
+
+            let dummy_hash = DeploymentHash::new("dummy").unwrap();
+
+            let schema = BaseSchema::parse(SCHEMA, dummy_hash).unwrap();
+
+            let errors = validate(&schema).unwrap_err();
+
+            // The only problem in the schema is the usage of reserved types
+            assert_eq!(errors.len(), 1);
+
+            assert!(matches!(
+                &errors[0],
+                SchemaValidationError::UsageOfReservedTypes(Strings(_))
+            ));
+
+            // We know this will match due to the assertion above
+            match &errors[0] {
+                SchemaValidationError::UsageOfReservedTypes(Strings(reserved_types)) => {
+                    let expected_types: Vec<String> =
+                        vec!["Gravatar_filter".into(), "Gravatar_orderBy".into()];
+                    assert_eq!(reserved_types, &expected_types);
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        #[test]
+        fn test_fulltext_directive_validation() {
+            const SCHEMA: &str = r#"
+type _Schema_ @fulltext(
+  name: "metadata"
+  language: en
+  algorithm: rank
+  include: [
+    {
+      entity: "Gravatar",
+      fields: [
+        { name: "displayName"},
+        { name: "imageUrl"},
+      ]
+    }
+  ]
+)
+type Gravatar @entity {
+  id: ID!
+  owner: Bytes!
+  displayName: String!
+  imageUrl: String!
+}"#;
+
+            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![]);
+        }
+
+        #[test]
+        fn agg() {
+            fn parse_annotation(file_name: &str, line: &str) -> (bool, Version, String) {
+                let bad_annotation = |msg: &str| -> ! {
+                    panic!("test case {file_name} has an invalid annotation `{line}`: {msg}")
+                };
+
+                let header_rx = Regex::new(
+                    r"^#\s*(?P<exp>valid|fail)\s*(@\s*(?P<version>[0-9.]+))?\s*:\s*(?P<rest>.*)$",
+                )
+                .unwrap();
+                let Some(caps) = header_rx.captures(line) else {
+                    bad_annotation("must match the regex `^# (valid|fail) (@ ([0-9.]+))? : .*$`")
+                };
+                let valid = match caps.name("exp").map(|mtch| mtch.as_str()) {
+                    Some("valid") => true,
+                    Some("fail") => false,
+                    Some(other) => {
+                        bad_annotation(&format!("expected 'valid' or 'fail' but got {other}"))
+                    }
+                    None => bad_annotation("missing 'valid' or 'fail'"),
+                };
+                let version = match caps
+                    .name("version")
+                    .map(|mtch| Version::parse(mtch.as_str()))
+                    .transpose()
+                {
+                    Ok(Some(version)) => version,
+                    Ok(None) => LATEST_VERSION.clone(),
+                    Err(err) => bad_annotation(&err.to_string()),
+                };
+                let rest = match caps.name("rest").map(|mtch| mtch.as_str()) {
+                    Some(rest) => rest.to_string(),
+                    None => bad_annotation("missing message"),
+                };
+                (valid, version, rest)
+            }
+
+            // The test files for this test are all GraphQL schemas that
+            // must all have a comment as the first line. For a test that is
+            // expected to succeed, the comment must be `# valid: ..`. For
+            // tests that are expected to fail validation, the comment must
+            // be `# fail: <err>` where <err> must appear in one of the
+            // error messages when they are formatted as debug output.
+            let dir = std::path::PathBuf::from_iter([
+                env!("CARGO_MANIFEST_DIR"),
+                "src",
+                "schema",
+                "test_schemas",
+            ]);
+            let files = {
+                let mut files = std::fs::read_dir(dir)
+                    .unwrap()
+                    .filter_map(|entry| entry.ok())
+                    .map(|entry| entry.path())
+                    .filter(|path| path.extension() == Some(OsString::from("graphql").as_os_str()))
+                    .collect::<Vec<_>>();
+                files.sort();
+                files
+            };
+            for file in files {
+                let schema = std::fs::read_to_string(&file).unwrap();
+                let file_name = file.file_name().unwrap().to_str().unwrap();
+                let first_line = schema.lines().next().unwrap();
+                let (valid, version, msg) = parse_annotation(file_name, first_line);
+                let schema = {
+                    let hash = DeploymentHash::new("test").unwrap();
+                    match BaseSchema::parse(&schema, hash) {
+                        Ok(schema) => schema,
+                        Err(e) => panic!("test case {file_name} failed to parse: {e}"),
+                    }
+                };
+                let res = super::validate(&version, &schema);
+                match (valid, res) {
+                    (true, Err(errs)) => {
+                        panic!("{file_name} should validate: {errs:?}",);
+                    }
+                    (false, Ok(_)) => {
+                        panic!("{file_name} should fail validation");
+                    }
+                    (false, Err(errs)) => {
+                        if errs.iter().any(|err| {
+                            err.to_string().contains(&msg) || format!("{err:?}").contains(&msg)
+                        }) {
+                            // 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}`: \n\
+                                    actual: {errs:?}\n\
+                                    or {msgs:?}",
+                            )
+                        }
+                    }
+                    (true, Ok(_)) => {
+                        // println!("{file_name} validated as expected")
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        data::store::ID,
+        prelude::DeploymentHash,
+        schema::{
+            EntityType,
+            input::{POI_DIGEST, POI_OBJECT},
+        },
+    };
+
+    use super::InputSchema;
+
+    const SCHEMA: &str = r#"
+      type Thing @entity {
+        id: ID!
+        name: String!
+      }
+
+      interface Animal {
+        name: String!
+      }
+
+      type Hippo implements Animal @entity {
+        id: ID!
+        name: String!
+      }
+
+      type Rhino implements Animal @entity {
+        id: ID!
+        name: String!
+      }
+
+      type HippoData @entity(timeseries: true) {
+        id: Int8!
+        hippo: Hippo!
+        timestamp: Timestamp!
+        weight: BigDecimal!
+      }
+
+      type HippoStats @aggregation(intervals: ["hour"], source: "HippoData") {
+        id: Int8!
+        timestamp: Timestamp!
+        hippo: Hippo!
+        maxWeight: BigDecimal! @aggregate(fn: "max", arg:"weight")
+      }
+    "#;
+
+    fn make_schema() -> InputSchema {
+        let id = DeploymentHash::new("test").unwrap();
+        InputSchema::parse_latest(SCHEMA, id).unwrap()
+    }
+
+    #[test]
+    fn entity_type() {
+        let schema = make_schema();
+
+        assert_eq!("Thing", schema.entity_type("Thing").unwrap().typename());
+
+        let poi = schema.entity_type(POI_OBJECT).unwrap();
+        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());
+
+        assert!(schema.entity_type("NonExistent").is_err());
+    }
+
+    #[test]
+    fn share_interfaces() {
+        const SCHEMA: &str = r#"
+    interface Animal {
+        name: String!
+    }
+
+    type Dog implements Animal @entity {
+        id: ID!
+        name: String!
+    }
+
+    type Cat implements Animal @entity {
+        id: ID!
+        name: String!
+    }
+
+    type Person @entity {
+        id: ID!
+        name: String!
+    }
+        "#;
+
+        let id = DeploymentHash::new("test").unwrap();
+        let schema = InputSchema::parse_latest(SCHEMA, id).unwrap();
+
+        let dog = schema.entity_type("Dog").unwrap();
+        let cat = schema.entity_type("Cat").unwrap();
+        let person = schema.entity_type("Person").unwrap();
+        assert_eq!(vec![cat.clone()], dog.share_interfaces().unwrap());
+        assert_eq!(vec![dog], cat.share_interfaces().unwrap());
+        assert!(person.share_interfaces().unwrap().is_empty());
+    }
+
+    #[test]
+    fn intern() {
+        static NAMES: &[&str] = &[
+            "Thing",
+            "Animal",
+            "Hippo",
+            "HippoStats",
+            "HippoStats_hour",
+            "id",
+            "name",
+            "timestamp",
+            "hippo",
+            "maxWeight",
+        ];
+
+        let schema = make_schema();
+        let pool = schema.pool();
+
+        for name in NAMES {
+            assert!(pool.lookup(name).is_some(), "The string {name} is interned");
+        }
+    }
+
+    #[test]
+    fn object_type() {
+        let schema = make_schema();
+        let pool = schema.pool();
+
+        let animal = pool.lookup("Animal").unwrap();
+        let hippo = pool.lookup("Hippo").unwrap();
+        let rhino = pool.lookup("Rhino").unwrap();
+        let hippo_data = pool.lookup("HippoData").unwrap();
+        let hippo_stats_hour = pool.lookup("HippoStats_hour").unwrap();
+
+        let animal_ent = EntityType::new(schema.clone(), animal);
+        // Interfaces don't have an object type
+        assert!(animal_ent.object_type().is_err());
+
+        let hippo_ent = EntityType::new(schema.clone(), hippo);
+        let hippo_obj = hippo_ent.object_type().unwrap();
+        assert_eq!(hippo_obj.name, hippo);
+        assert!(!hippo_ent.is_immutable());
+
+        let rhino_ent = EntityType::new(schema.clone(), rhino);
+        assert_eq!(hippo_ent.share_interfaces().unwrap(), vec![rhino_ent]);
+
+        let hippo_data_ent = EntityType::new(schema.clone(), hippo_data);
+        let hippo_data_obj = hippo_data_ent.object_type().unwrap();
+        assert_eq!(hippo_data_obj.name, hippo_data);
+        assert!(hippo_data_ent.share_interfaces().unwrap().is_empty());
+        assert!(hippo_data_ent.is_immutable());
+
+        let hippo_stats_hour_ent = EntityType::new(schema.clone(), hippo_stats_hour);
+        let hippo_stats_hour_obj = schema.object_type(hippo_stats_hour).unwrap();
+        assert_eq!(hippo_stats_hour_obj.name, hippo_stats_hour);
+        assert!(hippo_stats_hour_ent.share_interfaces().unwrap().is_empty());
+        assert!(hippo_stats_hour_ent.is_immutable());
+    }
+}
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/data/introspection.graphql b/graph/src/schema/introspection.graphql
similarity index 78%
rename from graph/src/data/introspection.graphql
rename to graph/src/schema/introspection.graphql
index c3d2c1b8842..d34b4d67e5b 100644
--- a/graph/src/data/introspection.graphql
+++ b/graph/src/schema/introspection.graphql
@@ -1,9 +1,12 @@
 # A GraphQL introspection schema for inclusion in a subgraph's API schema.
-# The schema differs from the 'standard' introspection schema in that it
-# doesn't have a Query type nor scalar declarations as they come from the
-# API schema.
+
+type Query {
+  __schema: __Schema!
+  __type(name: String!): __Type
+}
 
 type __Schema {
+  description: String
   types: [__Type!]!
   queryType: __Type!
   mutationType: __Type
@@ -33,12 +36,15 @@ type __Type {
 
   # NON_NULL and LIST only
   ofType: __Type
+
+  # may be non-null for custom SCALAR, otherwise null.
+  specifiedByURL: String
 }
 
 type __Field {
   name: String!
   description: String
-  args: [__InputValue!]!
+  args(includeDeprecated: Boolean = false): [__InputValue!]!
   type: __Type!
   isDeprecated: Boolean!
   deprecationReason: String
@@ -49,6 +55,8 @@ type __InputValue {
   description: String
   type: __Type!
   defaultValue: String
+  isDeprecated: Boolean!
+  deprecationReason: String
 }
 
 type __EnumValue {
@@ -73,7 +81,8 @@ type __Directive {
   name: String!
   description: String
   locations: [__DirectiveLocation!]!
-  args: [__InputValue!]!
+  args(includeDeprecated: Boolean = false): [__InputValue!]!
+  isRepeatable: Boolean!
 }
 
 enum __DirectiveLocation {
@@ -84,6 +93,7 @@ enum __DirectiveLocation {
   FRAGMENT_DEFINITION
   FRAGMENT_SPREAD
   INLINE_FRAGMENT
+  VARIABLE_DEFINITION
   SCHEMA
   SCALAR
   OBJECT
@@ -95,4 +105,4 @@ enum __DirectiveLocation {
   ENUM_VALUE
   INPUT_OBJECT
   INPUT_FIELD_DEFINITION
-}
\ No newline at end of file
+}
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/graphql/src/schema/meta.graphql b/graph/src/schema/meta.graphql
similarity index 77%
rename from graphql/src/schema/meta.graphql
rename to graph/src/schema/meta.graphql
index b2b5ffd9a87..729874d8b9d 100644
--- a/graphql/src/schema/meta.graphql
+++ b/graph/src/schema/meta.graphql
@@ -1,6 +1,9 @@
 # GraphQL core functionality
 scalar Boolean
 scalar ID
+"""
+4 bytes signed integer
+"""
 scalar Int
 scalar Float
 scalar String
@@ -19,9 +22,18 @@ directive @subgraphId(id: String!) on OBJECT
 "creates a virtual field on the entity that may be queried but cannot be set manually through the mappings API."
 directive @derivedFrom(field: String!) on FIELD_DEFINITION
 
+# Additional scalar types
 scalar BigDecimal
 scalar Bytes
 scalar BigInt
+"""
+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
@@ -55,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
@@ -74,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.
@@ -86,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
new file mode 100644
index 00000000000..0da95598e2e
--- /dev/null
+++ b/graph/src/schema/mod.rs
@@ -0,0 +1,433 @@
+use crate::data::graphql::ext::DocumentExt;
+use crate::data::subgraph::DeploymentHash;
+use crate::prelude::{anyhow, s};
+
+use anyhow::Error;
+use semver::Version;
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+use std::collections::BTreeMap;
+use std::fmt;
+use std::iter::FromIterator;
+
+/// Generate full-fledged API schemas from existing GraphQL schemas.
+mod api;
+
+/// Utilities for working with GraphQL schema ASTs.
+pub mod ast;
+
+mod entity_key;
+mod entity_type;
+mod fulltext;
+pub(crate) mod input;
+
+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(crate) use input::POI_OBJECT;
+pub use input::sqlexpr::{ExprVisitor, VisitExpr};
+pub use input::{
+    Aggregate, AggregateFn, Aggregation, AggregationInterval, AggregationMapping, Field,
+    InputSchema, InterfaceType, ObjectOrInterface, ObjectType, TypeKind, kw,
+};
+
+pub const SCHEMA_TYPE_NAME: &str = "_Schema_";
+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_";
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Strings(Vec<String>);
+
+impl fmt::Display for Strings {
+    fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        let s = self.0.join(", ");
+        write!(f, "{}", s)
+    }
+}
+
+#[derive(Debug, Error, PartialEq, Eq)]
+pub enum SchemaValidationError {
+    #[error("Invalid schema: {0}")]
+    InvalidSchema(String),
+    #[error("Interface `{0}` not defined")]
+    InterfaceUndefined(String),
+
+    #[error("@entity directive missing on the following types: `{0}`")]
+    EntityDirectivesMissing(Strings),
+    #[error("The `{0}` argument of the @entity directive must be a boolean")]
+    EntityDirectiveNonBooleanArgValue(String),
+
+    #[error(
+        "Entity type `{0}` does not satisfy interface `{1}` because it is missing \
+         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"
+    )]
+    InterfaceImplementorsMixId(String, String),
+    #[error("Field `{1}` in type `{0}` has invalid @derivedFrom: {2}")]
+    InvalidDerivedFrom(String, String, String), // (type, field, reason)
+    #[error("The following type names are reserved: `{0}`")]
+    UsageOfReservedTypes(Strings),
+    #[error("_Schema_ type is only for @fulltext and must not have any fields")]
+    SchemaTypeWithFields,
+    #[error("The _Schema_ type only allows @fulltext directives")]
+    InvalidSchemaTypeDirectives,
+    #[error("Type `{0}`, field `{1}`: type `{2}` is not defined")]
+    FieldTypeUnknown(String, String, String), // (type_name, field_name, field_type)
+    #[error("Imported type `{0}` does not exist in the `{1}` schema")]
+    ImportedTypeUndefined(String, String), // (type_name, schema)
+    #[error("Fulltext directive name undefined")]
+    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}"
+    )]
+    FulltextNameCollision(String),
+    #[error("Fulltext language is undefined")]
+    FulltextLanguageUndefined,
+    #[error("Fulltext language is invalid: {0}")]
+    FulltextLanguageInvalid(String),
+    #[error("Fulltext algorithm is undefined")]
+    FulltextAlgorithmUndefined,
+    #[error("Fulltext algorithm is invalid: {0}")]
+    FulltextAlgorithmInvalid(String),
+    #[error("Fulltext include is invalid")]
+    FulltextIncludeInvalid,
+    #[error("Fulltext directive requires an 'include' list")]
+    FulltextIncludeUndefined,
+    #[error("Fulltext 'include' list must contain an object")]
+    FulltextIncludeObjectMissing,
+    #[error(
+        "Fulltext 'include' object must contain 'entity' (String) and 'fields' (List) attributes"
+    )]
+    FulltextIncludeEntityMissingOrIncorrectAttributes,
+    #[error("Fulltext directive includes an entity not found on the subgraph schema")]
+    FulltextIncludedEntityNotFound,
+    #[error("Fulltext include field must have a 'name' attribute")]
+    FulltextIncludedFieldMissingRequiredProperty,
+    #[error("Fulltext entity field, {0}, not found or not a string")]
+    FulltextIncludedFieldInvalid(String),
+    #[error("Type {0} is missing an `id` field")]
+    IdFieldMissing(String),
+    #[error("{0}")]
+    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"
+    )]
+    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(
+        "Aggregation {0} has an invalid argument for `source`: it must be the name of a timeseries"
+    )]
+    AggregationInvalidSource(String),
+    #[error("Aggregation {0} is missing an `intervals` argument for the timeseries directive")]
+    AggregationMissingIntervals(String),
+    #[error(
+        "Aggregation {0} has an invalid argument for `intervals`: it must be a non-empty list of strings"
+    )]
+    AggregationWrongIntervals(String),
+    #[error("Aggregation {0}: the interval {1} is not supported")]
+    AggregationInvalidInterval(String, String),
+    #[error("Aggregation {0} has no @aggregate fields")]
+    PointlessAggregation(String),
+    #[error(
+        "Aggregation {0} has a derived field {1} but fields in aggregations can not be derived"
+    )]
+    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 Timestamp")]
+    InvalidTimestampType(String, String),
+    #[error("Aggregaton {0} uses {1} as the source, but there is no timeseries of that name")]
+    AggregationUnknownSource(String, String),
+    #[error("Aggregation {0} uses {1} as the source, but that type is not a timeseries")]
+    AggregationNonTimeseriesSource(String, String),
+    #[error("Aggregation {0} uses {1} as the source, but that does not have a field {2}")]
+    AggregationUnknownField(String, String, String),
+    #[error("Field {1} in aggregation {0} has type {2} but its type in the source is {3}")]
+    AggregationNonMatchingType(String, String, String, String),
+    #[error("Field {1} in aggregation {0} has an invalid argument for `arg`: it must be a string")]
+    AggregationInvalidArg(String, String),
+    #[error("Field {1} in aggregation {0} uses the unknown aggregation function `{2}`")]
+    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"
+    )]
+    AggregationMissingArg(String, String, String),
+    #[error(
+        "Field {1} in aggregation {0} has `arg` {2} but the source type does not have such a field"
+    )]
+    AggregationUnknownArg(String, String, String),
+    #[error(
+        "Field {1} in aggregation {0} has `arg` {2} of type {3} but it is of the wider type {4} in the source"
+    )]
+    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(
+        "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"
+    )]
+    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.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Schema {
+    pub id: DeploymentHash,
+    pub document: s::Document,
+
+    // Maps type name to implemented interfaces.
+    pub interfaces_for_type: BTreeMap<String, Vec<s::InterfaceType>>,
+
+    // Maps an interface name to the list of entities that implement it.
+    pub types_for_interface: BTreeMap<String, Vec<s::ObjectType>>,
+}
+
+impl Schema {
+    /// Create a new schema. The document must already have been validated
+    //
+    // TODO: The way some validation is expected to be done beforehand, and
+    // some is done here makes it incredibly murky whether a `Schema` is
+    // fully validated. The code should be changed to make sure that a
+    // `Schema` is always fully valid
+    pub fn new(id: DeploymentHash, document: s::Document) -> Result<Self, SchemaValidationError> {
+        let (interfaces_for_type, types_for_interface) = Self::collect_interfaces(&document)?;
+
+        let mut schema = Schema {
+            id: id.clone(),
+            document,
+            interfaces_for_type,
+            types_for_interface,
+        };
+
+        schema.add_subgraph_id_directives(id);
+
+        Ok(schema)
+    }
+
+    fn collect_interfaces(
+        document: &s::Document,
+    ) -> Result<
+        (
+            BTreeMap<String, Vec<s::InterfaceType>>,
+            BTreeMap<String, Vec<s::ObjectType>>,
+        ),
+        SchemaValidationError,
+    > {
+        // Initialize with an empty vec for each interface, so we don't
+        // miss interfaces that have no implementors.
+        let mut types_for_interface =
+            BTreeMap::from_iter(document.definitions.iter().filter_map(|d| match d {
+                s::Definition::TypeDefinition(s::TypeDefinition::Interface(t)) => {
+                    Some((t.name.to_string(), vec![]))
+                }
+                _ => None,
+            }));
+        let mut interfaces_for_type = BTreeMap::<_, Vec<_>>::new();
+
+        for object_type in document.get_object_type_definitions() {
+            for implemented_interface in &object_type.implements_interfaces {
+                let interface_type = document
+                    .definitions
+                    .iter()
+                    .find_map(|def| match def {
+                        s::Definition::TypeDefinition(s::TypeDefinition::Interface(i))
+                            if i.name.eq(implemented_interface) =>
+                        {
+                            Some(i.clone())
+                        }
+                        _ => None,
+                    })
+                    .ok_or_else(|| {
+                        SchemaValidationError::InterfaceUndefined(implemented_interface.clone())
+                    })?;
+
+                Self::validate_interface_implementation(object_type, &interface_type)?;
+
+                interfaces_for_type
+                    .entry(object_type.name.to_owned())
+                    .or_default()
+                    .push(interface_type);
+                types_for_interface
+                    .get_mut(implemented_interface)
+                    .unwrap()
+                    .push(object_type.clone());
+            }
+        }
+
+        Ok((interfaces_for_type, types_for_interface))
+    }
+
+    pub fn parse(raw: &str, id: DeploymentHash) -> Result<Self, Error> {
+        let document = s::parse_schema(raw)?.into_static();
+
+        Schema::new(id, document).map_err(Into::into)
+    }
+
+    /// Returned map has one an entry for each interface in the schema.
+    pub fn types_for_interface(&self) -> &BTreeMap<String, Vec<s::ObjectType>> {
+        &self.types_for_interface
+    }
+
+    /// Returns `None` if the type implements no interfaces.
+    pub fn interfaces_for_type(&self, type_name: &str) -> Option<&Vec<s::InterfaceType>> {
+        self.interfaces_for_type.get(type_name)
+    }
+
+    // Adds a @subgraphId(id: ...) directive to object/interface/enum types in the schema.
+    pub fn add_subgraph_id_directives(&mut self, id: DeploymentHash) {
+        for definition in self.document.definitions.iter_mut() {
+            let subgraph_id_argument = (String::from("id"), s::Value::String(id.to_string()));
+
+            let subgraph_id_directive = s::Directive {
+                name: "subgraphId".to_string(),
+                position: s::Pos::default(),
+                arguments: vec![subgraph_id_argument],
+            };
+
+            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)
+                    }
+                    s::TypeDefinition::Interface(interface_type) => {
+                        (&interface_type.name, &mut interface_type.directives)
+                    }
+                    s::TypeDefinition::Enum(enum_type) => {
+                        (&enum_type.name, &mut enum_type.directives)
+                    }
+                    s::TypeDefinition::Scalar(scalar_type) => {
+                        (&scalar_type.name, &mut scalar_type.directives)
+                    }
+                    s::TypeDefinition::InputObject(input_object_type) => {
+                        (&input_object_type.name, &mut input_object_type.directives)
+                    }
+                    s::TypeDefinition::Union(union_type) => {
+                        (&union_type.name, &mut union_type.directives)
+                    }
+                };
+
+                if !name.eq(SCHEMA_TYPE_NAME)
+                    && !directives
+                        .iter()
+                        .any(|directive| directive.name.eq("subgraphId"))
+                {
+                    directives.push(subgraph_id_directive);
+                }
+            };
+        }
+    }
+
+    /// Validate that `object` implements `interface`.
+    fn validate_interface_implementation(
+        object: &s::ObjectType,
+        interface: &s::InterfaceType,
+    ) -> Result<(), SchemaValidationError> {
+        // Check that all fields in the interface exist in the object with same name and type.
+        let mut missing_fields = vec![];
+        for i in &interface.fields {
+            if !object
+                .fields
+                .iter()
+                .any(|o| o.name.eq(&i.name) && o.field_type.eq(&i.field_type))
+            {
+                missing_fields.push(i.to_string().trim().to_owned());
+            }
+        }
+        if !missing_fields.is_empty() {
+            Err(SchemaValidationError::InterfaceFieldsMissing(
+                object.name.clone(),
+                interface.name.clone(),
+                Strings(missing_fields),
+            ))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn subgraph_schema_object_type(&self) -> Option<&s::ObjectType> {
+        self.document
+            .get_object_type_definitions()
+            .into_iter()
+            .find(|object_type| object_type.name.eq(SCHEMA_TYPE_NAME))
+    }
+}
+
+#[test]
+fn non_existing_interface() {
+    let schema = "type Foo implements Bar @entity { foo: Int }";
+    let res = Schema::parse(schema, DeploymentHash::new("dummy").unwrap());
+    let error = res
+        .unwrap_err()
+        .downcast::<SchemaValidationError>()
+        .unwrap();
+    assert_eq!(
+        error,
+        SchemaValidationError::InterfaceUndefined("Bar".to_owned())
+    );
+}
+
+#[test]
+fn invalid_interface_implementation() {
+    let schema = "
+        interface Foo {
+            x: Int,
+            y: Int
+        }
+
+        type Bar implements Foo @entity {
+            x: Boolean
+        }
+    ";
+    let res = Schema::parse(schema, DeploymentHash::new("dummy").unwrap());
+    assert_eq!(
+        res.unwrap_err().to_string(),
+        "Entity type `Bar` does not satisfy interface `Foo` because it is missing \
+         the following fields: x: Int, y: Int",
+    );
+}
diff --git a/graph/src/schema/test_schemas/no_aggregations.graphql b/graph/src/schema/test_schemas/no_aggregations.graphql
new file mode 100644
index 00000000000..31fee546802
--- /dev/null
+++ b/graph/src/schema/test_schemas/no_aggregations.graphql
@@ -0,0 +1,12 @@
+# fail @ 0.0.9: AggregationsNotSupported
+type Data @entity(timeseries: true) {
+  id: Bytes!
+  timestamp: Timestamp!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: Bytes!
+  timestamp: Timestamp!
+  sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
+}
diff --git a/graph/src/schema/test_schemas/no_int8_id.graphql b/graph/src/schema/test_schemas/no_int8_id.graphql
new file mode 100644
index 00000000000..abdbc56d84f
--- /dev/null
+++ b/graph/src/schema/test_schemas/no_int8_id.graphql
@@ -0,0 +1,5 @@
+# fail @ 0.0.9: IdTypeInt8NotSupported
+type Thing @entity {
+  id: Int8!
+  name: String!
+}
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
new file mode 100644
index 00000000000..5fe0b3a45e9
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_data_mutable.graphql
@@ -0,0 +1,12 @@
+# fail: MutableTimeseries
+type Data @entity(timeseries: true, immutable: false) {
+  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")
+}
diff --git a/graph/src/schema/test_schemas/ts_data_no_id.graphql b/graph/src/schema/test_schemas/ts_data_no_id.graphql
new file mode 100644
index 00000000000..4ab5b65a505
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_data_no_id.graphql
@@ -0,0 +1,11 @@
+# fail: IdFieldMissing
+type Data @entity(timeseries: true) {
+  timestamp: Timestamp!
+  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_data_no_timestamp.graphql b/graph/src/schema/test_schemas/ts_data_no_timestamp.graphql
new file mode 100644
index 00000000000..c01086923a3
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_data_no_timestamp.graphql
@@ -0,0 +1,11 @@
+# fail: TimestampFieldMissing
+type Data @entity(timeseries: true) {
+  id: 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_data_not_timeseries.graphql b/graph/src/schema/test_schemas/ts_data_not_timeseries.graphql
new file mode 100644
index 00000000000..3f9370e2409
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_data_not_timeseries.graphql
@@ -0,0 +1,12 @@
+# fail: AggregationNonTimeseriesSource
+type Data @entity {
+  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")
+}
diff --git a/graph/src/schema/test_schemas/ts_derived_from.graphql b/graph/src/schema/test_schemas/ts_derived_from.graphql
new file mode 100644
index 00000000000..5f9c3633ca6
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_derived_from.graphql
@@ -0,0 +1,20 @@
+# fail: AggregationDerivedField
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Bytes!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..17bac0ee24c
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_empty_intervals.graphql
@@ -0,0 +1,20 @@
+# fail: AggregationWrongIntervals
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: [], source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..39510dd79c7
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_id_type_mismatch.graphql
@@ -0,0 +1,12 @@
+# fail: IllegalIdType
+type Data @entity(timeseries: true) {
+  id: Bytes!
+  timestamp: Timestamp!
+  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_invalid_arg.graphql b/graph/src/schema/test_schemas/ts_invalid_arg.graphql
new file mode 100644
index 00000000000..b9728da0fe5
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_invalid_arg.graphql
@@ -0,0 +1,20 @@
+# fail: AggregationNonNumericArg
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..dedf928e607
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_invalid_fn.graphql
@@ -0,0 +1,19 @@
+# fail: AggregationInvalidFn
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..a74ec505c8c
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_invalid_interval.graphql
@@ -0,0 +1,20 @@
+# fail: AggregationInvalidInterval
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["fortnight"], source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..ce874942eb7
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_missing_arg.graphql
@@ -0,0 +1,19 @@
+# fail: AggregationMissingArg
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..30b9b4a5363
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_missing_fn.graphql
@@ -0,0 +1,19 @@
+# fail: AggregationMissingFn
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..6d8be96b689
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_missing_type.graphql
@@ -0,0 +1,15 @@
+# fail: FieldTypeUnknown
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..2ef903429b2
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_no_aggregate.graphql
@@ -0,0 +1,18 @@
+# fail: PointlessAggregation
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..50878765de8
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_no_id.graphql
@@ -0,0 +1,19 @@
+# fail: IllegalIdType
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  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
new file mode 100644
index 00000000000..42add266d92
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_no_interval.graphql
@@ -0,0 +1,20 @@
+# fail: AggregationMissingIntervals
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..52ad13979c0
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_no_timeseries.graphql
@@ -0,0 +1,8 @@
+# fail: EntityDirectivesMissing
+type Stats {
+  id: 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
new file mode 100644
index 00000000000..6669920746e
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_no_timestamp.graphql
@@ -0,0 +1,19 @@
+# fail: TimestampFieldMissing
+type Token @entity {
+  id: Bytes!
+  stats: Stats!
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: Int8!
+  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.graphql b/graph/src/schema/test_schemas/ts_valid.graphql
new file mode 100644
index 00000000000..274d6463752
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_valid.graphql
@@ -0,0 +1,20 @@
+# valid: Simple example
+type Token @entity {
+  id: Bytes!
+  stats: Stats! @derivedFrom(field: "token")
+}
+
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  token: Token!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+  id: 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
new file mode 100644
index 00000000000..14078ac386d
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_valid_minimal.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")
+}
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
new file mode 100644
index 00000000000..ea6f9e84c48
--- /dev/null
+++ b/graph/src/schema/test_schemas/ts_wrong_interval.graphql
@@ -0,0 +1,12 @@
+# fail: AggregationWrongIntervals
+type Data @entity(timeseries: true) {
+  id: Int8!
+  timestamp: Timestamp!
+  price: BigDecimal!
+}
+
+type Stats @aggregation(intervals: [60, 1440], source: "Data") {
+  id: 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 38e96fd598d..00000000000
--- a/graph/src/substreams/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod codec;
-
-pub use codec::*;
diff --git a/graph/src/substreams/sf.substreams.v1.rs b/graph/src/substreams/sf.substreams.v1.rs
deleted file mode 100644
index 99ab0c0cf58..00000000000
--- a/graph/src/substreams/sf.substreams.v1.rs
+++ /dev/null
@@ -1,817 +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,
-    #[prost(enumeration = "ForkStep", repeated, tag = "4")]
-    pub fork_steps: ::prost::alloc::vec::Vec<i32>,
-    #[prost(string, tag = "5")]
-    pub irreversibility_condition: ::prost::alloc::string::String,
-    /// By default, the engine runs in developer mode, with richer and deeper output,
-    /// * support for multiple `output_modules`, of `store` and `map` kinds
-    /// * support for `initial_store_snapshot_for_modules`
-    /// * log outputs for output modules
-    ///
-    /// With `production_mode`, however, you trade off functionality for high speed, where it:
-    /// * restricts the possible requested `output_modules` to a single mapper module,
-    /// * turns off support for `initial_store_snapshot_for_modules`,
-    /// * still streams output linearly, with a cursor, but at higher speeds
-    /// * and purges log outputs from responses.
-    #[prost(bool, tag = "9")]
-    pub production_mode: bool,
-    #[prost(message, optional, tag = "6")]
-    pub modules: ::core::option::Option<Modules>,
-    #[prost(string, repeated, tag = "7")]
-    pub output_modules: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    #[prost(string, repeated, tag = "8")]
-    pub 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 = "5, 1, 2, 3, 4")]
-    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 = "5")]
-        Session(super::SessionInit),
-        /// Progress of data preparation, before sending in the stream of `data` events.
-        #[prost(message, tag = "1")]
-        Progress(super::ModulesProgress),
-        #[prost(message, tag = "2")]
-        SnapshotData(super::InitialSnapshotData),
-        #[prost(message, tag = "3")]
-        SnapshotComplete(super::InitialSnapshotComplete),
-        #[prost(message, tag = "4")]
-        Data(super::BlockScopedData),
-    }
-}
-#[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,
-}
-#[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, optional, tag = "2")]
-    pub deltas: ::core::option::Option<StoreDeltas>,
-    #[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 BlockScopedData {
-    #[prost(message, repeated, tag = "1")]
-    pub outputs: ::prost::alloc::vec::Vec<ModuleOutput>,
-    #[prost(message, optional, tag = "3")]
-    pub clock: ::core::option::Option<Clock>,
-    #[prost(enumeration = "ForkStep", tag = "6")]
-    pub step: i32,
-    #[prost(string, tag = "10")]
-    pub cursor: ::prost::alloc::string::String,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ModuleOutput {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(string, repeated, tag = "4")]
-    pub debug_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 = "5")]
-    pub debug_logs_truncated: bool,
-    #[prost(bool, tag = "6")]
-    pub cached: bool,
-    #[prost(oneof = "module_output::Data", tags = "2, 3")]
-    pub data: ::core::option::Option<module_output::Data>,
-}
-/// Nested message and enum types in `ModuleOutput`.
-pub mod module_output {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Data {
-        #[prost(message, tag = "2")]
-        MapOutput(::prost_types::Any),
-        /// StoreDeltas 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.
-        #[prost(message, tag = "3")]
-        DebugStoreDeltas(super::StoreDeltas),
-    }
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ModulesProgress {
-    #[prost(message, repeated, tag = "1")]
-    pub modules: ::prost::alloc::vec::Vec<ModuleProgress>,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct ModuleProgress {
-    #[prost(string, tag = "1")]
-    pub name: ::prost::alloc::string::String,
-    #[prost(oneof = "module_progress::Type", tags = "2, 3, 4, 5")]
-    pub r#type: ::core::option::Option<module_progress::Type>,
-}
-/// Nested message and enum types in `ModuleProgress`.
-pub mod module_progress {
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct ProcessedRange {
-        #[prost(message, repeated, tag = "1")]
-        pub processed_ranges: ::prost::alloc::vec::Vec<super::BlockRange>,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Message)]
-    pub struct InitialState {
-        #[prost(uint64, tag = "2")]
-        pub available_up_to_block: u64,
-    }
-    #[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 Failed {
-        #[prost(string, tag = "1")]
-        pub reason: ::prost::alloc::string::String,
-        #[prost(string, repeated, tag = "2")]
-        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 = "3")]
-        pub logs_truncated: bool,
-    }
-    #[allow(clippy::derive_partial_eq_without_eq)]
-    #[derive(Clone, PartialEq, ::prost::Oneof)]
-    pub enum Type {
-        #[prost(message, tag = "2")]
-        ProcessedRanges(ProcessedRange),
-        #[prost(message, tag = "3")]
-        InitialState(InitialState),
-        #[prost(message, tag = "4")]
-        ProcessedBytes(ProcessedBytes),
-        #[prost(message, tag = "5")]
-        Failed(Failed),
-    }
-}
-#[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,
-}
-#[allow(clippy::derive_partial_eq_without_eq)]
-#[derive(Clone, PartialEq, ::prost::Message)]
-pub struct StoreDeltas {
-    #[prost(message, repeated, tag = "1")]
-    pub deltas: ::prost::alloc::vec::Vec<StoreDelta>,
-}
-#[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 Output {
-    #[prost(uint64, tag = "1")]
-    pub block_num: u64,
-    #[prost(string, tag = "2")]
-    pub block_id: ::prost::alloc::string::String,
-    #[prost(message, optional, tag = "4")]
-    pub timestamp: ::core::option::Option<::prost_types::Timestamp>,
-    #[prost(message, optional, tag = "10")]
-    pub value: ::core::option::Option<::prost_types::Any>,
-}
-#[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")]
-        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::Oneof)]
-        pub enum Input {
-            #[prost(message, tag = "1")]
-            Source(Source),
-            #[prost(message, tag = "2")]
-            Map(Map),
-            #[prost(message, tag = "3")]
-            Store(Store),
-        }
-    }
-    #[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),
-    }
-}
-#[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>,
-}
-#[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 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>,
-}
-#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
-#[repr(i32)]
-pub enum ForkStep {
-    StepUnknown = 0,
-    /// Block is new head block of the chain, that is linear with the previous block
-    StepNew = 1,
-    /// Block is now forked and should be undone, it's not the head block of the chain anymore
-    StepUndo = 2,
-    /// Block is now irreversible and can be committed to (finality is chain specific, see chain documentation for more details)
-    StepIrreversible = 4,
-}
-impl ForkStep {
-    /// 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 {
-            ForkStep::StepUnknown => "STEP_UNKNOWN",
-            ForkStep::StepNew => "STEP_NEW",
-            ForkStep::StepUndo => "STEP_UNDO",
-            ForkStep::StepIrreversible => "STEP_IRREVERSIBLE",
-        }
-    }
-    /// Creates an enum from field names used in the ProtoBuf definition.
-    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
-        match value {
-            "STEP_UNKNOWN" => Some(Self::StepUnknown),
-            "STEP_NEW" => Some(Self::StepNew),
-            "STEP_UNDO" => Some(Self::StepUndo),
-            "STEP_IRREVERSIBLE" => Some(Self::StepIrreversible),
-            _ => None,
-        }
-    }
-}
-/// 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.v1.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.v1.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.v1.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 1a5d3b29f78..2f739a96ea9 100644
--- a/graph/src/util/backoff.rs
+++ b/graph/src/util/backoff.rs
@@ -8,6 +8,7 @@ pub struct ExponentialBackoff {
     pub attempt: u64,
     base: Duration,
     ceiling: Duration,
+    jitter: f64,
 }
 
 impl ExponentialBackoff {
@@ -16,6 +17,19 @@ impl ExponentialBackoff {
             attempt: 0,
             base,
             ceiling,
+            jitter: 0.0,
+        }
+    }
+
+    // Create ExponentialBackoff with jitter
+    // jitter is a value between 0.0 and 1.0. Sleep delay will be randomized
+    // within `jitter` of the normal sleep delay
+    pub fn with_jitter(base: Duration, ceiling: Duration, jitter: f64) -> Self {
+        ExponentialBackoff {
+            attempt: 0,
+            base,
+            ceiling,
+            jitter: jitter.clamp(0.0, 1.0),
         }
     }
 
@@ -33,11 +47,12 @@ impl ExponentialBackoff {
     }
 
     pub fn delay(&self) -> Duration {
-        let mut delay = self.base.saturating_mul(1 << self.attempt);
+        let mut delay = self.base.saturating_mul(1u32 << self.attempt.min(31));
         if delay > self.ceiling {
             delay = self.ceiling;
         }
-        delay
+        let jitter = rand::Rng::random_range(&mut rand::rng(), -self.jitter..=self.jitter);
+        delay.mul_f64(1.0 + jitter)
     }
 
     fn next_attempt(&mut self) -> Duration {
@@ -50,3 +65,94 @@ impl ExponentialBackoff {
         self.attempt = 0;
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Instant;
+
+    #[test]
+    fn test_delay() {
+        let mut backoff =
+            ExponentialBackoff::new(Duration::from_millis(500), Duration::from_secs(5));
+
+        // First delay should be base (0.5s)
+        assert_eq!(backoff.next_attempt(), Duration::from_millis(500));
+
+        // Second delay should be 1s (base * 2^1)
+        assert_eq!(backoff.next_attempt(), Duration::from_secs(1));
+
+        // Third delay should be 2s (base * 2^2)
+        assert_eq!(backoff.next_attempt(), Duration::from_secs(2));
+
+        // Fourth delay should be 4s (base * 2^3)
+        assert_eq!(backoff.next_attempt(), Duration::from_secs(4));
+
+        // Seventh delay should be ceiling (5s)
+        assert_eq!(backoff.next_attempt(), Duration::from_secs(5));
+
+        // Eighth delay should also be ceiling (5s)
+        assert_eq!(backoff.next_attempt(), Duration::from_secs(5));
+    }
+
+    #[test]
+    fn test_delay_with_jitter() {
+        let mut backoff = ExponentialBackoff::with_jitter(
+            Duration::from_millis(1000),
+            Duration::from_secs(5),
+            0.1,
+        );
+
+        // Delay should be between 0.5s and 1.5s
+        let delay1 = backoff.delay();
+        assert!(delay1 > Duration::from_millis(900) && delay1 <= Duration::from_millis(1100));
+        let delay2 = backoff.delay();
+        assert!(delay2 > Duration::from_millis(900) && delay2 <= Duration::from_millis(1100));
+
+        // Delays should be random and different
+        assert_ne!(delay1, delay2);
+
+        // Test ceiling
+        backoff.attempt = 123456;
+        let delay = backoff.delay();
+        assert!(delay > Duration::from_millis(4500) && delay <= Duration::from_millis(5500));
+    }
+
+    #[test]
+    fn test_overflow_delay() {
+        let mut backoff =
+            ExponentialBackoff::new(Duration::from_millis(500), Duration::from_secs(45));
+
+        // 31st should be ceiling (45s) without overflowing
+        backoff.attempt = 31;
+        assert_eq!(backoff.next_attempt(), Duration::from_secs(45));
+        assert_eq!(backoff.next_attempt(), Duration::from_secs(45));
+
+        backoff.attempt = 123456;
+        assert_eq!(backoff.next_attempt(), Duration::from_secs(45));
+    }
+
+    #[crate::test]
+    async fn test_sleep_async() {
+        let mut backoff =
+            ExponentialBackoff::new(Duration::from_secs_f32(0.1), Duration::from_secs_f32(0.2));
+
+        let start = Instant::now();
+        backoff.sleep_async().await;
+        let elapsed = start.elapsed();
+
+        assert!(elapsed >= Duration::from_secs_f32(0.1) && elapsed < Duration::from_secs_f32(0.15));
+
+        let start = Instant::now();
+        backoff.sleep_async().await;
+        let elapsed = start.elapsed();
+
+        assert!(elapsed >= Duration::from_secs_f32(0.2) && elapsed < Duration::from_secs_f32(0.25));
+
+        let start = Instant::now();
+        backoff.sleep_async().await;
+        let elapsed = start.elapsed();
+
+        assert!(elapsed >= Duration::from_secs_f32(0.2) && elapsed < Duration::from_secs_f32(0.25));
+    }
+}
diff --git a/graph/src/util/bounded_queue.rs b/graph/src/util/bounded_queue.rs
index 5e0a666d260..6129817eabe 100644
--- a/graph/src/util/bounded_queue.rs
+++ b/graph/src/util/bounded_queue.rs
@@ -86,6 +86,19 @@ impl<T: Clone> BoundedQueue<T> {
         item.clone()
     }
 
+    /// Same as `peek`, but also call `f` while the queue is still locked
+    /// and safe from modification
+    pub async fn peek_with<F>(&self, f: F) -> T
+    where
+        F: FnOnce(&T),
+    {
+        let _permit = self.pop_semaphore.acquire().await.unwrap();
+        let queue = self.queue.lock().unwrap();
+        let item = queue.front().expect("the queue is not empty");
+        f(item);
+        item.clone()
+    }
+
     /// Push an item into the queue. If the queue is currently full this method
     /// blocks until an item is available
     pub async fn push(&self, item: T) {
@@ -129,6 +142,17 @@ impl<T: Clone> BoundedQueue<T> {
         queue.iter().rev().find_map(f)
     }
 
+    /// Execute `f` on the newest entry in the queue atomically, i.e., while
+    /// the queue is locked. The function `f` should therefore not do any
+    /// slow work
+    pub fn map_newest<F, R>(&self, f: F) -> R
+    where
+        F: FnOnce(Option<&T>) -> R,
+    {
+        let queue = self.queue.lock().unwrap();
+        f(queue.back())
+    }
+
     /// Iterate over the entries in the queue from newest to oldest entry
     /// atomically, applying `f` to each entry and returning the result of
     /// the last invocation of `f`.
@@ -145,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 af15a82b25d..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::{
-    components::store::{EntityKey, EntityType},
     data::value::Word,
-    prelude::{q, BigDecimal, BigInt, Value},
+    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::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 5af1063d54d..f263480b063 100644
--- a/graph/src/util/futures.rs
+++ b/graph/src/util/futures.rs
@@ -1,13 +1,21 @@
 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)]
+pub const RETRY_DEFAULT_LIMIT: Duration = Duration::from_secs(1);
+#[cfg(not(debug_assertions))]
+pub const RETRY_DEFAULT_LIMIT: Duration = Duration::from_secs(30);
 
 /// Generic helper function for retrying async operations with built-in logging.
 ///
@@ -55,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,
     }
 }
 
@@ -69,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>
@@ -102,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
     }
 
@@ -119,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> {
@@ -143,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> {
@@ -167,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);
@@ -178,6 +204,8 @@ where
             log_after,
             warn_after,
             limit_opt,
+            redact_log_urls,
+            max_delay,
             move || {
                 try_it()
                     .timeout(timeout)
@@ -208,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);
 
@@ -218,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),
         )
@@ -259,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
@@ -271,7 +305,7 @@ where
 
     let mut attempt_count = 0;
 
-    Retry::spawn(retry_strategy(limit_opt), move || {
+    Retry::start(retry_strategy(limit_opt, max_delay), move || {
         let operation_name = operation_name.clone();
         let logger = logger.clone();
         let condition = condition.clone();
@@ -305,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(),
                         );
                     }
 
@@ -347,11 +394,17 @@ where
     })
 }
 
-fn retry_strategy(limit_opt: Option<usize>) -> Box<dyn Iterator<Item = Duration> + Send> {
+pub fn retry_strategy(
+    limit_opt: Option<usize>,
+    max_delay: Duration,
+) -> Box<dyn Iterator<Item = Duration> + Send> {
     // Exponential backoff, but with a maximum
-    let max_delay_ms = 30_000;
-    let backoff = ExponentialBackoff::from_millis(2)
-        .max_delay(Duration::from_millis(max_delay_ms))
+    let backoff = ExponentialBackoff::from_millis(10)
+        .max_delay(Duration::from_millis(
+            // This should be fine, if the value is too high it will crash during
+            // testing.
+            max_delay.as_millis().try_into().unwrap(),
+        ))
         .map(jitter);
 
     // Apply limit (maximum retry count)
@@ -359,7 +412,8 @@ fn retry_strategy(limit_opt: Option<usize>) -> Box<dyn Iterator<Item = Duration>
         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),
     }
@@ -427,20 +481,16 @@ where
 mod tests {
     use super::*;
 
-    use futures::future;
+    use futures01::future;
     use futures03::compat::Future01CompatExt;
     use slog::o;
     use std::sync::Mutex;
 
-    #[test]
-    fn test() {
+    #[crate::test]
+    async fn test() {
         let logger = Logger::root(::slog::Discard, o!());
 
-        let runtime = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .unwrap();
-        let result = runtime.block_on(async {
+        let result = {
             let c = Mutex::new(0);
             retry("test", &logger)
                 .no_logging()
@@ -457,19 +507,15 @@ mod tests {
                     }
                 })
                 .await
-        });
+        };
         assert_eq!(result, Ok(10));
     }
 
-    #[test]
-    fn limit_reached() {
+    #[crate::test]
+    async fn limit_reached() {
         let logger = Logger::root(::slog::Discard, o!());
-        let runtime = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .unwrap();
 
-        let result = runtime.block_on({
+        let result = {
             let c = Mutex::new(0);
             retry("test", &logger)
                 .no_logging()
@@ -485,19 +531,16 @@ mod tests {
                         future::err(*c_guard).compat()
                     }
                 })
-        });
+                .await
+        };
         assert_eq!(result, Err(5));
     }
 
-    #[test]
-    fn limit_not_reached() {
+    #[crate::test]
+    async fn limit_not_reached() {
         let logger = Logger::root(::slog::Discard, o!());
-        let runtime = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .unwrap();
 
-        let result = runtime.block_on({
+        let result = {
             let c = Mutex::new(0);
             retry("test", &logger)
                 .no_logging()
@@ -513,20 +556,17 @@ mod tests {
                         future::err(*c_guard).compat()
                     }
                 })
-        });
+                .await
+        };
         assert_eq!(result, Ok(10));
     }
 
-    #[test]
-    fn custom_when() {
+    #[crate::test]
+    async fn custom_when() {
         let logger = Logger::root(::slog::Discard, o!());
         let c = Mutex::new(0);
 
-        let runtime = tokio::runtime::Builder::new_current_thread()
-            .enable_all()
-            .build()
-            .unwrap();
-        let result = runtime.block_on({
+        let result = {
             retry("test", &logger)
                 .when(|result| result.unwrap() < 10)
                 .no_logging()
@@ -541,7 +581,8 @@ mod tests {
                         future::ok(*c_guard).compat()
                     }
                 })
-        });
+                .await
+        };
 
         assert_eq!(result, Ok(10));
     }
diff --git a/graph/src/util/herd_cache.rs b/graph/src/util/herd_cache.rs
new file mode 100644
index 00000000000..88f32ffb861
--- /dev/null
+++ b/graph/src/util/herd_cache.rs
@@ -0,0 +1,83 @@
+use std::collections::HashMap;
+use std::collections::hash_map::Entry;
+use std::future::Future;
+use std::pin::Pin;
+use std::sync::Arc;
+
+use futures03::future::{FutureExt as _, Shared};
+use slog::Logger;
+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;
+
+type Hash = <SetHasher as StableHasher>::Out;
+
+type PinFut<R> = Pin<Box<dyn Future<Output = R> + 'static + Send>>;
+
+/// Cache that keeps a result around as long as it is still being processed.
+/// The cache ensures that the query is not re-entrant, so multiple
+/// consumers of identical queries will not execute them in parallel.
+///
+/// This has a lot in common with AsyncCache in the network-services repo,
+/// 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, CheapClone)]
+pub struct HerdCache<R> {
+    cache: Arc<TimedMutex<HashMap<Hash, Shared<PinFut<R>>>>>,
+}
+
+impl<R: CheapClone> HerdCache<R> {
+    pub fn new(id: impl Into<String>) -> Self {
+        Self {
+            cache: Arc::new(TimedMutex::new(HashMap::new(), id)),
+        }
+    }
+
+    /// Assumption: Whatever F is passed in consistently returns the same
+    /// value for any input - for all values of F used with this Cache.
+    ///
+    /// Returns `(value, cached)`, where `cached` is true if the value was
+    /// already in the cache and false otherwise.
+    pub async fn cached_query<F: Future<Output = R> + Send + 'static>(
+        &self,
+        hash: Hash,
+        f: F,
+        logger: &Logger,
+    ) -> (R, bool) {
+        let f = f.boxed();
+
+        let (work, cached) = {
+            let mut cache = self.cache.lock(logger);
+
+            match cache.entry(hash) {
+                Entry::Occupied(entry) => {
+                    // This is already being worked on.
+                    let entry = entry.get().cheap_clone();
+                    (entry, true)
+                }
+                Entry::Vacant(entry) => {
+                    // New work, put it in the in-flight list.
+                    let uncached = f.shared();
+                    entry.insert(uncached.clone());
+                    (uncached, false)
+                }
+            }
+        };
+
+        let _remove_guard = if !cached {
+            // Make sure to remove this from the in-flight list, even if `poll` panics.
+            Some(defer::defer(|| {
+                self.cache.lock(logger).remove(&hash);
+            }))
+        } else {
+            None
+        };
+
+        (work.await, cached)
+    }
+}
diff --git a/graph/src/util/intern.rs b/graph/src/util/intern.rs
new file mode 100644
index 00000000000..655d71da9e7
--- /dev/null
+++ b/graph/src/util/intern.rs
@@ -0,0 +1,743 @@
+//! Interning of strings.
+//!
+//! This module provides an interned string pool `AtomPool` and a map-like
+//! data structure `Object` that uses the string pool. It offers two
+//! different kinds of atom: a plain `Atom` (an integer) and a `FatAtom` (a
+//! reference to the pool and an integer). The former is useful when the
+//! pool is known from context whereas the latter carries a reference to the
+//! pool and can be used anywhere.
+
+use std::convert::TryFrom;
+use std::{collections::HashMap, sync::Arc};
+
+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;
+
+// An `Atom` is really just an integer value of this type. The size of the
+// type determines how many atoms a pool (and all its parents) can hold.
+type AtomInt = u16;
+
+/// An atom in a pool. To look up the underlying string, surrounding code
+/// needs to know the pool for it.
+///
+/// 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, 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,
+}
+
+impl FatAtom {
+    pub fn as_str(&self) -> &str {
+        self.pool.get(self.atom).expect("atom is in the pool")
+    }
+}
+
+impl AsRef<str> for FatAtom {
+    fn as_ref(&self) -> &str {
+        self.as_str()
+    }
+}
+
+#[derive(Debug)]
+pub enum Error {
+    NotInterned(String),
+}
+
+impl Error {
+    pub fn not_interned(self) -> String {
+        match self {
+            Error::NotInterned(s) => s,
+        }
+    }
+}
+
+#[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
+/// outside.
+pub struct AtomPool {
+    base: Option<Arc<AtomPool>>,
+    base_sym: AtomInt,
+    atoms: Vec<Box<str>>,
+    words: HashMap<Box<str>, Atom>,
+}
+
+impl AtomPool {
+    /// Create a new root pool.
+    pub fn new() -> Self {
+        Self {
+            base: None,
+            base_sym: 0,
+            atoms: Vec::new(),
+            words: HashMap::new(),
+        }
+    }
+
+    /// Create a child pool that extends the set of strings interned in the
+    /// current pool.
+    pub fn child(self: &Arc<Self>) -> Self {
+        let base_sym = AtomInt::try_from(self.atoms.len()).unwrap();
+        AtomPool {
+            base: Some(self.clone()),
+            base_sym,
+            atoms: Vec::new(),
+            words: HashMap::new(),
+        }
+    }
+
+    /// Get the string for `atom`. Return `None` if the atom is not in this
+    /// pool or any of its ancestors.
+    pub fn get(&self, atom: Atom) -> Option<&str> {
+        if atom.0 < self.base_sym {
+            self.base.as_ref().and_then(|base| base.get(atom))
+        } else {
+            self.atoms
+                .get((atom.0 - self.base_sym) as usize)
+                .map(|s| s.as_ref())
+        }
+    }
+
+    /// 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
+            && let Some(atom) = base.lookup(word)
+        {
+            return Some(atom);
+        }
+
+        self.words.get(word).cloned()
+    }
+
+    /// Add `word` to this pool if it is not already in it. Return the atom
+    /// for the word.
+    pub fn intern(&mut self, word: &str) -> Atom {
+        if let Some(atom) = self.lookup(word) {
+            return atom;
+        }
+
+        let atom =
+            AtomInt::try_from(self.base_sym as usize + self.atoms.len()).expect("too many atoms");
+        let atom = Atom(atom);
+        if atom == TOMBSTONE_KEY {
+            panic!("too many atoms");
+        }
+        self.words.insert(Box::from(word), atom);
+        self.atoms.push(Box::from(word));
+        atom
+    }
+}
+
+impl<S: AsRef<str>> FromIterator<S> for AtomPool {
+    fn from_iter<I: IntoIterator<Item = S>>(iter: I) -> Self {
+        let mut pool = AtomPool::new();
+        for s in iter {
+            pool.intern(s.as_ref());
+        }
+        pool
+    }
+}
+
+/// A marker for an empty entry in an `Object`
+const TOMBSTONE_KEY: Atom = Atom(AtomInt::MAX);
+
+/// A value that can be used as a null value in an `Object`. The null value
+/// is used when removing an entry as `Object.remove` does not actually
+/// remove the entry but replaces it with a tombstone marker.
+pub trait NullValue {
+    fn null() -> Self;
+}
+
+impl<T: Default> NullValue for T {
+    fn null() -> Self {
+        T::default()
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+struct Entry<V> {
+    key: Atom,
+    value: V,
+}
+
+impl<V: GasSizeOf> GasSizeOf for Entry<V> {
+    fn gas_size_of(&self) -> Gas {
+        Gas::new(std::mem::size_of::<Atom>() as u64) + self.value.gas_size_of()
+    }
+}
+
+/// A map-like data structure that uses an `AtomPool` for its keys. The data
+/// structure assumes that reads are much more common than writes, and that
+/// entries are rarely removed. It also assumes that each instance has
+/// relatively few entries.
+#[derive(Clone)]
+pub struct Object<V> {
+    pool: Arc<AtomPool>,
+    // This could be further improved by using two `Vec`s, one for keys and
+    // one for values. That would avoid losing memory to padding.
+    entries: Vec<Entry<V>>,
+}
+
+impl<V> Object<V> {
+    /// Create a new `Object` whose keys are interned in `pool`.
+    pub fn new(pool: Arc<AtomPool>) -> Self {
+        Self {
+            pool,
+            entries: Vec::new(),
+        }
+    }
+
+    /// Return the number of entries in the object. Because of tombstones,
+    /// this operation has to traverse all entries
+    pub fn len(&self) -> usize {
+        // Because of tombstones we can't just return `self.entries.len()`.
+        self.entries
+            .iter()
+            .filter(|entry| entry.key != TOMBSTONE_KEY)
+            .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> {
+        match self.pool.lookup(key) {
+            None => None,
+            Some(key) => self
+                .entries
+                .iter()
+                .find(|entry| entry.key == key)
+                .map(|entry| &entry.value),
+        }
+    }
+
+    /// Find the value for `atom` in the object. Return `None` if the atom
+    /// is not present.
+    fn get_by_atom(&self, atom: &Atom) -> Option<&V> {
+        if *atom == TOMBSTONE_KEY {
+            return None;
+        }
+
+        self.entries
+            .iter()
+            .find(|entry| &entry.key == atom)
+            .map(|entry| &entry.value)
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = (&str, &V)> {
+        ObjectIter::new(self)
+    }
+
+    /// Add or update an entry to the object. Return the value that was
+    /// previously associated with the `key`. The `key` must already be part
+    /// of the `AtomPool` that this object uses. Trying to set a key that is
+    /// not in the pool will result in an error.
+    pub fn insert<K: AsRef<str>>(&mut self, key: K, value: V) -> Result<Option<V>, Error> {
+        let key = self
+            .pool
+            .lookup(key.as_ref())
+            .ok_or_else(|| Error::NotInterned(key.as_ref().to_string()))?;
+        Ok(self.insert_atom(key, value))
+    }
+
+    fn insert_atom(&mut self, key: Atom, value: V) -> Option<V> {
+        if key == TOMBSTONE_KEY {
+            // Ignore attempts to insert the tombstone key.
+            return None;
+        }
+
+        match self.entries.iter_mut().find(|entry| entry.key == key) {
+            Some(entry) => Some(std::mem::replace(&mut entry.value, value)),
+            None => {
+                self.entries.push(Entry { key, value });
+                None
+            }
+        }
+    }
+
+    pub(crate) fn contains_key(&self, key: &str) -> bool {
+        self.entries
+            .iter()
+            .any(|entry| self.pool.get(entry.key) == Some(key))
+    }
+
+    pub fn merge(&mut self, other: Object<V>) {
+        if self.same_pool(&other) {
+            for Entry { key, value } in other.entries {
+                self.insert_atom(key, value);
+            }
+        } else {
+            for (key, value) in other {
+                self.insert(key, value).expect("pools use the same keys");
+            }
+        }
+    }
+
+    pub fn retain(&mut self, mut f: impl FnMut(&str, &V) -> bool) {
+        self.entries.retain(|entry| {
+            if entry.key == TOMBSTONE_KEY {
+                // Since we are going through the trouble of removing
+                // entries, remove deleted entries opportunistically.
+                false
+            } else {
+                let key = self.pool.get(entry.key).unwrap();
+                f(key, &entry.value)
+            }
+        })
+    }
+
+    fn same_pool(&self, other: &Object<V>) -> bool {
+        Arc::ptr_eq(&self.pool, &other.pool)
+    }
+
+    pub fn atoms(&self) -> AtomIter<'_, V> {
+        AtomIter::new(self)
+    }
+}
+
+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
+    /// efficiency reasons. It is instead replaced with an entry with a
+    /// dummy key and a null value.
+    pub fn remove(&mut self, key: &str) -> Option<V> {
+        match self.pool.lookup(key) {
+            None => None,
+            Some(key) => self
+                .entries
+                .iter_mut()
+                .find(|entry| entry.key == key)
+                .map(|entry| {
+                    entry.key = TOMBSTONE_KEY;
+                    std::mem::replace(&mut entry.value, V::null())
+                }),
+        }
+    }
+}
+
+pub struct ObjectIter<'a, V> {
+    pool: &'a AtomPool,
+    iter: std::slice::Iter<'a, Entry<V>>,
+}
+
+impl<'a, V> ObjectIter<'a, V> {
+    fn new(object: &'a Object<V>) -> Self {
+        Self {
+            pool: object.pool.as_ref(),
+            iter: object.entries.as_slice().iter(),
+        }
+    }
+}
+
+impl<'a, V> Iterator for ObjectIter<'a, V> {
+    type Item = (&'a str, &'a V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        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();
+                return Some((key, &entry.value));
+            }
+        }
+        None
+    }
+}
+
+impl<'a, V> IntoIterator for &'a Object<V> {
+    type Item = <ObjectIter<'a, V> as Iterator>::Item;
+
+    type IntoIter = ObjectIter<'a, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ObjectIter::new(self)
+    }
+}
+
+pub struct ObjectOwningIter<V> {
+    pool: Arc<AtomPool>,
+    iter: std::vec::IntoIter<Entry<V>>,
+}
+
+impl<V> ObjectOwningIter<V> {
+    fn new(object: Object<V>) -> Self {
+        Self {
+            pool: object.pool.cheap_clone(),
+            iter: object.entries.into_iter(),
+        }
+    }
+}
+
+impl<V> Iterator for ObjectOwningIter<V> {
+    type Item = (Word, V);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        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();
+                return Some((Word::from(key), entry.value));
+            }
+        }
+        None
+    }
+}
+
+pub struct AtomIter<'a, V> {
+    iter: std::slice::Iter<'a, Entry<V>>,
+}
+
+impl<'a, V> AtomIter<'a, V> {
+    fn new(object: &'a Object<V>) -> Self {
+        Self {
+            iter: object.entries.as_slice().iter(),
+        }
+    }
+}
+
+impl<'a, V> Iterator for AtomIter<'a, V> {
+    type Item = Atom;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        for entry in self.iter.by_ref() {
+            if entry.key != TOMBSTONE_KEY {
+                return Some(entry.key);
+            }
+        }
+        None
+    }
+}
+
+impl<V> IntoIterator for Object<V> {
+    type Item = <ObjectOwningIter<V> as Iterator>::Item;
+
+    type IntoIter = ObjectOwningIter<V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ObjectOwningIter::new(self)
+    }
+}
+
+impl<V: CacheWeight> CacheWeight for Entry<V> {
+    fn indirect_weight(&self) -> usize {
+        self.value.indirect_weight()
+    }
+}
+
+impl<V: CacheWeight> CacheWeight for Object<V> {
+    fn indirect_weight(&self) -> usize {
+        self.entries.indirect_weight()
+    }
+}
+
+impl<V: std::fmt::Debug> std::fmt::Debug for Object<V> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.entries.fmt(f)
+    }
+}
+
+impl<V: PartialEq> PartialEq for Object<V> {
+    fn eq(&self, other: &Self) -> bool {
+        if self.len() != other.len() {
+            return false;
+        }
+
+        if self.same_pool(other) {
+            self.entries
+                .iter()
+                .filter(|e| e.key != TOMBSTONE_KEY)
+                .all(|Entry { key, value }| other.get_by_atom(key) == Some(value))
+        } else {
+            self.iter()
+                .all(|(key, value)| other.get(key) == Some(value))
+        }
+    }
+}
+
+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>
+    where
+        S: serde::Serializer,
+    {
+        serializer.collect_map(self.iter())
+    }
+}
+
+impl<V: GasSizeOf> GasSizeOf for Object<V> {
+    fn gas_size_of(&self) -> Gas {
+        Gas::new(std::mem::size_of::<Arc<AtomPool>>() as u64) + self.entries.gas_size_of()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::prelude::r;
+
+    use super::*;
+
+    #[test]
+    fn simple() {
+        let mut intern = AtomPool::new();
+        let hello = intern.intern("Hello");
+        assert_eq!(Some(hello), intern.lookup("Hello"));
+        assert_eq!(None, intern.lookup("World"));
+        assert_eq!(Some("Hello"), intern.get(hello));
+
+        // Print some size information, just for understanding better how
+        // big these data structures are
+        use std::mem;
+
+        println!(
+            "pool: {}, arc: {}",
+            mem::size_of::<AtomPool>(),
+            mem::size_of::<Arc<AtomPool>>()
+        );
+
+        println!(
+            "Atom: {}, FatAtom: {}",
+            mem::size_of::<Atom>(),
+            mem::size_of::<FatAtom>(),
+        );
+        println!(
+            "Entry<u64>: {}, Object<u64>: {}",
+            mem::size_of::<Entry<u64>>(),
+            mem::size_of::<Object<u64>>()
+        );
+        println!(
+            "Entry<Value>: {}, Object<Value>: {}, r::Value: {}",
+            mem::size_of::<Entry<r::Value>>(),
+            mem::size_of::<Object<r::Value>>(),
+            mem::size_of::<r::Value>()
+        );
+    }
+
+    #[test]
+    fn stacked() {
+        let mut base = AtomPool::new();
+        let bsym = base.intern("base");
+        let isym = base.intern("intern");
+        let base = Arc::new(base);
+
+        let mut intern = base.child();
+        assert_eq!(Some(bsym), intern.lookup("base"));
+
+        assert_eq!(bsym, intern.intern("base"));
+        let hello = intern.intern("hello");
+        assert_eq!(None, base.get(hello));
+        assert_eq!(Some("hello"), intern.get(hello));
+        assert_eq!(None, base.lookup("hello"));
+        assert_eq!(Some(hello), intern.lookup("hello"));
+        assert_eq!(Some(isym), base.lookup("intern"));
+        assert_eq!(Some(isym), intern.lookup("intern"));
+    }
+
+    fn make_pool(words: Vec<&str>) -> Arc<AtomPool> {
+        let mut pool = AtomPool::new();
+        for word in words {
+            pool.intern(word);
+        }
+        Arc::new(pool)
+    }
+
+    fn make_obj(pool: Arc<AtomPool>, entries: Vec<(&str, usize)>) -> Object<usize> {
+        let mut obj: Object<usize> = Object::new(pool);
+        for (k, v) in entries {
+            obj.insert(k, v).unwrap();
+        }
+        obj
+    }
+
+    #[test]
+    fn object_eq() {
+        // Make an object `{ "one": 1, "two": 2 }` that has a removed key
+        // `three` in it to make sure equality checking ignores removed keys
+        fn make_obj1(pool: Arc<AtomPool>) -> Object<usize> {
+            let mut obj = make_obj(pool, vec![("one", 1), ("two", 2), ("three", 3)]);
+            obj.remove("three");
+            obj
+        }
+
+        // Make two pools with the same atoms, but different order
+        let pool1 = make_pool(vec!["one", "two", "three"]);
+        let pool2 = make_pool(vec!["three", "two", "one"]);
+
+        // Make two objects with the same keys and values in the same order
+        // but different pools
+        let obj1 = make_obj1(pool1.clone());
+        let obj2 = make_obj(pool2.clone(), vec![("one", 1), ("two", 2)]);
+        assert_eq!(obj1, obj2);
+
+        // Make two objects with the same keys and values in different order
+        // and with  different pools
+        let obj1 = make_obj1(pool1.clone());
+        let obj2 = make_obj(pool2.clone(), vec![("two", 2), ("one", 1)]);
+        assert_eq!(obj1, obj2);
+
+        // Check that two objects using the same pools and the same keys and
+        // values but in different order are equal
+        let pool = pool1;
+        let obj1 = make_obj1(pool.clone());
+        let obj2 = make_obj(pool.clone(), vec![("two", 2), ("one", 1)]);
+        assert_eq!(obj1, obj2);
+    }
+
+    #[test]
+    fn object_remove() {
+        let pool = make_pool(vec!["one", "two", "three"]);
+        let mut obj = make_obj(pool.clone(), vec![("one", 1), ("two", 2)]);
+
+        assert_eq!(Some(1), obj.remove("one"));
+        assert_eq!(None, obj.get("one"));
+        assert_eq!(Some(&2), obj.get("two"));
+
+        let entries = obj.iter().collect::<Vec<_>>();
+        assert_eq!(vec![("two", &2)], entries);
+
+        assert_eq!(None, obj.remove("one"));
+        let entries = obj.into_iter().collect::<Vec<_>>();
+        assert_eq!(vec![(Word::from("two"), 2)], entries);
+    }
+
+    #[test]
+    fn object_insert() {
+        let pool = make_pool(vec!["one", "two", "three"]);
+        let mut obj = make_obj(pool.clone(), vec![("one", 1), ("two", 2)]);
+
+        assert_eq!(Some(1), obj.insert("one", 17).unwrap());
+        assert_eq!(Some(&17), obj.get("one"));
+        assert_eq!(Some(&2), obj.get("two"));
+        assert!(obj.insert("not interned", 42).is_err());
+
+        let entries = obj.iter().collect::<Vec<_>>();
+        assert_eq!(vec![("one", &17), ("two", &2)], entries);
+
+        assert_eq!(None, obj.insert("three", 3).unwrap());
+        let entries = obj.into_iter().collect::<Vec<_>>();
+        assert_eq!(
+            vec![
+                (Word::from("one"), 17),
+                (Word::from("two"), 2),
+                (Word::from("three"), 3)
+            ],
+            entries
+        );
+    }
+
+    #[test]
+    fn object_remove_insert() {
+        let pool = make_pool(vec!["one", "two", "three"]);
+        let mut obj = make_obj(pool.clone(), vec![("one", 1), ("two", 2)]);
+
+        // Remove an entry
+        assert_eq!(Some(1), obj.remove("one"));
+        assert_eq!(None, obj.get("one"));
+
+        let entries = obj.iter().collect::<Vec<_>>();
+        assert_eq!(vec![("two", &2)], entries);
+
+        // And insert it again
+        assert_eq!(None, obj.insert("one", 1).unwrap());
+
+        let entries = obj.iter().collect::<Vec<_>>();
+        assert_eq!(vec![("two", &2), ("one", &1)], entries);
+
+        let entries = obj.into_iter().collect::<Vec<_>>();
+        assert_eq!(
+            vec![(Word::from("two"), 2), (Word::from("one"), 1)],
+            entries
+        );
+    }
+
+    #[test]
+    fn object_merge() {
+        let pool1 = make_pool(vec!["one", "two", "three"]);
+        let pool2 = make_pool(vec!["three", "two", "one"]);
+
+        // Merge objects with different pools
+        let mut obj1 = make_obj(pool1.clone(), vec![("one", 1), ("two", 2)]);
+        let obj2 = make_obj(pool2.clone(), vec![("one", 11), ("three", 3)]);
+
+        obj1.merge(obj2);
+        let entries = obj1.into_iter().collect::<Vec<_>>();
+        assert_eq!(
+            vec![
+                (Word::from("one"), 11),
+                (Word::from("two"), 2),
+                (Word::from("three"), 3)
+            ],
+            entries
+        );
+
+        // Merge objects with the same pool
+        let mut obj1 = make_obj(pool1.clone(), vec![("one", 1), ("two", 2)]);
+        let obj2 = make_obj(pool1.clone(), vec![("one", 11), ("three", 3)]);
+        obj1.merge(obj2);
+        let entries = obj1.into_iter().collect::<Vec<_>>();
+        assert_eq!(
+            vec![
+                (Word::from("one"), 11),
+                (Word::from("two"), 2),
+                (Word::from("three"), 3)
+            ],
+            entries
+        );
+    }
+}
diff --git a/graph/src/util/jobs.rs b/graph/src/util/jobs.rs
index ccd9007a881..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;
@@ -95,8 +95,15 @@ impl Runner {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use lazy_static::lazy_static;
     use std::sync::{Arc, Mutex};
-    use test_store::LOGGER;
+
+    lazy_static! {
+        pub static ref LOGGER: Logger = match crate::env::ENV_VARS.log_levels {
+            Some(_) => crate::log::logger(false),
+            None => Logger::root(slog::Discard, o!()),
+        };
+    }
 
     struct CounterJob {
         count: Arc<Mutex<usize>>,
@@ -116,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 {
@@ -135,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 55f252c8669..12712350a01 100644
--- a/graph/src/util/lfu_cache.rs
+++ b/graph/src/util/lfu_cache.rs
@@ -72,8 +72,23 @@ pub struct EvictStats {
     pub stale_update: bool,
     /// How long eviction took
     pub evict_time: Duration,
+    /// The total number of cache accesses during this stale period
+    pub accesses: usize,
+    /// The total number of cache hits during this stale period
+    pub hits: usize,
 }
 
+impl EvictStats {
+    /// The cache hit rate in percent. The underlying counters are reset at
+    /// the end of each stale period.
+    pub fn hit_rate_pct(&self) -> f64 {
+        if self.accesses > 0 {
+            self.hits as f64 / self.accesses as f64 * 100.0
+        } else {
+            100.0
+        }
+    }
+}
 /// Each entry in the cache has a frequency, which is incremented by 1 on access. Entries also have
 /// a weight, upon eviction first stale entries will be removed and then non-stale entries by order
 /// of least frequency until the max weight is respected. This cache only removes entries on calls
@@ -85,6 +100,8 @@ pub struct LfuCache<K: Eq + Hash, V> {
     total_weight: usize,
     stale_counter: u64,
     dead_weight: bool,
+    accesses: usize,
+    hits: usize,
 }
 
 impl<K: Ord + Eq + Hash, V> Default for LfuCache<K, V> {
@@ -94,6 +111,8 @@ impl<K: Ord + Eq + Hash, V> Default for LfuCache<K, V> {
             total_weight: 0,
             stale_counter: 0,
             dead_weight: false,
+            accesses: 0,
+            hits: 0,
         }
     }
 }
@@ -105,6 +124,8 @@ impl<K: Clone + Ord + Eq + Hash + Debug + CacheWeight, V: CacheWeight + Default>
             total_weight: 0,
             stale_counter: 0,
             dead_weight: ENV_VARS.mappings.entity_cache_dead_weight,
+            accesses: 0,
+            hits: 0,
         }
     }
 
@@ -147,13 +168,23 @@ 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;
             x.0.will_stale = false;
             x.0
         })
     }
 
+    pub fn iter(&self) -> impl Iterator<Item = (&K, &V)> {
+        self.queue
+            .iter()
+            .map(|entry| (&entry.0.key, &entry.0.value))
+    }
+
     pub fn get(&mut self, key: &K) -> Option<&V> {
         self.get_mut(key.clone()).map(|x| &x.value)
     }
@@ -163,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);
@@ -187,6 +218,20 @@ impl<K: Clone + Ord + Eq + Hash + Debug + CacheWeight, V: CacheWeight + Default>
         self.queue.len()
     }
 
+    pub fn evict_and_stats(&mut self, max_weight: usize) -> EvictStats {
+        self.evict_with_period(max_weight, STALE_PERIOD)
+            .unwrap_or_else(|| EvictStats {
+                new_weight: self.total_weight,
+                evicted_weight: 0,
+                new_count: self.len(),
+                evicted_count: 0,
+                stale_update: false,
+                evict_time: Duration::from_millis(0),
+                accesses: 0,
+                hits: 0,
+            })
+    }
+
     /// Same as `evict_with_period(max_weight, STALE_PERIOD)`
     pub fn evict(&mut self, max_weight: usize) -> Option<EvictStats> {
         self.evict_with_period(max_weight, STALE_PERIOD)
@@ -211,10 +256,16 @@ impl<K: Clone + Ord + Eq + Hash + Debug + CacheWeight, V: CacheWeight + Default>
 
         let start = Instant::now();
 
+        let accesses = self.accesses;
+        let hits = self.hits;
+
         self.stale_counter += 1;
         if self.stale_counter == stale_period {
             self.stale_counter = 0;
 
+            self.accesses = 0;
+            self.hits = 0;
+
             // Entries marked `will_stale` were not accessed in this period. Properly mark them as
             // stale in their priorities. Also mark all entities as `will_stale` for the _next_
             // period so that they will be marked stale next time unless they are updated or looked
@@ -248,6 +299,8 @@ impl<K: Clone + Ord + Eq + Hash + Debug + CacheWeight, V: CacheWeight + Default>
             evicted_count: old_len - self.len(),
             stale_update: self.stale_counter == 0,
             evict_time: start.elapsed(),
+            accesses,
+            hits,
         })
     }
 }
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 8af2540f401..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;
@@ -29,3 +31,10 @@ pub mod mem;
 
 /// Data structures instrumented with Prometheus metrics.
 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 b5e04c57a6a..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;
@@ -55,8 +57,8 @@ impl Bin {
 /// a `window_size` of 5 minutes and a bin size of one second would use
 /// 300 bins. Each bin has constant size
 pub struct MovingStats {
-    window_size: Duration,
-    bin_size: Duration,
+    pub window_size: Duration,
+    pub bin_size: Duration,
     /// The buffer with measurements. The back has the most recent entries,
     /// and the front has the oldest entries
     bins: VecDeque<Bin>,
@@ -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/README.md b/graph/tests/README.md
new file mode 100644
index 00000000000..ff99b410d4b
--- /dev/null
+++ b/graph/tests/README.md
@@ -0,0 +1,5 @@
+Put integration tests for this crate into `store/test-store/tests/graph`.
+This avoids cyclic dev-dependencies which make rust-analyzer nearly
+unusable. Once [this
+issue](https://github.com/rust-lang/rust-analyzer/issues/14167) has been
+fixed, we can move tests back here
diff --git a/graph/tests/entity_cache.rs b/graph/tests/entity_cache.rs
deleted file mode 100644
index 4d7579e2987..00000000000
--- a/graph/tests/entity_cache.rs
+++ /dev/null
@@ -1,351 +0,0 @@
-use async_trait::async_trait;
-use graph::blockchain::block_stream::FirehoseCursor;
-use graph::blockchain::BlockPtr;
-use graph::data::subgraph::schema::{SubgraphError, SubgraphHealth};
-use graph::data_source::CausalityRegion;
-use graph::prelude::{Schema, StopwatchMetrics, StoreError, UnfailOutcome};
-use lazy_static::lazy_static;
-use slog::Logger;
-use std::collections::{BTreeMap, BTreeSet};
-use std::sync::Arc;
-
-use graph::components::store::{
-    EntityKey, EntityType, ReadStore, StoredDynamicDataSource, WritableStore,
-};
-use graph::{
-    components::store::{DeploymentId, DeploymentLocator},
-    prelude::{DeploymentHash, Entity, EntityCache, EntityModification, Value},
-};
-
-lazy_static! {
-    static ref SUBGRAPH_ID: DeploymentHash = DeploymentHash::new("entity_cache").unwrap();
-    static ref DEPLOYMENT: DeploymentLocator =
-        DeploymentLocator::new(DeploymentId::new(-12), SUBGRAPH_ID.clone());
-    static ref SCHEMA: Arc<Schema> = Arc::new(
-        Schema::parse(
-            "
-            type Band @entity {
-                id: ID!
-                name: String!
-                founded: Int
-                label: String
-            }
-            ",
-            SUBGRAPH_ID.clone(),
-        )
-        .expect("Test schema invalid")
-    );
-}
-
-struct MockStore {
-    get_many_res: BTreeMap<EntityKey, Entity>,
-}
-
-impl MockStore {
-    fn new(get_many_res: BTreeMap<EntityKey, Entity>) -> Self {
-        Self { get_many_res }
-    }
-}
-
-impl ReadStore for MockStore {
-    fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
-        Ok(self.get_many_res.get(key).cloned())
-    }
-
-    fn get_many(
-        &self,
-        _keys: BTreeSet<EntityKey>,
-    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
-        Ok(self.get_many_res.clone())
-    }
-
-    fn input_schema(&self) -> Arc<Schema> {
-        SCHEMA.clone()
-    }
-}
-
-#[async_trait]
-impl WritableStore for MockStore {
-    fn block_ptr(&self) -> Option<BlockPtr> {
-        unimplemented!()
-    }
-
-    fn block_cursor(&self) -> FirehoseCursor {
-        unimplemented!()
-    }
-
-    async fn start_subgraph_deployment(&self, _: &Logger) -> Result<(), StoreError> {
-        unimplemented!()
-    }
-
-    async fn revert_block_operations(
-        &self,
-        _: BlockPtr,
-        _: FirehoseCursor,
-    ) -> Result<(), StoreError> {
-        unimplemented!()
-    }
-
-    async fn unfail_deterministic_error(
-        &self,
-        _: &BlockPtr,
-        _: &BlockPtr,
-    ) -> Result<UnfailOutcome, StoreError> {
-        unimplemented!()
-    }
-
-    fn unfail_non_deterministic_error(&self, _: &BlockPtr) -> Result<UnfailOutcome, StoreError> {
-        unimplemented!()
-    }
-
-    async fn fail_subgraph(&self, _: SubgraphError) -> Result<(), StoreError> {
-        unimplemented!()
-    }
-
-    async fn supports_proof_of_indexing(&self) -> Result<bool, StoreError> {
-        unimplemented!()
-    }
-
-    async fn transact_block_operations(
-        &self,
-        _: BlockPtr,
-        _: FirehoseCursor,
-        _: Vec<EntityModification>,
-        _: &StopwatchMetrics,
-        _: Vec<StoredDynamicDataSource>,
-        _: Vec<SubgraphError>,
-        _: Vec<(u32, String)>,
-        _: Vec<StoredDynamicDataSource>,
-    ) -> Result<(), StoreError> {
-        unimplemented!()
-    }
-
-    async fn is_deployment_synced(&self) -> Result<bool, StoreError> {
-        unimplemented!()
-    }
-
-    fn unassign_subgraph(&self) -> Result<(), StoreError> {
-        unimplemented!()
-    }
-
-    async fn load_dynamic_data_sources(
-        &self,
-        _manifest_idx_and_name: Vec<(u32, String)>,
-    ) -> Result<Vec<StoredDynamicDataSource>, StoreError> {
-        unimplemented!()
-    }
-
-    fn deployment_synced(&self) -> Result<(), StoreError> {
-        unimplemented!()
-    }
-
-    fn shard(&self) -> &str {
-        unimplemented!()
-    }
-
-    async fn health(&self) -> Result<SubgraphHealth, StoreError> {
-        unimplemented!()
-    }
-
-    async fn flush(&self) -> Result<(), StoreError> {
-        unimplemented!()
-    }
-
-    async fn causality_region_curr_val(&self) -> Result<Option<CausalityRegion>, StoreError> {
-        unimplemented!()
-    }
-}
-
-fn make_band(id: &'static str, data: Vec<(&str, Value)>) -> (EntityKey, Entity) {
-    (
-        EntityKey {
-            entity_type: EntityType::new("Band".to_string()),
-            entity_id: id.into(),
-            causality_region: CausalityRegion::ONCHAIN,
-        },
-        Entity::from(data),
-    )
-}
-
-fn sort_by_entity_key(mut mods: Vec<EntityModification>) -> Vec<EntityModification> {
-    mods.sort_by_key(|m| m.entity_ref().clone());
-    mods
-}
-
-#[tokio::test]
-async fn empty_cache_modifications() {
-    let store = Arc::new(MockStore::new(BTreeMap::new()));
-    let cache = EntityCache::new(store);
-    let result = cache.as_modifications();
-    assert_eq!(result.unwrap().modifications, vec![]);
-}
-
-#[test]
-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 (mogwai_key, mogwai_data) = make_band(
-        "mogwai",
-        vec![("id", "mogwai".into()), ("name", "Mogwai".into())],
-    );
-    cache.set(mogwai_key.clone(), mogwai_data.clone()).unwrap();
-
-    let (sigurros_key, sigurros_data) = make_band(
-        "sigurros",
-        vec![("id", "sigurros".into()), ("name", "Sigur Ros".into())],
-    );
-    cache
-        .set(sigurros_key.clone(), sigurros_data.clone())
-        .unwrap();
-
-    let result = cache.as_modifications();
-    assert_eq!(
-        sort_by_entity_key(result.unwrap().modifications),
-        sort_by_entity_key(vec![
-            EntityModification::Insert {
-                key: mogwai_key,
-                data: mogwai_data,
-            },
-            EntityModification::Insert {
-                key: sigurros_key,
-                data: sigurros_data,
-            }
-        ])
-    );
-}
-
-fn entity_version_map(entity_type: &str, entities: Vec<Entity>) -> BTreeMap<EntityKey, Entity> {
-    let mut map = BTreeMap::new();
-    for entity in entities {
-        let key = EntityKey {
-            entity_type: EntityType::new(entity_type.to_string()),
-            entity_id: entity.id().unwrap().into(),
-            causality_region: CausalityRegion::ONCHAIN,
-        };
-        map.insert(key, entity);
-    }
-    map
-}
-
-#[test]
-fn overwrite_modifications() {
-    // Pre-populate the store with entities so that the cache treats
-    // every set operation as an overwrite.
-    let store = {
-        let entities = vec![
-            make_band(
-                "mogwai",
-                vec![("id", "mogwai".into()), ("name", "Mogwai".into())],
-            )
-            .1,
-            make_band(
-                "sigurros",
-                vec![("id", "sigurros".into()), ("name", "Sigur Ros".into())],
-            )
-            .1,
-        ];
-        MockStore::new(entity_version_map("Band", entities))
-    };
-
-    let store = Arc::new(store);
-    let mut cache = EntityCache::new(store);
-
-    let (mogwai_key, mogwai_data) = make_band(
-        "mogwai",
-        vec![
-            ("id", "mogwai".into()),
-            ("name", "Mogwai".into()),
-            ("founded", 1995.into()),
-        ],
-    );
-    cache.set(mogwai_key.clone(), mogwai_data.clone()).unwrap();
-
-    let (sigurros_key, sigurros_data) = make_band(
-        "sigurros",
-        vec![
-            ("id", "sigurros".into()),
-            ("name", "Sigur Ros".into()),
-            ("founded", 1994.into()),
-        ],
-    );
-    cache
-        .set(sigurros_key.clone(), sigurros_data.clone())
-        .unwrap();
-
-    let result = cache.as_modifications();
-    assert_eq!(
-        sort_by_entity_key(result.unwrap().modifications),
-        sort_by_entity_key(vec![
-            EntityModification::Overwrite {
-                key: mogwai_key,
-                data: mogwai_data,
-            },
-            EntityModification::Overwrite {
-                key: sigurros_key,
-                data: sigurros_data,
-            }
-        ])
-    );
-}
-
-#[test]
-fn consecutive_modifications() {
-    // Pre-populate the store with data so that we can test setting a field to
-    // `Value::Null`.
-    let store = {
-        let entities = vec![
-            make_band(
-                "mogwai",
-                vec![
-                    ("id", "mogwai".into()),
-                    ("name", "Mogwai".into()),
-                    ("label", "Chemikal Underground".into()),
-                ],
-            )
-            .1,
-        ];
-
-        MockStore::new(entity_version_map("Band", entities))
-    };
-
-    let store = Arc::new(store);
-    let mut cache = EntityCache::new(store);
-
-    // First, add "founded" and change the "label".
-    let (update_key, update_data) = make_band(
-        "mogwai",
-        vec![
-            ("id", "mogwai".into()),
-            ("founded", 1995.into()),
-            ("label", "Rock Action Records".into()),
-        ],
-    );
-    cache.set(update_key, update_data).unwrap();
-
-    // Then, just reset the "label".
-    let (update_key, update_data) = make_band(
-        "mogwai",
-        vec![("id", "mogwai".into()), ("label", Value::Null)],
-    );
-    cache.set(update_key.clone(), update_data).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();
-    assert_eq!(
-        sort_by_entity_key(result.unwrap().modifications),
-        sort_by_entity_key(vec![EntityModification::Overwrite {
-            key: update_key,
-            data: Entity::from(vec![
-                ("id", "mogwai".into()),
-                ("name", "Mogwai".into()),
-                ("founded", 1995.into()),
-            ]),
-        },])
-    );
-}
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 17bd166e8d1..cec9330f072 100644
--- a/graphql/Cargo.toml
+++ b/graphql/Cargo.toml
@@ -4,21 +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 = "1.9"
-Inflector = "0.11.3"
-lazy_static = "1.2.0"
-stable-hash_legacy = { version = "0.3.3", package = "stable-hash" }
-stable-hash = { version = "0.4.2" }
-defer = "0.1"
+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.0"
+async-recursion = "1.1.1"
 
-[dev-dependencies]
-pretty_assertions = "1.3.0"
-test-store = { path = "../store/test-store" }
-graph-chain-ethereum = { path = "../chain/ethereum" }
+[lints]
+workspace = true
diff --git a/graphql/examples/schema.rs b/graphql/examples/schema.rs
index 0bf77f7a7bc..d29b23a77a9 100644
--- a/graphql/examples/schema.rs
+++ b/graphql/examples/schema.rs
@@ -1,10 +1,9 @@
-use graphql_parser::parse_schema;
+use graph::prelude::DeploymentHash;
+use graph::schema::InputSchema;
 use std::env;
 use std::fs;
 use std::process::exit;
 
-use graph_graphql::schema::api::api_schema;
-
 pub fn usage(msg: &str) -> ! {
     println!("{}", msg);
     println!("usage: schema schema.graphql");
@@ -30,11 +29,12 @@ pub fn main() {
         _ => usage("too many arguments"),
     };
     let schema = ensure(fs::read_to_string(schema), "Can not read schema file");
+    let id = DeploymentHash::new("unknown").unwrap();
     let schema = ensure(
-        parse_schema(&schema).map(|v| v.into_static()),
+        InputSchema::parse_latest(&schema, id),
         "Failed to parse schema",
     );
-    let schema = ensure(api_schema(&schema), "Failed to convert to API schema");
+    let schema = ensure(schema.api_schema(), "Failed to convert to API schema");
 
-    println!("{}", schema);
+    println!("{}", schema.schema().document);
 }
diff --git a/graphql/src/execution/ast.rs b/graphql/src/execution/ast.rs
index 2a0c19e6d36..cc9eeae5083 100644
--- a/graphql/src/execution/ast.rs
+++ b/graphql/src/execution/ast.rs
@@ -1,13 +1,12 @@
-use std::collections::HashSet;
+use std::collections::{BTreeSet, HashSet};
 
 use graph::{
-    components::store::EntityType,
-    data::graphql::ObjectOrInterface,
-    prelude::{anyhow, q, r, s, ApiSchema, QueryExecutionError, ValueMap},
+    components::store::{AggregationCurrent, AttributeNames, ChildMultiplicity, EntityOrder},
+    data::{graphql::ObjectOrInterface, store::ID},
+    env::ENV_VARS,
+    prelude::{QueryExecutionError, ValueMap, anyhow, q, r, s},
+    schema::{AggregationInterval, ApiSchema, EntityType, ast::ObjectType, kw},
 };
-use graphql_parser::Pos;
-
-use crate::schema::ast::ObjectType;
 
 /// 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
@@ -102,18 +101,25 @@ impl SelectionSet {
     pub fn fields_for(
         &self,
         obj_type: &ObjectType,
+    ) -> Result<impl Iterator<Item = &Field>, QueryExecutionError> {
+        self.fields_for_name(&obj_type.name)
+    }
+
+    fn fields_for_name(
+        &self,
+        name: &str,
     ) -> Result<impl Iterator<Item = &Field>, QueryExecutionError> {
         let item = self
             .items
             .iter()
-            .find(|(our_type, _)| our_type == obj_type)
+            .find(|(our_type, _)| our_type.name == name)
             .ok_or_else(|| {
                 // see: graphql-bug-compat
                 // Once queries are validated, this can become a panic since
                 // users won't be able to trigger this any more
                 QueryExecutionError::ValidationError(
                     None,
-                    format!("invalid query: no fields for type `{}`", obj_type.name),
+                    format!("invalid query: no fields for type `{}`", name),
                 )
             })?;
         Ok(item.1.iter())
@@ -184,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)>,
 }
@@ -228,12 +258,13 @@ 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)>,
     pub directives: Vec<Directive>,
     pub selection_set: SelectionSet,
+    pub multiplicity: ChildMultiplicity,
 }
 
 impl Field {
@@ -261,6 +292,98 @@ impl Field {
     fn is_leaf(&self) -> bool {
         self.selection_set.is_empty()
     }
+
+    /// Return the set of attributes that should be selected for this field.
+    /// If `ENV_VARS.enable_select_by_specific_attributes` is `false`,
+    /// return `AttributeNames::All
+    pub fn selected_attrs(
+        &self,
+        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(entity_type.typename())?;
+
+        // Extract the attributes we should select from `selection_set`. In
+        // particular, disregard derived fields since they are not stored
+        let mut column_names: BTreeSet<String> = fields
+            .filter(|field| {
+                // Keep fields that are not derived and for which we
+                // can find the field type
+                entity_type
+                    .field(&field.name)
+                    .is_some_and(|field| !field.is_derived())
+            })
+            .filter_map(|field| {
+                if field.name.starts_with("__") {
+                    None
+                } else {
+                    Some(field.name.clone())
+                }
+            })
+            .collect();
+
+        // 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
+            }
+        };
+        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)),
+                _ => {}
+            }
+        }
+
+        Err(QueryExecutionError::InvalidArgumentError(
+            self.position,
+            kw::CURRENT.to_string(),
+            q::Value::from(value.clone()),
+        ))
+    }
 }
 
 impl ValueMap for Field {
@@ -352,7 +475,7 @@ pub(crate) fn resolve_object_types(
         .ok_or_else(|| QueryExecutionError::AbstractTypeError(name.to_string()))?
     {
         s::TypeDefinition::Interface(intf) => {
-            for obj_ty in &schema.types_for_interface()[&EntityType::new(intf.name.to_string())] {
+            for obj_ty in &schema.types_for_interface()[&intf.name] {
                 let obj_ty = schema.object_type(obj_ty);
                 set.insert(obj_ty.into());
             }
diff --git a/graphql/src/execution/cache.rs b/graphql/src/execution/cache.rs
index 9343f5efbc6..de4387ace46 100644
--- a/graphql/src/execution/cache.rs
+++ b/graphql/src/execution/cache.rs
@@ -1,87 +1,11 @@
-use futures03::future::FutureExt;
-use futures03::future::Shared;
-use graph::{
-    prelude::{debug, futures03, BlockPtr, CheapClone, Logger, QueryResult},
-    util::timed_rw_lock::TimedMutex,
-};
-use stable_hash_legacy::crypto::SetHasher;
-use stable_hash_legacy::prelude::*;
-use std::future::Future;
-use std::pin::Pin;
-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::{hash_map::Entry, VecDeque},
-    time::Instant,
-};
+use std::{collections::VecDeque, time::Instant};
 
 use super::QueryHash;
 
-type Hash = <SetHasher as StableHasher>::Out;
-
-type PinFut<R> = Pin<Box<dyn Future<Output = R> + 'static + Send>>;
-/// Cache that keeps a result around as long as it is still being processed.
-/// The cache ensures that the query is not re-entrant, so multiple consumers
-/// of identical queries will not execute them in parallel.
-///
-/// This has a lot in common with AsyncCache in the network-services repo,
-/// but more specialized.
-pub struct QueryCache<R> {
-    cache: Arc<TimedMutex<HashMap<Hash, Shared<PinFut<R>>>>>,
-}
-
-impl<R: CheapClone> QueryCache<R> {
-    pub fn new(id: impl Into<String>) -> Self {
-        Self {
-            cache: Arc::new(TimedMutex::new(HashMap::new(), id)),
-        }
-    }
-
-    /// Assumption: Whatever F is passed in consistently returns the same
-    /// value for any input - for all values of F used with this Cache.
-    ///
-    /// Returns `(value, cached)`, where `cached` is true if the value was
-    /// already in the cache and false otherwise.
-    pub async fn cached_query<F: Future<Output = R> + Send + 'static>(
-        &self,
-        hash: Hash,
-        f: F,
-        logger: &Logger,
-    ) -> (R, bool) {
-        let f = f.boxed();
-
-        let (work, cached) = {
-            let mut cache = self.cache.lock(logger);
-
-            match cache.entry(hash) {
-                Entry::Occupied(entry) => {
-                    // This is already being worked on.
-                    let entry = entry.get().cheap_clone();
-                    (entry, true)
-                }
-                Entry::Vacant(entry) => {
-                    // New work, put it in the in-flight list.
-                    let uncached = f.shared();
-                    entry.insert(uncached.clone());
-                    (uncached, false)
-                }
-            }
-        };
-
-        let _remove_guard = if !cached {
-            // Make sure to remove this from the in-flight list, even if `poll` panics.
-            Some(defer::defer(|| {
-                self.cache.lock(logger).remove(&hash);
-            }))
-        } else {
-            None
-        };
-
-        (work.await, cached)
-    }
-}
-
 #[derive(Debug)]
 struct CacheByBlock {
     block: BlockPtr,
@@ -183,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 {
@@ -240,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 8f4d0259538..c3d116e6c64 100644
--- a/graphql/src/execution/execution.rs
+++ b/graphql/src/execution/execution.rs
@@ -1,10 +1,15 @@
-use super::cache::{QueryBlockCache, QueryCache};
+use super::cache::QueryBlockCache;
 use async_recursion::async_recursion;
 use crossbeam::atomic::AtomicCell;
 use graph::{
-    data::{query::Trace, schema::META_FIELD_NAME, value::Object},
-    prelude::{s, CheapClone},
-    util::{lfu_cache::EvictStats, timed_rw_lock::TimedMutex},
+    data::{
+        query::Trace,
+        value::{Object, Word},
+    },
+    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;
 use parking_lot::MutexGuard;
@@ -15,31 +20,42 @@ use graph::data::graphql::*;
 use graph::data::query::CacheStatus;
 use graph::env::CachedSubgraphIds;
 use graph::prelude::*;
+use graph::schema::ast as sast;
 use graph::util::{lfu_cache::LfuCache, stable_hash_glue::impl_stable_hash};
 
 use super::QueryHash;
 use crate::execution::ast as a;
-use crate::introspection::{is_introspection_field, INTROSPECTION_QUERY_TYPE};
 use crate::prelude::*;
-use crate::schema::ast as sast;
 
 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
     };
-    static ref QUERY_HERD_CACHE: QueryCache<Arc<QueryResult>> = QueryCache::new("query_herd_cache");
+    static ref QUERY_HERD_CACHE: HerdCache<Arc<QueryResult>> = HerdCache::new("query_herd_cache");
 }
 
 struct WeightedResult {
@@ -148,34 +164,37 @@ 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,
             evicted_count,
             stale_update,
             evict_time,
+            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,
-                        "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()
+                )
+            });
         }
     }
 }
@@ -207,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>(
@@ -234,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(),
         }
     }
 }
@@ -249,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
@@ -261,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 {
@@ -268,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?,
@@ -284,17 +330,102 @@ pub(crate) async fn execute_root_selection_set_uncached(
     if !intro_set.is_empty() {
         let ictx = ctx.as_introspection_context();
 
-        values.extend(
-            execute_selection_set_to_map(
-                &ictx,
-                ctx.query.selection_set.as_ref(),
-                &INTROSPECTION_QUERY_TYPE,
-                None,
-            )
-            .await?,
+        values.append(
+            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))
 }
 
@@ -317,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);
         }
     }
 
@@ -353,17 +484,23 @@ 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();
@@ -406,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,
@@ -538,7 +676,7 @@ async fn execute_selection_set_to_map<'a>(
     }
 
     if errors.is_empty() {
-        let obj = Object::from_iter(results.into_iter().map(|(k, v)| (k.to_owned(), v)));
+        let obj = Object::from_iter(results.into_iter().map(|(k, v)| (Word::from(k), v)));
         Ok(obj)
     } else {
         Err(errors)
@@ -588,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,
@@ -603,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,
@@ -666,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,
@@ -674,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
@@ -872,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 9a9b702e1af..c12d68d7fa9 100644
--- a/graphql/src/execution/query.rs
+++ b/graphql/src/execution/query.rs
@@ -1,8 +1,9 @@
+use graph::components::store::ChildMultiplicity;
 use graph::data::graphql::DocumentExt as _;
-use graph::data::value::Object;
-use graphql_parser::Pos;
+use graph::data::value::{Object, Word};
+use graph::schema::ApiSchema;
 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};
@@ -11,20 +12,20 @@ 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::schema::ApiSchema;
+use graph::data::query::{QueryExecutionError, Trace};
 use graph::prelude::{
-    info, o, q, r, s, warn, BlockNumber, CheapClone, DeploymentHash, GraphQLMetrics, Logger,
-    TryFromValue, ENV_VARS,
+    BlockNumber, CheapClone, DeploymentHash, ENV_VARS, EntityRange, GraphQLMetrics, Logger,
+    TryFromValue, info, o, q, r, s, warn,
 };
+use graph::schema::ErrorPolicy;
+use graph::schema::ast::{self as sast};
 
 use crate::execution::ast as a;
+use crate::execution::get_field;
 use crate::query::{ast as qast, ext::BlockConstraint};
-use crate::schema::ast::{self as sast};
 use crate::values::coercion;
-use crate::{execution::get_field, schema::api::ErrorPolicy};
 
 lazy_static! {
     static ref GRAPHQL_VALIDATION_PLAN: ValidationPlan =
@@ -34,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()),
@@ -68,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
@@ -129,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>,
@@ -225,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 {
@@ -268,7 +258,6 @@ impl Query {
             schema,
             selection_set: Arc::new(selection_set),
             shape_hash: query.shape_hash,
-            kind,
             network,
             logger,
             start,
@@ -280,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
@@ -299,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(),
                     )]
@@ -310,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(),
                     )]
@@ -335,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() {
@@ -487,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)
     }
@@ -559,7 +540,7 @@ impl<'s> RawQuery<'s> {
                                 q::Value::Int(n) => Some(n.as_i64()? as u64),
                                 _ => None,
                             })
-                            .unwrap_or(100);
+                            .unwrap_or(EntityRange::FIRST as u64);
                         max_entities
                             .checked_add(
                                 max_entities.checked_mul(field_complexity).ok_or(Overflow)?,
@@ -621,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))
             }
@@ -749,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) => {
@@ -777,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)
@@ -807,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,
@@ -849,7 +824,7 @@ impl Transform {
             ) {
                 Ok(Some(value)) => {
                     let value = if argument_def.name == *"text" {
-                        r::Value::Object(Object::from_iter(vec![(field_name.to_string(), value)]))
+                        r::Value::Object(Object::from_iter(vec![(Word::from(field_name), value)]))
                     } else {
                         value
                     };
@@ -907,6 +882,7 @@ impl Transform {
                 arguments: vec![],
                 directives: vec![],
                 selection_set: a::SelectionSet::new(vec![]),
+                multiplicity: ChildMultiplicity::Single,
             }));
         }
 
@@ -923,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);
@@ -945,6 +921,7 @@ impl Transform {
             self.expand_selection_set(selection_set, &type_set, ty)?
         };
 
+        let multiplicity = ChildMultiplicity::new(field_type);
         Ok(Some(a::Field {
             position,
             alias,
@@ -952,6 +929,7 @@ impl Transform {
             arguments,
             directives,
             selection_set,
+            multiplicity,
         }))
     }
 
diff --git a/graphql/src/execution/resolver.rs b/graphql/src/execution/resolver.rs
index f601b6f8f36..7e0609e98d4 100644
--- a/graphql/src/execution/resolver.rs
+++ b/graphql/src/execution/resolver.rs
@@ -1,22 +1,29 @@
-use graph::components::store::UnitStream;
-use graph::data::query::Trace;
-use graph::prelude::{async_trait, s, tokio, ApiSchema, Error, QueryExecutionError};
+use std::time::Duration;
+
+use async_trait::async_trait;
+
+use graph::components::store::QueryPermit;
+use graph::data::query::{CacheStatus, Trace};
+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;
 
 /// A GraphQL resolver that can resolve entities, enum values, scalar types and interfaces/unions.
 #[async_trait]
 pub trait Resolver: Sized + Send + Sync + 'static {
     const CACHEABLE: bool;
 
-    async fn query_permit(&self) -> Result<tokio::sync::OwnedSemaphorePermit, 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,
@@ -106,19 +113,11 @@ 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(())
     }
+
+    fn record_work(&self, _query: &Query, _elapsed: Duration, _cache_status: CacheStatus) {
+        // by default, record nothing
+    }
 }
diff --git a/graphql/src/introspection/mod.rs b/graphql/src/introspection/mod.rs
index 16b751284ee..7f4ccde25bd 100644
--- a/graphql/src/introspection/mod.rs
+++ b/graphql/src/introspection/mod.rs
@@ -1,5 +1,3 @@
 mod resolver;
-mod schema;
 
 pub use self::resolver::IntrospectionResolver;
-pub use self::schema::{is_introspection_field, INTROSPECTION_DOCUMENT, INTROSPECTION_QUERY_TYPE};
diff --git a/graphql/src/introspection/resolver.rs b/graphql/src/introspection/resolver.rs
index ff5b6bf49ce..39ead572448 100644
--- a/graphql/src/introspection/resolver.rs
+++ b/graphql/src/introspection/resolver.rs
@@ -1,14 +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 crate::schema::ast as sast;
+use graph::schema::{Schema, ast as sast};
 
 type TypeObjectsMap = BTreeMap<String, r::Value>;
 
@@ -33,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),
     }
 }
 
@@ -196,7 +197,7 @@ fn object_interfaces(
 ) -> r::Value {
     r::Value::List(
         schema
-            .interfaces_for_type(&object_type.into())
+            .interfaces_for_type(&object_type.name)
             .unwrap_or(&vec![])
             .iter()
             .map(|typedef| interface_type_object(schema, type_objects, typedef))
@@ -299,6 +300,8 @@ fn input_value(
                 .map_or(r::Value::Null, |value| {
                     r::Value::String(format!("{}", value))
                 }),
+        isDeprecated: false,
+        deprecationReason: r::Value::Null,
     }
 }
 
@@ -332,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(),
@@ -359,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<tokio::sync::OwnedSemaphorePermit, QueryExecutionError> {
+    async fn query_permit(&self) -> QueryPermit {
         unreachable!()
     }
 
-    fn prefetch(
+    async fn prefetch(
         &self,
         _: &ExecutionContext<Self>,
         _: &a::SelectionSet,
@@ -391,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())
@@ -424,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/introspection/schema.rs b/graphql/src/introspection/schema.rs
deleted file mode 100644
index 97379af3a42..00000000000
--- a/graphql/src/introspection/schema.rs
+++ /dev/null
@@ -1,132 +0,0 @@
-use std::sync::Arc;
-
-use graphql_parser;
-
-use graph::data::graphql::ext::DocumentExt;
-use graph::data::graphql::ext::ObjectTypeExt;
-use graph::prelude::s::Document;
-
-use lazy_static::lazy_static;
-
-use crate::schema::ast as sast;
-
-const INTROSPECTION_SCHEMA: &str = "
-scalar Boolean
-scalar Float
-scalar Int
-scalar ID
-scalar String
-
-type Query {
-  __schema: __Schema!
-  __type(name: String!): __Type
-}
-
-type __Schema {
-  types: [__Type!]!
-  queryType: __Type!
-  mutationType: __Type
-  subscriptionType: __Type
-  directives: [__Directive!]!
-}
-
-type __Type {
-  kind: __TypeKind!
-  name: String
-  description: String
-
-  # OBJECT and INTERFACE only
-  fields(includeDeprecated: Boolean = false): [__Field!]
-
-  # OBJECT only
-  interfaces: [__Type!]
-
-  # INTERFACE and UNION only
-  possibleTypes: [__Type!]
-
-  # ENUM only
-  enumValues(includeDeprecated: Boolean = false): [__EnumValue!]
-
-  # INPUT_OBJECT only
-  inputFields: [__InputValue!]
-
-  # NON_NULL and LIST only
-  ofType: __Type
-}
-
-type __Field {
-  name: String!
-  description: String
-  args: [__InputValue!]!
-  type: __Type!
-  isDeprecated: Boolean!
-  deprecationReason: String
-}
-
-type __InputValue {
-  name: String!
-  description: String
-  type: __Type!
-  defaultValue: String
-}
-
-type __EnumValue {
-  name: String!
-  description: String
-  isDeprecated: Boolean!
-  deprecationReason: String
-}
-
-enum __TypeKind {
-  SCALAR
-  OBJECT
-  INTERFACE
-  UNION
-  ENUM
-  INPUT_OBJECT
-  LIST
-  NON_NULL
-}
-
-type __Directive {
-  name: String!
-  description: String
-  locations: [__DirectiveLocation!]!
-  args: [__InputValue!]!
-}
-
-enum __DirectiveLocation {
-  QUERY
-  MUTATION
-  SUBSCRIPTION
-  FIELD
-  FRAGMENT_DEFINITION
-  FRAGMENT_SPREAD
-  INLINE_FRAGMENT
-  SCHEMA
-  SCALAR
-  OBJECT
-  FIELD_DEFINITION
-  ARGUMENT_DEFINITION
-  INTERFACE
-  UNION
-  ENUM
-  ENUM_VALUE
-  INPUT_OBJECT
-  INPUT_FIELD_DEFINITION
-}";
-
-lazy_static! {
-    pub static ref INTROSPECTION_DOCUMENT: Document =
-        graphql_parser::parse_schema(INTROSPECTION_SCHEMA).unwrap();
-    pub static ref INTROSPECTION_QUERY_TYPE: sast::ObjectType = sast::ObjectType::from(Arc::new(
-        INTROSPECTION_DOCUMENT
-            .get_root_query_type()
-            .unwrap()
-            .clone()
-    ));
-}
-
-pub fn is_introspection_field(name: &str) -> bool {
-    INTROSPECTION_QUERY_TYPE.field(name).is_some()
-}
diff --git a/graphql/src/lib.rs b/graphql/src/lib.rs
index 310f58a98d4..9869d0a5344 100644
--- a/graphql/src/lib.rs
+++ b/graphql/src/lib.rs
@@ -1,8 +1,3 @@
-pub extern crate graphql_parser;
-
-/// Utilities for working with GraphQL schemas.
-pub mod schema;
-
 /// Utilities for schema introspection.
 pub mod introspection;
 
@@ -12,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;
 
@@ -29,12 +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::schema::{api_schema, APISchemaError};
+    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/metrics.rs b/graphql/src/metrics.rs
index 69d17ed5c01..549945bdeec 100644
--- a/graphql/src/metrics.rs
+++ b/graphql/src/metrics.rs
@@ -14,6 +14,7 @@ pub struct GraphQLMetrics {
     query_result_size: Box<Histogram>,
     query_result_size_max: Box<Gauge>,
     query_validation_error_counter: Box<CounterVec>,
+    query_blocks_behind: Box<HistogramVec>,
 }
 
 impl fmt::Debug for GraphQLMetrics {
@@ -73,10 +74,16 @@ impl GraphQLMetricsTrait for GraphQLMetrics {
                 .inc();
         }
     }
+
+    fn observe_query_blocks_behind(&self, blocks_behind: i32, id: &DeploymentHash) {
+        self.query_blocks_behind
+            .with_label_values(&[id.as_str()])
+            .observe(blocks_behind as f64);
+    }
 }
 
 impl GraphQLMetrics {
-    pub fn new(registry: Arc<dyn MetricsRegistry>) -> Self {
+    pub fn new(registry: Arc<MetricsRegistry>) -> Self {
         let query_execution_time = registry
             .new_histogram_vec(
                 "query_execution_time",
@@ -128,6 +135,18 @@ impl GraphQLMetrics {
             )
             .unwrap();
 
+        let query_blocks_behind = registry
+            .new_histogram_vec(
+                "query_blocks_behind",
+                "How many blocks the query block is behind the subgraph head",
+                vec![String::from("deployment")],
+                vec![
+                    0.0, 5.0, 10.0, 20.0, 30.0, 40.0, 50.0, 100.0, 200.0, 500.0, 1000.0, 10000.0,
+                    100000.0, 1000000.0, 10000000.0,
+                ],
+            )
+            .unwrap();
+
         Self {
             query_execution_time,
             query_parsing_time,
@@ -135,12 +154,13 @@ impl GraphQLMetrics {
             query_result_size,
             query_result_size_max,
             query_validation_error_counter,
+            query_blocks_behind,
         }
     }
 
     // Tests need to construct one of these, but normal code doesn't
     #[cfg(debug_assertions)]
-    pub fn make(registry: Arc<dyn MetricsRegistry>) -> Self {
+    pub fn make(registry: Arc<MetricsRegistry>) -> Self {
         Self::new(registry)
     }
 
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 707b87936a0..86244c4cc71 100644
--- a/graphql/src/query/mod.rs
+++ b/graphql/src/query/mod.rs
@@ -1,9 +1,10 @@
-use graph::prelude::{BlockPtr, CheapClone, QueryExecutionError, QueryResult};
+use graph::{
+    data::query::CacheStatus,
+    prelude::{BlockPtr, CheapClone, QueryResult},
+};
 use std::sync::Arc;
 use std::time::Instant;
 
-use graph::data::graphql::effort::LoadManager;
-
 use crate::execution::{ast as a, *};
 
 /// Utilities for working with GraphQL query ASTs.
@@ -26,10 +27,11 @@ pub struct QueryExecutionOptions<R> {
     /// Maximum value for the `skip` argument
     pub max_skip: u32,
 
-    pub load_manager: Arc<LoadManager>,
-
     /// 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.
@@ -39,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,
 {
@@ -53,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());
@@ -76,14 +74,13 @@ where
     .await;
     let elapsed = start.elapsed();
     let cache_status = ctx.cache_status.load();
-    options
-        .load_manager
-        .record_work(query.shape_hash, elapsed, cache_status);
+    ctx.resolver
+        .record_work(query.as_ref(), elapsed, cache_status);
     query.log_cache_status(
         &selection_set,
         block_ptr.map(|b| b.number).unwrap_or(0),
         start,
         cache_status.to_string(),
     );
-    result
+    (result, cache_status)
 }
diff --git a/graphql/src/runner.rs b/graphql/src/runner.rs
index 89b2c2d182a..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::effort::LoadManager, prelude::QueryStoreManager};
+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<dyn MetricsRegistry>,
+        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,49 +150,66 @@ 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(),
+                self.load_manager.cheap_clone(),
             )
             .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),
-                    load_manager: self.load_manager.clone(),
-                    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)
@@ -186,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(
@@ -225,58 +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)?,
-                query.shape_hash,
-                query.query_text.as_ref(),
+                &store.wait_stats(),
+                store.shard(),
+                store.deployment_id(),
+                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(),
-            },
-        )
-    }
+        let query_start = Instant::now();
+        let result = store.execute_sql(&req.query).await;
 
-    fn load_manager(&self) -> Arc<LoadManager> {
-        self.load_manager.clone()
-    }
+        self.load_manager.record_work(
+            store.shard(),
+            store.deployment_id(),
+            query_hash,
+            query_start.elapsed(),
+            CacheStatus::Miss,
+        );
 
-    fn metrics(&self) -> Arc<dyn GraphQLMetricsTrait> {
-        self.graphql_metrics.clone()
+        result
     }
 }
diff --git a/graphql/src/schema/api.rs b/graphql/src/schema/api.rs
deleted file mode 100644
index dad30d997ae..00000000000
--- a/graphql/src/schema/api.rs
+++ /dev/null
@@ -1,1679 +0,0 @@
-use std::str::FromStr;
-
-use graphql_parser::{schema::TypeDefinition, Pos};
-use inflector::Inflector;
-use lazy_static::lazy_static;
-
-use crate::schema::ast;
-
-use graph::data::{
-    graphql::ext::{DirectiveExt, DocumentExt, ValueExt},
-    schema::{META_FIELD_NAME, META_FIELD_TYPE, SCHEMA_TYPE_NAME},
-};
-use graph::prelude::s::{Value, *};
-use graph::prelude::*;
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum APISchemaError {
-    #[error("type {0} already exists in the input schema")]
-    TypeExists(String),
-    #[error("Type {0} not found")]
-    TypeNotFound(String),
-    #[error("Fulltext search is not yet deterministic")]
-    FulltextSearchNonDeterministic,
-}
-
-// The followoing types are defined in meta.graphql
-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)]
-pub enum ErrorPolicy {
-    Allow,
-    Deny,
-}
-
-impl std::str::FromStr for ErrorPolicy {
-    type Err = anyhow::Error;
-
-    fn from_str(s: &str) -> Result<ErrorPolicy, anyhow::Error> {
-        match s {
-            "allow" => Ok(ErrorPolicy::Allow),
-            "deny" => Ok(ErrorPolicy::Deny),
-            _ => Err(anyhow::anyhow!("failed to parse `{}` as ErrorPolicy", s)),
-        }
-    }
-}
-
-impl TryFrom<&q::Value> for ErrorPolicy {
-    type Error = anyhow::Error;
-
-    /// `value` should be the output of input value coercion.
-    fn try_from(value: &q::Value) -> Result<Self, Self::Error> {
-        match value {
-            q::Value::Enum(s) => ErrorPolicy::from_str(s),
-            _ => Err(anyhow::anyhow!("invalid `ErrorPolicy`")),
-        }
-    }
-}
-
-impl TryFrom<&r::Value> for ErrorPolicy {
-    type Error = anyhow::Error;
-
-    /// `value` should be the output of input value coercion.
-    fn try_from(value: &r::Value) -> Result<Self, Self::Error> {
-        match value {
-            r::Value::Enum(s) => ErrorPolicy::from_str(s),
-            _ => Err(anyhow::anyhow!("invalid `ErrorPolicy`")),
-        }
-    }
-}
-
-/// Derives a full-fledged GraphQL API schema from an input schema.
-///
-/// 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 fn api_schema(input_schema: &Document) -> Result<Document, APISchemaError> {
-    // Refactor: Take `input_schema` by value.
-    let object_types = input_schema.get_object_type_definitions();
-    let interface_types = input_schema.get_interface_type_definitions();
-
-    // Refactor: Don't clone the schema.
-    let mut schema = input_schema.clone();
-    add_meta_field_type(&mut schema);
-    add_types_for_object_types(&mut schema, &object_types)?;
-    add_types_for_interface_types(&mut schema, &interface_types)?;
-    add_field_arguments(&mut schema, input_schema)?;
-    add_query_type(&mut schema, &object_types, &interface_types)?;
-    add_subscription_type(&mut schema, &object_types, &interface_types)?;
-
-    // Remove the `_Schema_` type from the generated schema.
-    schema.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,
-    });
-
-    Ok(schema)
-}
-
-/// Adds a global `_Meta_` type to the schema. The `_meta` field
-/// accepts values of this type
-fn add_meta_field_type(schema: &mut Document) {
-    lazy_static! {
-        static ref META_FIELD_SCHEMA: Document = {
-            let schema = include_str!("meta.graphql");
-            parse_schema(schema).expect("the schema `meta.graphql` is invalid")
-        };
-    }
-
-    schema
-        .definitions
-        .extend(META_FIELD_SCHEMA.definitions.iter().cloned());
-}
-
-fn add_types_for_object_types(
-    schema: &mut Document,
-    object_types: &[&ObjectType],
-) -> Result<(), APISchemaError> {
-    for object_type in object_types {
-        if !object_type.name.eq(SCHEMA_TYPE_NAME) {
-            add_order_by_type(schema, &object_type.name, &object_type.fields)?;
-            add_filter_type(schema, &object_type.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 Document,
-    interface_types: &[&InterfaceType],
-) -> Result<(), APISchemaError> {
-    for interface_type in interface_types {
-        add_order_by_type(schema, &interface_type.name, &interface_type.fields)?;
-        add_filter_type(schema, &interface_type.name, &interface_type.fields)?;
-    }
-    Ok(())
-}
-
-/// Adds a `<type_name>_orderBy` enum type for the given fields to the schema.
-fn add_order_by_type(
-    schema: &mut Document,
-    type_name: &str,
-    fields: &[Field],
-) -> Result<(), APISchemaError> {
-    let type_name = format!("{}_orderBy", type_name);
-
-    match schema.get_named_type(&type_name) {
-        None => {
-            let typedef = TypeDefinition::Enum(EnumType {
-                position: Pos::default(),
-                description: None,
-                name: type_name,
-                directives: vec![],
-                values: field_enum_values(schema, fields)?,
-            });
-            let def = Definition::TypeDefinition(typedef);
-            schema.definitions.push(def);
-        }
-        Some(_) => return Err(APISchemaError::TypeExists(type_name)),
-    }
-    Ok(())
-}
-
-/// Generates enum values for the given set of fields.
-fn field_enum_values(
-    schema: &Document,
-    fields: &[Field],
-) -> Result<Vec<EnumValue>, APISchemaError> {
-    let mut enum_values = vec![];
-    for field in fields {
-        enum_values.push(EnumValue {
-            position: Pos::default(),
-            description: None,
-            name: field.name.clone(),
-            directives: vec![],
-        });
-        enum_values.extend(field_enum_values_from_child_entity(schema, field)?);
-    }
-    Ok(enum_values)
-}
-
-fn enum_value_from_child_entity_field(
-    schema: &Document,
-    parent_field_name: &str,
-    field: &Field,
-) -> Option<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(),
-            description: None,
-            name: format!("{}__{}", parent_field_name, field.name),
-            directives: vec![],
-        })
-    }
-}
-
-fn field_enum_values_from_child_entity(
-    schema: &Document,
-    field: &Field,
-) -> Result<Vec<EnumValue>, APISchemaError> {
-    fn resolve_supported_type_name(field_type: &Type) -> Option<&String> {
-        match field_type {
-            Type::NamedType(name) => Some(name),
-            Type::ListType(_) => None,
-            Type::NonNullType(of_type) => resolve_supported_type_name(of_type),
-        }
-    }
-
-    let type_name = match ENV_VARS.graphql.disable_child_sorting {
-        true => None,
-        false => resolve_supported_type_name(&field.field_type),
-    };
-
-    Ok(match type_name {
-        Some(name) => {
-            let named_type = schema
-                .get_named_type(name)
-                .ok_or_else(|| APISchemaError::TypeNotFound(name.clone()))?;
-            match named_type {
-                TypeDefinition::Object(ObjectType { fields, .. })
-                | TypeDefinition::Interface(InterfaceType { fields, .. }) => fields
-                    .iter()
-                    .filter_map(|f| {
-                        enum_value_from_child_entity_field(schema, field.name.as_str(), f)
-                    })
-                    .collect(),
-                _ => vec![],
-            }
-        }
-        None => vec![],
-    })
-}
-
-/// Adds a `<type_name>_filter` enum type for the given fields to the schema.
-fn add_filter_type(
-    schema: &mut Document,
-    type_name: &str,
-    fields: &[Field],
-) -> Result<(), APISchemaError> {
-    let filter_type_name = format!("{}_filter", type_name);
-    match schema.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 !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![],
-                });
-
-                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![],
-                });
-            }
-
-            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.definitions.push(def);
-        }
-        Some(_) => return Err(APISchemaError::TypeExists(filter_type_name)),
-    }
-
-    Ok(())
-}
-
-/// Generates `*_filter` input values for the given set of fields.
-fn field_input_values(
-    schema: &Document,
-    fields: &[Field],
-) -> Result<Vec<InputValue>, APISchemaError> {
-    let mut input_values = vec![];
-    for field in fields {
-        input_values.extend(field_filter_input_values(schema, field, &field.field_type)?);
-    }
-    Ok(input_values)
-}
-
-/// Generates `*_filter` input values for the given field.
-fn field_filter_input_values(
-    schema: &Document,
-    field: &Field,
-    field_type: &Type,
-) -> Result<Vec<InputValue>, APISchemaError> {
-    match field_type {
-        Type::NamedType(ref name) => {
-            let named_type = schema
-                .get_named_type(name)
-                .ok_or_else(|| APISchemaError::TypeNotFound(name.clone()))?;
-            Ok(match named_type {
-                TypeDefinition::Object(_) | TypeDefinition::Interface(_) => {
-                    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,
-                            field,
-                            &ScalarType::new(String::from("String")),
-                        ),
-                    };
-                    extend_with_child_filter_input_value(field, name, &mut input_values);
-                    input_values
-                }
-                TypeDefinition::Scalar(ref t) => field_scalar_filter_input_values(schema, field, t),
-                TypeDefinition::Enum(ref t) => field_enum_filter_input_values(schema, 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),
-    }
-}
-
-/// 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![
-            "",
-            "not",
-            "gt",
-            "lt",
-            "gte",
-            "lte",
-            "in",
-            "not_in",
-            "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"],
-        "String" => vec![
-            "",
-            "not",
-            "gt",
-            "lt",
-            "gte",
-            "lte",
-            "in",
-            "not_in",
-            "contains",
-            "contains_nocase",
-            "not_contains",
-            "not_contains_nocase",
-            "starts_with",
-            "starts_with_nocase",
-            "not_starts_with",
-            "not_starts_with_nocase",
-            "ends_with",
-            "ends_with_nocase",
-            "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()
-}
-
-/// 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>,
-) {
-    input_values.push(input_value(
-        &format!("{}_", field.name),
-        "",
-        Type::NamedType(format!("{}_filter", field_type_name)),
-    ));
-}
-
-/// Generates `*_filter` input values for the given enum field.
-fn field_enum_filter_input_values(
-    _schema: &Document,
-    field: &Field,
-    field_type: &EnumType,
-) -> Vec<InputValue> {
-    vec!["", "not", "in", "not_in"]
-        .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()
-}
-
-/// Generates `*_filter` input values for the given list field.
-fn field_list_filter_input_values(
-    schema: &Document,
-    field: &Field,
-    field_type: &Type,
-) -> Option<Vec<InputValue>> {
-    // Only add a filter field if the type of the field exists in the schema
-    ast::get_type_definition_from_type(schema, field_type).map(|typedef| {
-        // Decide what type of values can be passed to the filter. In the case
-        // one-to-many or many-to-many object or interface fields that are not
-        // 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() {
-                    (None, Some(name.clone()))
-                } else {
-                    (Some(Type::NamedType("String".into())), 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),
-        };
-
-        let mut input_values: Vec<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(),
-        };
-
-        if let Some(parent) = parent_type_name {
-            extend_with_child_filter_input_value(field, &parent, &mut input_values);
-        }
-
-        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(),
-        description: None,
-        name: if suffix.is_empty() {
-            name.to_owned()
-        } else {
-            format!("{}_{}", name, suffix)
-        },
-        value_type,
-        default_value: None,
-        directives: vec![],
-    }
-}
-
-/// Adds a root `Query` object type to the schema.
-fn add_query_type(
-    schema: &mut Document,
-    object_types: &[&ObjectType],
-    interface_types: &[&InterfaceType],
-) -> Result<(), APISchemaError> {
-    let type_name = String::from("Query");
-
-    if schema.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
-        .get_fulltext_directives()
-        .map_err(|_| APISchemaError::FulltextSearchNonDeterministic)?
-        .iter()
-        .filter_map(|fulltext| query_field_for_fulltext(fulltext))
-        .collect();
-    fields.append(&mut fulltext_fields);
-    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 query_field_for_fulltext(fulltext: &Directive) -> Option<Field> {
-    let name = fulltext.argument("name").unwrap().as_str().unwrap().into();
-
-    let includes = fulltext.argument("include").unwrap().as_list().unwrap();
-    // Only one include is allowed per fulltext directive
-    let include = includes.iter().next().unwrap();
-    let included_entity = include.as_object().unwrap();
-    let entity_name = included_entity.get("entity").unwrap().as_str().unwrap();
-
-    let mut arguments = vec![
-        // text: String
-        InputValue {
-            position: Pos::default(),
-            description: None,
-            name: String::from("text"),
-            value_type: Type::NonNullType(Box::new(Type::NamedType(String::from("String")))),
-            default_value: None,
-            directives: vec![],
-        },
-        // first: Int
-        InputValue {
-            position: Pos::default(),
-            description: None,
-            name: String::from("first"),
-            value_type: Type::NamedType(String::from("Int")),
-            default_value: Some(Value::Int(100.into())),
-            directives: vec![],
-        },
-        // skip: Int
-        InputValue {
-            position: Pos::default(),
-            description: None,
-            name: String::from("skip"),
-            value_type: Type::NamedType(String::from("Int")),
-            default_value: Some(Value::Int(0.into())),
-            directives: vec![],
-        },
-        // block: BlockHeight
-        block_argument(),
-    ];
-
-    arguments.push(subgraph_error_argument());
-
-    Some(Field {
-        position: 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
-        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(),
-        description: Some(
-            "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."
-                .to_owned(),
-        ),
-        name: "block".to_string(),
-        value_type: Type::NamedType(BLOCK_HEIGHT.to_owned()),
-        default_value: None,
-        directives: vec![],
-    }
-}
-
-fn block_changed_filter_argument() -> InputValue {
-    InputValue {
-        position: 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()),
-        default_value: None,
-        directives: vec![],
-    }
-}
-
-fn subgraph_error_argument() -> InputValue {
-    InputValue {
-        position: 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())),
-        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);
-    collection_arguments.push(block_argument());
-
-    let mut by_id_arguments = vec![
-        InputValue {
-            position: Pos::default(),
-            description: None,
-            name: "id".to_string(),
-            value_type: Type::NonNullType(Box::new(Type::NamedType("ID".to_string()))),
-            default_value: None,
-            directives: vec![],
-        },
-        block_argument(),
-    ];
-
-    collection_arguments.push(subgraph_error_argument());
-    by_id_arguments.push(subgraph_error_argument());
-
-    vec![
-        Field {
-            position: 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()`
-            arguments: by_id_arguments,
-            field_type: Type::NamedType(type_name.to_owned()),
-            directives: vec![],
-        },
-        Field {
-            position: 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()`
-            arguments: collection_arguments,
-            field_type: Type::NonNullType(Box::new(Type::ListType(Box::new(Type::NonNullType(
-                Box::new(Type::NamedType(type_name.to_owned())),
-            ))))),
-            directives: vec![],
-        },
-    ]
-}
-
-fn meta_field() -> Field {
-    lazy_static! {
-        static ref META_FIELD: Field = Field {
-            position: Pos::default(),
-            description: Some("Access to subgraph metadata".to_string()),
-            name: META_FIELD_NAME.to_string(),
-            arguments: vec![
-                // block: BlockHeight
-                InputValue {
-                    position: Pos::default(),
-                    description: None,
-                    name: String::from("block"),
-                    value_type: Type::NamedType(BLOCK_HEIGHT.to_string()),
-                    default_value: None,
-                    directives: vec![],
-                },
-            ],
-            field_type: 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"
-                        ),
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
-
-#[cfg(test)]
-mod tests {
-    use graph::data::graphql::DocumentExt;
-    use graphql_parser::schema::*;
-
-    use super::api_schema;
-    use crate::schema::ast;
-
-    #[test]
-    fn api_schema_contains_built_in_scalar_types() {
-        let input_schema =
-            parse_schema("type User { id: ID! }").expect("Failed to parse input schema");
-        let schema = api_schema(&input_schema).expect("Failed to derive API schema");
-
-        schema
-            .get_named_type("Boolean")
-            .expect("Boolean type is missing in API schema");
-        schema
-            .get_named_type("ID")
-            .expect("ID type is missing in API schema");
-        schema
-            .get_named_type("Int")
-            .expect("Int type is missing in API schema");
-        schema
-            .get_named_type("BigDecimal")
-            .expect("BigDecimal type is missing in API schema");
-        schema
-            .get_named_type("String")
-            .expect("String type is missing in API schema");
-    }
-
-    #[test]
-    fn api_schema_contains_order_direction_enum() {
-        let input_schema = parse_schema("type User { id: ID!, name: String! }")
-            .expect("Failed to parse input schema");
-        let schema = api_schema(&input_schema).expect("Failed to derived API schema");
-
-        let order_direction = schema
-            .get_named_type("OrderDirection")
-            .expect("OrderDirection type is missing in derived API schema");
-        let enum_type = match order_direction {
-            TypeDefinition::Enum(t) => Some(t),
-            _ => None,
-        }
-        .expect("OrderDirection type is not an enum");
-
-        let values: Vec<&str> = enum_type
-            .values
-            .iter()
-            .map(|value| value.name.as_str())
-            .collect();
-        assert_eq!(values, ["asc", "desc"]);
-    }
-
-    #[test]
-    fn api_schema_contains_query_type() {
-        let input_schema =
-            parse_schema("type User { id: ID! }").expect("Failed to parse input schema");
-        let schema = api_schema(&input_schema).expect("Failed to derive API schema");
-        schema
-            .get_named_type("Query")
-            .expect("Root Query type is missing in API schema");
-    }
-
-    #[test]
-    fn api_schema_contains_field_order_by_enum() {
-        let input_schema = parse_schema("type User { id: ID!, name: String! }")
-            .expect("Failed to parse input schema");
-        let schema = api_schema(&input_schema).expect("Failed to derived API schema");
-
-        let user_order_by = schema
-            .get_named_type("User_orderBy")
-            .expect("User_orderBy type is missing in derived API schema");
-
-        let enum_type = match user_order_by {
-            TypeDefinition::Enum(t) => Some(t),
-            _ => None,
-        }
-        .expect("User_orderBy type is not an enum");
-
-        let values: Vec<&str> = enum_type
-            .values
-            .iter()
-            .map(|value| value.name.as_str())
-            .collect();
-        assert_eq!(values, ["id", "name"]);
-    }
-
-    #[test]
-    fn api_schema_contains_field_order_by_enum_for_child_entity() {
-        let input_schema = parse_schema(
-            r#"
-              enum FurType {
-                  NONE
-                  FLUFFY
-                  BRISTLY
-              }
-
-              type Pet {
-                  id: ID!
-                  name: String!
-                  mostHatedBy: [User!]!
-                  mostLovedBy: [User!]!
-              }
-
-              interface Recipe {
-                id: ID!
-                name: String!
-                author: User!
-                lovedBy: [User!]!
-                ingredients: [String!]!
-              }
-
-              type FoodRecipe implements Recipe {
-                id: ID!
-                name: String!
-                author: User!
-                ingredients: [String!]!
-              }
-
-              type DrinkRecipe implements Recipe {
-                id: ID!
-                name: String!
-                author: User!
-                ingredients: [String!]!
-              }
-
-              interface Meal {
-                id: ID!
-                name: String!
-                mostHatedBy: [User!]!
-                mostLovedBy: [User!]!
-              }
-
-              type Pizza implements Meal {
-                id: ID!
-                name: String!
-                toppings: [String!]!
-                mostHatedBy: [User!]!
-                mostLovedBy: [User!]!
-              }
-
-              type Burger implements Meal {
-                id: ID!
-                name: String!
-                bun: String!
-                mostHatedBy: [User!]!
-                mostLovedBy: [User!]!
-              }
-
-              type User {
-                  id: ID!
-                  name: String!
-                  favoritePetNames: [String!]
-                  pets: [Pet!]!
-                  favoriteFurType: FurType!
-                  favoritePet: Pet!
-                  leastFavoritePet: Pet @derivedFrom(field: "mostHatedBy")
-                  mostFavoritePets: [Pet!] @derivedFrom(field: "mostLovedBy")
-                  favoriteMeal: Meal!
-                  leastFavoriteMeal: Meal @derivedFrom(field: "mostHatedBy")
-                  mostFavoriteMeals: [Meal!] @derivedFrom(field: "mostLovedBy")
-                  recipes: [Recipe!]! @derivedFrom(field: "author")
-              }
-            "#,
-        )
-        .expect("Failed to parse input schema");
-        let schema = api_schema(&input_schema).expect("Failed to derived API schema");
-
-        let user_order_by = schema
-            .get_named_type("User_orderBy")
-            .expect("User_orderBy type is missing in derived API schema");
-
-        let enum_type = match user_order_by {
-            TypeDefinition::Enum(t) => Some(t),
-            _ => None,
-        }
-        .expect("User_orderBy type is not an enum");
-
-        let values: Vec<&str> = enum_type
-            .values
-            .iter()
-            .map(|value| value.name.as_str())
-            .collect();
-
-        assert_eq!(
-            values,
-            [
-                "id",
-                "name",
-                "favoritePetNames",
-                "pets",
-                "favoriteFurType",
-                "favoritePet",
-                "favoritePet__id",
-                "favoritePet__name",
-                "leastFavoritePet",
-                "leastFavoritePet__id",
-                "leastFavoritePet__name",
-                "mostFavoritePets",
-                "favoriteMeal",
-                "favoriteMeal__id",
-                "favoriteMeal__name",
-                "leastFavoriteMeal",
-                "leastFavoriteMeal__id",
-                "leastFavoriteMeal__name",
-                "mostFavoriteMeals",
-                "recipes",
-            ]
-        );
-
-        let meal_order_by = schema
-            .get_named_type("Meal_orderBy")
-            .expect("Meal_orderBy type is missing in derived API schema");
-
-        let enum_type = match meal_order_by {
-            TypeDefinition::Enum(t) => Some(t),
-            _ => None,
-        }
-        .expect("Meal_orderBy type is not an enum");
-
-        let values: Vec<&str> = enum_type
-            .values
-            .iter()
-            .map(|value| value.name.as_str())
-            .collect();
-
-        assert_eq!(values, ["id", "name", "mostHatedBy", "mostLovedBy",]);
-
-        let recipe_order_by = schema
-            .get_named_type("Recipe_orderBy")
-            .expect("Recipe_orderBy type is missing in derived API schema");
-
-        let enum_type = match recipe_order_by {
-            TypeDefinition::Enum(t) => Some(t),
-            _ => None,
-        }
-        .expect("Recipe_orderBy type is not an enum");
-
-        let values: Vec<&str> = enum_type
-            .values
-            .iter()
-            .map(|value| value.name.as_str())
-            .collect();
-
-        assert_eq!(
-            values,
-            [
-                "id",
-                "name",
-                "author",
-                "author__id",
-                "author__name",
-                "author__favoriteFurType",
-                "author__favoritePet",
-                "author__leastFavoritePet",
-                "lovedBy",
-                "ingredients"
-            ]
-        );
-    }
-
-    #[test]
-    fn api_schema_contains_object_type_filter_enum() {
-        let input_schema = parse_schema(
-            r#"
-              enum FurType {
-                  NONE
-                  FLUFFY
-                  BRISTLY
-              }
-
-              type Pet {
-                  id: ID!
-                  name: String!
-                  mostHatedBy: [User!]!
-                  mostLovedBy: [User!]!
-              }
-
-              type User {
-                  id: ID!
-                  name: String!
-                  favoritePetNames: [String!]
-                  pets: [Pet!]!
-                  favoriteFurType: FurType!
-                  favoritePet: Pet!
-                  leastFavoritePet: Pet @derivedFrom(field: "mostHatedBy")
-                  mostFavoritePets: [Pet!] @derivedFrom(field: "mostLovedBy")
-              }
-            "#,
-        )
-        .expect("Failed to parse input schema");
-        let schema = api_schema(&input_schema).expect("Failed to derived API schema");
-
-        let user_filter = schema
-            .get_named_type("User_filter")
-            .expect("User_filter type is missing in derived API schema");
-
-        let user_filter_type = match user_filter {
-            TypeDefinition::InputObject(t) => Some(t),
-            _ => None,
-        }
-        .expect("User_filter type is not an input object");
-
-        assert_eq!(
-            user_filter_type
-                .fields
-                .iter()
-                .map(|field| field.name.clone())
-                .collect::<Vec<String>>(),
-            [
-                "id",
-                "id_not",
-                "id_gt",
-                "id_lt",
-                "id_gte",
-                "id_lte",
-                "id_in",
-                "id_not_in",
-                "name",
-                "name_not",
-                "name_gt",
-                "name_lt",
-                "name_gte",
-                "name_lte",
-                "name_in",
-                "name_not_in",
-                "name_contains",
-                "name_contains_nocase",
-                "name_not_contains",
-                "name_not_contains_nocase",
-                "name_starts_with",
-                "name_starts_with_nocase",
-                "name_not_starts_with",
-                "name_not_starts_with_nocase",
-                "name_ends_with",
-                "name_ends_with_nocase",
-                "name_not_ends_with",
-                "name_not_ends_with_nocase",
-                "favoritePetNames",
-                "favoritePetNames_not",
-                "favoritePetNames_contains",
-                "favoritePetNames_contains_nocase",
-                "favoritePetNames_not_contains",
-                "favoritePetNames_not_contains_nocase",
-                "pets",
-                "pets_not",
-                "pets_contains",
-                "pets_contains_nocase",
-                "pets_not_contains",
-                "pets_not_contains_nocase",
-                "pets_",
-                "favoriteFurType",
-                "favoriteFurType_not",
-                "favoriteFurType_in",
-                "favoriteFurType_not_in",
-                "favoritePet",
-                "favoritePet_not",
-                "favoritePet_gt",
-                "favoritePet_lt",
-                "favoritePet_gte",
-                "favoritePet_lte",
-                "favoritePet_in",
-                "favoritePet_not_in",
-                "favoritePet_contains",
-                "favoritePet_contains_nocase",
-                "favoritePet_not_contains",
-                "favoritePet_not_contains_nocase",
-                "favoritePet_starts_with",
-                "favoritePet_starts_with_nocase",
-                "favoritePet_not_starts_with",
-                "favoritePet_not_starts_with_nocase",
-                "favoritePet_ends_with",
-                "favoritePet_ends_with_nocase",
-                "favoritePet_not_ends_with",
-                "favoritePet_not_ends_with_nocase",
-                "favoritePet_",
-                "leastFavoritePet_",
-                "mostFavoritePets_",
-                "_change_block",
-                "and",
-                "or"
-            ]
-            .iter()
-            .map(ToString::to_string)
-            .collect::<Vec<String>>()
-        );
-
-        let pets_field = user_filter_type
-            .fields
-            .iter()
-            .find(|field| field.name == "pets_")
-            .expect("pets_ field is missing");
-
-        assert_eq!(
-            pets_field.value_type.to_string(),
-            String::from("Pet_filter")
-        );
-
-        let pet_filter = schema
-            .get_named_type("Pet_filter")
-            .expect("Pet_filter type is missing in derived API schema");
-
-        let pet_filter_type = match pet_filter {
-            TypeDefinition::InputObject(t) => Some(t),
-            _ => None,
-        }
-        .expect("Pet_filter type is not an input object");
-
-        assert_eq!(
-            pet_filter_type
-                .fields
-                .iter()
-                .map(|field| field.name.clone())
-                .collect::<Vec<String>>(),
-            [
-                "id",
-                "id_not",
-                "id_gt",
-                "id_lt",
-                "id_gte",
-                "id_lte",
-                "id_in",
-                "id_not_in",
-                "name",
-                "name_not",
-                "name_gt",
-                "name_lt",
-                "name_gte",
-                "name_lte",
-                "name_in",
-                "name_not_in",
-                "name_contains",
-                "name_contains_nocase",
-                "name_not_contains",
-                "name_not_contains_nocase",
-                "name_starts_with",
-                "name_starts_with_nocase",
-                "name_not_starts_with",
-                "name_not_starts_with_nocase",
-                "name_ends_with",
-                "name_ends_with_nocase",
-                "name_not_ends_with",
-                "name_not_ends_with_nocase",
-                "mostHatedBy",
-                "mostHatedBy_not",
-                "mostHatedBy_contains",
-                "mostHatedBy_contains_nocase",
-                "mostHatedBy_not_contains",
-                "mostHatedBy_not_contains_nocase",
-                "mostHatedBy_",
-                "mostLovedBy",
-                "mostLovedBy_not",
-                "mostLovedBy_contains",
-                "mostLovedBy_contains_nocase",
-                "mostLovedBy_not_contains",
-                "mostLovedBy_not_contains_nocase",
-                "mostLovedBy_",
-                "_change_block",
-                "and",
-                "or"
-            ]
-            .iter()
-            .map(ToString::to_string)
-            .collect::<Vec<String>>()
-        );
-
-        let change_block_filter = user_filter_type
-            .fields
-            .iter()
-            .find(move |p| match p.name.as_str() {
-                "_change_block" => true,
-                _ => false,
-            })
-            .expect("_change_block field is missing in User_filter");
-
-        match &change_block_filter.value_type {
-            Type::NamedType(name) => assert_eq!(name.as_str(), "BlockChangedFilter"),
-            _ => panic!("_change_block field is not a named type"),
-        }
-
-        schema
-            .get_named_type("BlockChangedFilter")
-            .expect("BlockChangedFilter type is missing in derived API schema");
-    }
-
-    #[test]
-    fn api_schema_contains_object_type_with_field_interface() {
-        let input_schema = parse_schema(
-            r#"
-              interface Pet {
-                  id: ID!
-                  name: String!
-              }
-
-              type Dog implements Pet {
-                id: ID!
-                name: String!
-              }
-
-              type Cat implements Pet {
-                id: ID!
-                name: String!
-                owner: User!
-              }
-
-              type User {
-                  id: ID!
-                  name: String!
-                  pets: [Pet!]! @derivedFrom(field: "owner")
-                  favoritePet: Pet!
-              }
-            "#,
-        )
-        .expect("Failed to parse input schema");
-        let schema = api_schema(&input_schema).expect("Failed to derived API schema");
-
-        let user_filter = schema
-            .get_named_type("User_filter")
-            .expect("User_filter type is missing in derived API schema");
-
-        let user_filter_type = match user_filter {
-            TypeDefinition::InputObject(t) => Some(t),
-            _ => None,
-        }
-        .expect("User_filter type is not an input object");
-
-        assert_eq!(
-            user_filter_type
-                .fields
-                .iter()
-                .map(|field| field.name.clone())
-                .collect::<Vec<String>>(),
-            [
-                "id",
-                "id_not",
-                "id_gt",
-                "id_lt",
-                "id_gte",
-                "id_lte",
-                "id_in",
-                "id_not_in",
-                "name",
-                "name_not",
-                "name_gt",
-                "name_lt",
-                "name_gte",
-                "name_lte",
-                "name_in",
-                "name_not_in",
-                "name_contains",
-                "name_contains_nocase",
-                "name_not_contains",
-                "name_not_contains_nocase",
-                "name_starts_with",
-                "name_starts_with_nocase",
-                "name_not_starts_with",
-                "name_not_starts_with_nocase",
-                "name_ends_with",
-                "name_ends_with_nocase",
-                "name_not_ends_with",
-                "name_not_ends_with_nocase",
-                "pets_",
-                "favoritePet",
-                "favoritePet_not",
-                "favoritePet_gt",
-                "favoritePet_lt",
-                "favoritePet_gte",
-                "favoritePet_lte",
-                "favoritePet_in",
-                "favoritePet_not_in",
-                "favoritePet_contains",
-                "favoritePet_contains_nocase",
-                "favoritePet_not_contains",
-                "favoritePet_not_contains_nocase",
-                "favoritePet_starts_with",
-                "favoritePet_starts_with_nocase",
-                "favoritePet_not_starts_with",
-                "favoritePet_not_starts_with_nocase",
-                "favoritePet_ends_with",
-                "favoritePet_ends_with_nocase",
-                "favoritePet_not_ends_with",
-                "favoritePet_not_ends_with_nocase",
-                "favoritePet_",
-                "_change_block",
-                "and",
-                "or"
-            ]
-            .iter()
-            .map(ToString::to_string)
-            .collect::<Vec<String>>()
-        );
-
-        let change_block_filter = user_filter_type
-            .fields
-            .iter()
-            .find(move |p| match p.name.as_str() {
-                "_change_block" => true,
-                _ => false,
-            })
-            .expect("_change_block field is missing in User_filter");
-
-        match &change_block_filter.value_type {
-            Type::NamedType(name) => assert_eq!(name.as_str(), "BlockChangedFilter"),
-            _ => panic!("_change_block field is not a named type"),
-        }
-
-        schema
-            .get_named_type("BlockChangedFilter")
-            .expect("BlockChangedFilter type is missing in derived API schema");
-    }
-
-    #[test]
-    fn api_schema_contains_object_fields_on_query_type() {
-        let input_schema = parse_schema(
-            "type User { id: ID!, name: String! } type UserProfile { id: ID!, title: String! }",
-        )
-        .expect("Failed to parse input schema");
-        let schema = api_schema(&input_schema).expect("Failed to derive API schema");
-
-        let query_type = schema
-            .get_named_type("Query")
-            .expect("Query type is missing in derived API schema");
-
-        let user_singular_field = match query_type {
-            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())
-        );
-
-        assert_eq!(
-            user_singular_field
-                .arguments
-                .iter()
-                .map(|input_value| input_value.name.clone())
-                .collect::<Vec<String>>(),
-            vec![
-                "id".to_string(),
-                "block".to_string(),
-                "subgraphError".to_string()
-            ],
-        );
-
-        let user_plural_field = match query_type {
-            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()))
-            )))))
-        );
-
-        assert_eq!(
-            user_plural_field
-                .arguments
-                .iter()
-                .map(|input_value| input_value.name.clone())
-                .collect::<Vec<String>>(),
-            [
-                "skip",
-                "first",
-                "orderBy",
-                "orderDirection",
-                "where",
-                "block",
-                "subgraphError",
-            ]
-            .iter()
-            .map(ToString::to_string)
-            .collect::<Vec<String>>()
-        );
-
-        let user_profile_singular_field = match query_type {
-            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())
-        );
-
-        let user_profile_plural_field = match query_type {
-            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()))
-            )))))
-        );
-    }
-
-    #[test]
-    fn api_schema_contains_interface_fields_on_query_type() {
-        let input_schema = parse_schema(
-            "
-            interface Node { id: ID!, name: String! }
-            type User implements Node { id: ID!, name: String!, email: String }
-            ",
-        )
-        .expect("Failed to parse input schema");
-        let schema = api_schema(&input_schema).expect("Failed to derived API schema");
-
-        let query_type = schema
-            .get_named_type("Query")
-            .expect("Query type is missing in derived API schema");
-
-        let singular_field = match query_type {
-            TypeDefinition::Object(ref 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())
-        );
-
-        assert_eq!(
-            singular_field
-                .arguments
-                .iter()
-                .map(|input_value| input_value.name.clone())
-                .collect::<Vec<String>>(),
-            vec![
-                "id".to_string(),
-                "block".to_string(),
-                "subgraphError".to_string()
-            ],
-        );
-
-        let plural_field = match query_type {
-            TypeDefinition::Object(ref 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()))
-            )))))
-        );
-
-        assert_eq!(
-            plural_field
-                .arguments
-                .iter()
-                .map(|input_value| input_value.name.clone())
-                .collect::<Vec<String>>(),
-            [
-                "skip",
-                "first",
-                "orderBy",
-                "orderDirection",
-                "where",
-                "block",
-                "subgraphError"
-            ]
-            .iter()
-            .map(ToString::to_string)
-            .collect::<Vec<String>>()
-        );
-    }
-
-    #[test]
-    fn api_schema_contains_fulltext_query_field_on_query_type() {
-        const SCHEMA: &str = r#"
-type _Schema_ @fulltext(
-  name: "metadata"
-  language: en
-  algorithm: rank
-  include: [
-    {
-      entity: "Gravatar",
-      fields: [
-        { name: "displayName"},
-        { name: "imageUrl"},
-      ]
-    }
-  ]
-)
-type Gravatar @entity {
-  id: ID!
-  owner: Bytes!
-  displayName: String!
-  imageUrl: String!
-}
-"#;
-        let input_schema = parse_schema(SCHEMA).expect("Failed to parse input schema");
-        let schema = api_schema(&input_schema).expect("Failed to derive API schema");
-
-        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")),
-            _ => None,
-        }
-        .expect("\"metadata\" field is missing on Query type");
-    }
-}
diff --git a/graphql/src/schema/mod.rs b/graphql/src/schema/mod.rs
deleted file mode 100644
index 6df51907471..00000000000
--- a/graphql/src/schema/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-/// Generate full-fledged API schemas from existing GraphQL schemas.
-pub mod api;
-
-/// Utilities for working with GraphQL schema ASTs.
-pub mod ast;
-
-pub use self::api::{api_schema, APISchemaError};
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 923c12ffb09..e9a04c8c97b 100644
--- a/graphql/src/store/prefetch.rs
+++ b/graphql/src/store/prefetch.rs
@@ -1,39 +1,41 @@
 //! Run a GraphQL query and fetch all the entitied needed to build the
 //! final result
 
-use anyhow::{anyhow, Error};
-use graph::constraint_violation;
+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 lazy_static::lazy_static;
-use std::collections::BTreeMap;
-use std::rc::Rc;
+use std::collections::{BTreeMap, HashMap};
+use std::sync::Arc;
 use std::time::Instant;
 
-use graph::{components::store::EntityType, data::graphql::*};
-use graph::{
-    data::graphql::ext::DirectiveFinder,
-    prelude::{
-        s, ApiSchema, AttributeNames, ChildMultiplicity, EntityCollection, EntityFilter,
-        EntityLink, EntityOrder, EntityWindow, ParentLink, QueryExecutionError, StoreError,
-        Value as StoreValue, WindowAttribute, ENV_VARS,
-    },
+use graph::data::graphql::TypeExt;
+use graph::prelude::{
+    AttributeNames, ChildMultiplicity, ENV_VARS, EntityCollection, EntityFilter, EntityLink,
+    EntityOrder, EntityWindow, ParentLink, QueryExecutionError, Value as StoreValue,
+    WindowAttribute,
 };
+use graph::schema::{EntityType, InputSchema, ObjectOrInterface};
 
-use crate::execution::{ast as a, ExecutionContext, Resolver};
+use crate::execution::ast as a;
 use crate::metrics::GraphQLMetrics;
-use crate::schema::ast as sast;
-use crate::store::query::build_query;
 use crate::store::StoreResolver;
+use crate::store::query::build_query;
 
-lazy_static! {
-    static ref ARG_FIRST: String = String::from("first");
-    static ref ARG_SKIP: String = String::from("skip");
-    static ref ARG_ID: String = String::from("id");
-}
+pub const ARG_ID: &str = "id";
+
+// Everything in this file only makes sense for an
+// `ExecutionContext<StoreResolver>`
+type ExecutionContext = crate::execution::ExecutionContext<StoreResolver>;
 
 /// Intermediate data structure to hold the results of prefetching entities
 /// and their nested associations. For each association of `entity`, `children`
@@ -45,7 +47,9 @@ struct Node {
     /// the keys and values of the `children` map, but not of the map itself
     children_weight: usize,
 
-    entity: BTreeMap<Word, r::Value>,
+    parent: Option<Id>,
+
+    entity: Object,
     /// We are using an `Rc` here for two reasons: it allows us to defer
     /// copying objects until the end, when converting to `q::Value` forces
     /// us to copy any child that is referenced by multiple parents. It also
@@ -86,14 +90,15 @@ 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<BTreeMap<Word, r::Value>> for Node {
-    fn from(entity: BTreeMap<Word, r::Value>) -> Self {
+impl From<QueryObject> for Node {
+    fn from(object: QueryObject) -> Self {
         Node {
-            children_weight: entity.weight(),
-            entity,
+            children_weight: object.weight(),
+            parent: object.parent,
+            entity: object.entity,
             children: BTreeMap::default(),
         }
     }
@@ -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(),
     )
@@ -135,9 +140,10 @@ fn is_root_node<'a>(mut nodes: impl Iterator<Item = &'a Node>) -> bool {
 }
 
 fn make_root_node() -> Vec<Node> {
-    let entity = BTreeMap::new();
+    let entity = Object::empty();
     vec![Node {
         children_weight: entity.weight(),
+        parent: None,
         entity,
         children: BTreeMap::default(),
     }]
@@ -150,18 +156,20 @@ fn make_root_node() -> Vec<Node> {
 impl From<Node> for r::Value {
     fn from(node: Node) -> Self {
         let mut map = node.entity;
-        for (key, nodes) in node.children.into_iter() {
-            map.insert(
+        let entries = node.children.into_iter().map(|(key, nodes)| {
+            (
                 format!("prefetch:{}", key).into(),
                 node_list_as_value(nodes),
-            );
-        }
-        r::Value::object(map)
+            )
+        });
+        map.extend(entries);
+        r::Value::Object(map)
     }
 }
 
 trait ValueExt {
     fn as_str(&self) -> Option<&str>;
+    fn as_id(&self, id_type: IdType) -> Option<Id>;
 }
 
 impl ValueExt for r::Value {
@@ -171,19 +179,30 @@ impl ValueExt for r::Value {
             _ => None,
         }
     }
+
+    fn as_id(&self, id_type: IdType) -> Option<Id> {
+        match self {
+            r::Value::String(s) => id_type.parse(Word::from(s.as_str())).ok(),
+            _ => None,
+        }
+    }
 }
 
 impl Node {
-    fn id(&self) -> Result<String, Error> {
+    fn id(&self, schema: &InputSchema) -> Result<Id, QueryExecutionError> {
+        let entity_type = schema.entity_type(self.typename())?;
         match self.get("id") {
-            None => Err(anyhow!("Entity is missing an `id` attribute")),
-            Some(r::Value::String(s)) => Ok(s.clone()),
-            _ => Err(anyhow!("Entity has non-string `id` attribute")),
+            None => Err(QueryExecutionError::IdMissing),
+            Some(r::Value::String(s)) => {
+                let id = entity_type.parse_id(s.as_str())?;
+                Ok(id)
+            }
+            _ => Err(QueryExecutionError::IdNotString),
         }
     }
 
     fn get(&self, key: &str) -> Option<&r::Value> {
-        self.entity.get(&key.into())
+        self.entity.get(key)
     }
 
     fn typename(&self) -> &str {
@@ -193,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
         }
@@ -214,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)
@@ -238,80 +257,87 @@ 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(
-        parent_type: &'a s::ObjectType,
-        child_type: &'a s::ObjectType,
-        field_name: &str,
+        schema: &InputSchema,
+        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: parent_type.into(),
-            child_type: child_type.into(),
+            parent_type,
+            child_type,
             relation,
         }
     }
 
     fn entity_link(
         &self,
-        parents_by_id: Vec<(String, &Node)>,
+        parents_by_id: Vec<(Id, &Node)>,
         multiplicity: ChildMultiplicity,
-    ) -> (Vec<String>, EntityLink) {
+    ) -> Result<(IdList, EntityLink), QueryExecutionError> {
         match &self.relation {
             JoinRelation::Direct(field) => {
                 // we only need the parent ids
-                let ids = parents_by_id.into_iter().map(|(id, _)| id).collect();
-                (
+                let ids = IdList::try_from_iter(
+                    self.parent_type.id_type()?,
+                    parents_by_id.into_iter().map(|(id, _)| id),
+                )?;
+                Ok((
                     ids,
                     EntityLink::Direct(field.window_attribute(), multiplicity),
-                )
+                ))
             }
             JoinRelation::Derived(field) => {
                 let (ids, parent_link) = match field {
                     JoinField::Scalar(child_field) => {
                         // child_field contains a String id of the child; extract
                         // those and the parent ids
+                        let id_type = self.child_type.id_type().unwrap();
                         let (ids, child_ids): (Vec<_>, Vec<_>) = parents_by_id
                             .into_iter()
                             .filter_map(|(id, node)| {
                                 node.get(child_field)
-                                    .and_then(|value| value.as_str())
+                                    .and_then(|value| value.as_id(id_type))
                                     .map(|child_id| (id, child_id.to_owned()))
                             })
                             .unzip();
-
+                        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) => {
                         // child_field stores a list of child ids; extract them,
                         // turn them into a list of strings and combine with the
                         // parent ids
+                        let id_type = self.child_type.id_type().unwrap();
                         let (ids, child_ids): (Vec<_>, Vec<_>) = parents_by_id
                             .into_iter()
                             .filter_map(|(id, node)| {
@@ -320,9 +346,7 @@ impl<'a> JoinCond<'a> {
                                         r::Value::List(values) => {
                                             let values: Vec<_> = values
                                                 .iter()
-                                                .filter_map(|value| {
-                                                    value.as_str().map(|value| value.to_owned())
-                                                })
+                                                .filter_map(|value| value.as_id(id_type))
                                                 .collect();
                                             if values.is_empty() {
                                                 None
@@ -335,13 +359,21 @@ impl<'a> JoinCond<'a> {
                                     .map(|child_ids| (id, child_ids))
                             })
                             .unzip();
+                        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.id_type()?, ids.into_iter())
+                            })
+                            .collect::<Result<Vec<_>, _>>()?;
                         (ids, ParentLink::List(child_ids))
                     }
                 };
-                (
+                Ok((
                     ids,
                     EntityLink::Parent(self.parent_type.clone(), parent_link),
-                )
+                ))
             }
         }
     }
@@ -353,95 +385,48 @@ 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 ApiSchema,
-        parent_type: &'a s::ObjectType,
+        schema: &'a InputSchema,
+        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(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 }
     }
 
-    /// Perform the join. The child nodes are distributed into the parent nodes
-    /// according to the `parent_id` returned by the database in each child as
-    /// attribute `g$parent_id`, and are stored in the `response_key` entry
-    /// in each parent's `children` map.
-    ///
-    /// The `children` must contain the nodes in the correct order for each
-    /// parent; we simply pick out matching children for each parent but
-    /// otherwise maintain the order in `children`
-    fn perform(parents: &mut [&mut Node], children: Vec<Node>, response_key: &str) {
-        let children: Vec<_> = children.into_iter().map(Rc::new).collect();
-
-        if parents.len() == 1 {
-            let parent = parents.first_mut().expect("we just checked");
-            parent.set_children(response_key.to_owned(), children);
-            return;
-        }
-
-        // Build a map parent_id -> Vec<child> that we will use to add
-        // 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: BTreeMap<&str, Vec<Rc<Node>>> = BTreeMap::default();
-        for child in children.iter() {
-            match child
-                .get("g$parent_id")
-                .expect("the query that produces 'child' ensures there is always a g$parent_id")
-            {
-                r::Value::String(key) => grouped.entry(key).or_default().push(child.clone()),
-                _ => unreachable!("the parent_id returned by the query is always a string"),
-            }
-        }
-
-        // Add appropriate children using grouped map
-        for parent in parents {
-            // Set the `response_key` field in `parent`. Make sure that even if `parent` has no
-            // matching `children`, the field gets set (to an empty `Vec`).
-            //
-            // This `insert` will overwrite in the case where the response key occurs both at the
-            // interface level and in nested object type conditions. The values for the interface
-            // query are always joined first, and may then be overwritten by the merged selection
-            // set under the object type condition. See also: e0d6da3e-60cf-41a5-b83c-b60a7a766d4a
-            let values = parent.id().ok().and_then(|id| grouped.get(&*id).cloned());
-            parent.set_children(response_key.to_owned(), values.unwrap_or_default());
-        }
-    }
-
     fn windows(
         &self,
+        schema: &InputSchema,
         parents: &[&mut Node],
         multiplicity: ChildMultiplicity,
         previous_collection: &EntityCollection,
-    ) -> Vec<EntityWindow> {
+    ) -> Result<Vec<EntityWindow>, QueryExecutionError> {
         let mut windows = vec![];
         let column_names_map = previous_collection.entity_types_and_column_names();
         for cond in &self.conds {
             let mut parents_by_id = parents
                 .iter()
-                .filter(|parent| parent.typename() == cond.parent_type.as_str())
-                .filter_map(|parent| parent.id().ok().map(|id| (id, &**parent)))
+                .filter(|parent| parent.typename() == cond.parent_type.typename())
+                .filter_map(|parent| parent.id(schema).ok().map(|id| (id, &**parent)))
                 .collect::<Vec<_>>();
 
             if !parents_by_id.is_empty() {
                 parents_by_id.sort_unstable_by(|(id1, _), (id2, _)| id1.cmp(id2));
                 parents_by_id.dedup_by(|(id1, _), (id2, _)| id1 == id2);
 
-                let (ids, link) = cond.entity_link(parents_by_id, multiplicity);
+                let (ids, link) = cond.entity_link(parents_by_id, multiplicity)?;
                 let child_type: EntityType = cond.child_type.clone();
                 let column_names = match column_names_map.get(&child_type) {
                     Some(column_names) => column_names.clone(),
@@ -455,8 +440,94 @@ impl<'a> Join<'a> {
                 });
             }
         }
-        windows
+        Ok(windows)
+    }
+}
+
+/// Distinguish between a root GraphQL query and nested queries. For root
+/// queries, there is no parent type, and it doesn't really make sense to
+/// worry about join conditions since there is only one parent (the root).
+/// In particular, the parent type for root queries is `Query` which is not
+/// an entity type, and we would create a `Join` with a fake entity type for
+/// the parent type
+enum MaybeJoin<'a> {
+    Root { child_type: ObjectOrInterface<'a> },
+    Nested(Join<'a>),
+}
+
+impl<'a> MaybeJoin<'a> {
+    fn child_type(&self) -> &ObjectOrInterface<'_> {
+        match self {
+            MaybeJoin::Root { child_type } => child_type,
+            MaybeJoin::Nested(Join {
+                child_type,
+                conds: _,
+            }) => child_type,
+        }
+    }
+}
+
+/// Link children to their parents. The child nodes are distributed into the
+/// parent nodes according to the `parent_id` returned by the database in
+/// each child as attribute `g$parent_id`, and are stored in the
+/// `response_key` entry in each parent's `children` map.
+///
+/// The `children` must contain the nodes in the correct order for each
+/// parent; we simply pick out matching children for each parent but
+/// otherwise maintain the order in `children`
+///
+/// If `parents` only has one entry, add all children to that one parent. In
+/// particular, this is what happens for toplevel queries.
+fn add_children(
+    schema: &InputSchema,
+    parents: &mut [&mut Node],
+    children: Vec<Node>,
+    response_key: &str,
+) -> Result<(), QueryExecutionError> {
+    let children: Vec<_> = children.into_iter().map(Arc::new).collect();
+
+    if parents.len() == 1 {
+        let parent = parents.first_mut().expect("we just checked");
+        parent.set_children(response_key.to_owned(), children);
+        return Ok(());
+    }
+
+    // Build a map parent_id -> Vec<child> that we will use to add
+    // 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<Arc<Node>>> = HashMap::default();
+    for child in children.iter() {
+        let parent = child.parent.as_ref().ok_or_else(|| {
+            QueryExecutionError::Panic(format!(
+                "child {}[{}] is missing a parent id",
+                child.typename(),
+                child
+                    .id(schema)
+                    .map(|id| id.to_string())
+                    .unwrap_or_else(|_| "<no id>".to_owned())
+            ))
+        })?;
+        grouped.entry(parent).or_default().push(child.clone());
+    }
+
+    // Add appropriate children using grouped map
+    for parent in parents {
+        // Set the `response_key` field in `parent`. Make sure that even if `parent` has no
+        // matching `children`, the field gets set (to an empty `Vec`).
+        //
+        // This `insert` will overwrite in the case where the response key occurs both at the
+        // interface level and in nested object type conditions. The values for the interface
+        // query are always joined first, and may then be overwritten by the merged selection
+        // set under the object type condition. See also: e0d6da3e-60cf-41a5-b83c-b60a7a766d4a
+        let values = parent
+            .id(schema)
+            .ok()
+            .and_then(|id| grouped.get(&id).cloned());
+        parent.set_children(response_key.to_owned(), values.unwrap_or_default());
     }
+
+    Ok(())
 }
 
 /// Run the query in `ctx` in such a manner that we only perform one query
@@ -476,294 +547,226 @@ impl<'a> Join<'a> {
 /// 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<impl Resolver>,
+    ctx: &ExecutionContext,
     selection_set: &a::SelectionSet,
     graphql_metrics: &GraphQLMetrics,
 ) -> Result<(r::Value, Trace), Vec<QueryExecutionError>> {
-    execute_root_selection_set(resolver, ctx, selection_set).map(|(nodes, trace)| {
-        graphql_metrics.observe_query_result_size(nodes.weight());
-        let obj = Object::from_iter(nodes.into_iter().flat_map(|node| {
-            node.children
-                .into_iter()
-                .map(|(key, nodes)| (format!("prefetch:{}", key), node_list_as_value(nodes)))
-        }));
-        (r::Value::Object(obj), trace)
-    })
+    let loader = Loader::new(resolver, ctx);
+
+    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, None)
+        .await?;
+
+    graphql_metrics.observe_query_result_size(nodes.weight());
+    let obj = Object::from_iter(nodes.into_iter().flat_map(|node| {
+        node.children.into_iter().map(|(key, nodes)| {
+            (
+                Word::from(format!("prefetch:{}", key)),
+                node_list_as_value(nodes),
+            )
+        })
+    }));
+
+    Ok((r::Value::Object(obj), trace))
 }
 
-/// Executes the root selection set of a query.
-fn execute_root_selection_set(
-    resolver: &StoreResolver,
-    ctx: &ExecutionContext<impl Resolver>,
-    selection_set: &a::SelectionSet,
-) -> Result<(Vec<Node>, Trace), Vec<QueryExecutionError>> {
-    let trace = Trace::root(
-        &ctx.query.query_text,
-        &ctx.query.variables_text,
-        &ctx.query.query_id,
-        resolver.block_number(),
-        ctx.trace,
-    );
-    // Execute the root selection set against the root query type
-    execute_selection_set(resolver, ctx, make_root_node(), trace, selection_set)
+struct Loader<'a> {
+    resolver: &'a StoreResolver,
+    ctx: &'a ExecutionContext,
 }
 
-fn check_result_size<'a>(
-    ctx: &'a ExecutionContext<impl Resolver>,
-    size: usize,
-) -> Result<(), QueryExecutionError> {
-    if size > ENV_VARS.graphql.warn_result_size {
-        warn!(ctx.logger, "Large query result"; "size" => size, "query_id" => &ctx.query.query_id);
-    }
-    if size > ENV_VARS.graphql.error_result_size {
-        return Err(QueryExecutionError::ResultTooBig(
-            size,
-            ENV_VARS.graphql.error_result_size,
-        ));
+impl<'a> Loader<'a> {
+    fn new(resolver: &'a StoreResolver, ctx: &'a ExecutionContext) -> Self {
+        Loader { resolver, ctx }
     }
-    Ok(())
-}
 
-fn execute_selection_set<'a>(
-    resolver: &StoreResolver,
-    ctx: &'a ExecutionContext<impl Resolver>,
-    mut parents: Vec<Node>,
-    mut parent_trace: Trace,
-    selection_set: &a::SelectionSet,
-) -> Result<(Vec<Node>, Trace), Vec<QueryExecutionError>> {
-    let schema = &ctx.query.schema;
-    let mut errors: Vec<QueryExecutionError> = Vec::new();
-
-    // Process all field groups in order
-    for (object_type, fields) in selection_set.interior_fields() {
-        if let Some(deadline) = ctx.deadline {
-            if deadline < Instant::now() {
+    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 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
+                && deadline < Instant::now()
+            {
                 errors.push(QueryExecutionError::Timeout);
                 break;
             }
-        }
-
-        // Filter out parents that do not match the type condition.
-        let mut parents: Vec<&mut Node> = if is_root_node(parents.iter()) {
-            parents.iter_mut().collect()
-        } else {
-            parents
-                .iter_mut()
-                .filter(|p| object_type.name == p.typename())
-                .collect()
-        };
-
-        if parents.is_empty() {
-            continue;
-        }
-
-        for field in fields {
-            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())
-                .expect("we only collect fields that are objects or interfaces");
-
-            let join = Join::new(
-                ctx.query.schema.as_ref(),
-                object_type,
-                child_type,
-                &field.name,
-            );
 
-            // "Select by Specific Attribute Names" is an experimental feature and can be disabled completely.
-            // If this environment variable is set, the program will use an empty collection that,
-            // effectively, causes the `AttributeNames::All` variant to be used as a fallback value for all
-            // queries.
-            let collected_columns = if !ENV_VARS.enable_select_by_specific_attributes {
-                SelectedAttributes(BTreeMap::new())
+            // Filter out parents that do not match the type condition.
+            let mut parents: Vec<&mut Node> = if at_root {
+                parents.iter_mut().collect()
             } else {
-                SelectedAttributes::for_field(field)?
+                parents
+                    .iter_mut()
+                    .filter(|p| object_type.name == p.typename())
+                    .collect()
             };
 
-            match execute_field(
-                resolver,
-                ctx,
-                &parents,
-                &join,
-                field,
-                field_type,
-                collected_columns,
-            ) {
-                Ok((children, trace)) => {
-                    match execute_selection_set(
-                        resolver,
-                        ctx,
-                        children,
-                        trace,
-                        &field.selection_set,
-                    ) {
-                        Ok((children, trace)) => {
-                            Join::perform(&mut parents, children, field.response_key());
-                            let weight =
-                                parents.iter().map(|parent| parent.weight()).sum::<usize>();
-                            check_result_size(ctx, weight)?;
-                            parent_trace.push(field.response_key(), trace);
+            if parents.is_empty() {
+                continue;
+            }
+
+            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 = 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.cheap_clone(),
+                        child_type,
+                        field_type,
+                    ))
+                };
+
+                match self
+                    .fetch(&parents, &join, field, aggregation_current)
+                    .await
+                {
+                    Ok((children, trace)) => {
+                        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,
+                                    &mut parents,
+                                    children,
+                                    field.response_key(),
+                                )?;
+                                self.check_result_size(&parents)?;
+                                parent_trace.push(field.response_key(), trace);
+                            }
+                            Err(mut e) => errors.append(&mut e),
                         }
-                        Err(mut e) => errors.append(&mut e),
                     }
-                }
-                Err(mut e) => {
-                    errors.append(&mut e);
-                }
-            };
+                    Err(e) => {
+                        errors.push(e);
+                    }
+                };
+            }
         }
-    }
 
-    if errors.is_empty() {
-        Ok((parents, parent_trace))
-    } else {
-        Err(errors)
-    }
-}
-
-/// Executes a field.
-fn execute_field(
-    resolver: &StoreResolver,
-    ctx: &ExecutionContext<impl Resolver>,
-    parents: &[&mut Node],
-    join: &Join<'_>,
-    field: &a::Field,
-    field_definition: &s::Field,
-    selected_attrs: SelectedAttributes,
-) -> Result<(Vec<Node>, Trace), Vec<QueryExecutionError>> {
-    let multiplicity = if sast::is_list_or_non_null_list_field(field_definition) {
-        ChildMultiplicity::Many
-    } else {
-        ChildMultiplicity::Single
-    };
-
-    fetch(
-        resolver,
-        ctx,
-        parents,
-        join,
-        field,
-        multiplicity,
-        selected_attrs,
-    )
-    .map_err(|e| vec![e])
-}
-
-/// 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(
-    resolver: &StoreResolver,
-    ctx: &ExecutionContext<impl Resolver>,
-    parents: &[&mut Node],
-    join: &Join<'_>,
-    field: &a::Field,
-    multiplicity: ChildMultiplicity,
-    selected_attrs: SelectedAttributes,
-) -> Result<(Vec<Node>, Trace), QueryExecutionError> {
-    let mut query = build_query(
-        join.child_type,
-        resolver.block_number(),
-        field,
-        ctx.query.schema.types_for_interface(),
-        ctx.max_first,
-        ctx.max_skip,
-        selected_attrs,
-        &ctx.query.schema,
-    )?;
-    query.trace = ctx.trace;
-    query.query_id = Some(ctx.query.query_id.clone());
-
-    if multiplicity == ChildMultiplicity::Single {
-        // Suppress 'order by' in lookups of scalar values since
-        // that causes unnecessary work in the database
-        query.order = EntityOrder::Unordered;
-    }
-
-    query.logger = Some(ctx.logger.cheap_clone());
-    if let Some(r::Value::String(id)) = field.argument_value(ARG_ID.as_str()) {
-        query.filter = Some(
-            EntityFilter::Equal(ARG_ID.to_owned(), StoreValue::from(id.clone()))
-                .and_maybe(query.filter),
-        );
-    }
-
-    if !is_root_node(parents.iter().map(|p| &**p)) {
-        // For anything but the root node, restrict the children we select
-        // by the parent list
-        let windows = join.windows(parents, multiplicity, &query.collection);
-        if windows.is_empty() {
-            return Ok((vec![], Trace::None));
+        if errors.is_empty() {
+            Ok((parents, parent_trace))
+        } else {
+            Err(errors)
         }
-        query.collection = EntityCollection::Window(windows);
     }
-    resolver
-        .store
-        .find_query_values(query)
-        .map(|(values, trace)| {
-            (
-                values.into_iter().map(|entity| entity.into()).collect(),
-                trace,
-            )
-        })
-}
 
-#[derive(Debug, Default, Clone)]
-pub(crate) struct SelectedAttributes(BTreeMap<String, AttributeNames>);
-
-impl SelectedAttributes {
-    /// Extract the attributes we should select from `selection_set`. In
-    /// particular, disregard derived fields since they are not stored
-    fn for_field(field: &a::Field) -> Result<SelectedAttributes, Vec<QueryExecutionError>> {
-        let mut map = BTreeMap::new();
-        for (object_type, fields) in field.selection_set.fields() {
-            let column_names = fields
-                .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)
-                })
-                .filter_map(|field| {
-                    if field.name.starts_with("__") {
-                        None
-                    } else {
-                        Some(field.name.clone())
-                    }
-                })
-                .collect();
-            map.insert(
-                object_type.name().to_string(),
-                AttributeNames::Select(column_names),
+    /// 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.
+    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().await?;
+        let child_type = join.child_type();
+        let mut query = build_query(
+            child_type,
+            self.resolver.block_number(),
+            field,
+            self.ctx.max_first,
+            self.ctx.max_skip,
+            &input_schema,
+        )?;
+        query.trace = self.ctx.trace;
+        query.query_id = Some(self.ctx.query.query_id.clone());
+
+        if field.multiplicity == ChildMultiplicity::Single {
+            // Suppress 'order by' in lookups of scalar values since
+            // 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(
+                EntityFilter::Equal(ARG_ID.to_owned(), StoreValue::from(id.clone()))
+                    .and_maybe(query.filter),
             );
         }
-        // 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 field.argument_value("orderBy") {
-            None => { /* nothing to do */ }
-            Some(r::Value::Enum(e)) => {
-                for columns in map.values_mut() {
-                    columns.add_str(e);
-                }
-            }
-            Some(v) => {
-                return Err(vec![constraint_violation!(
-                    "'orderBy' attribute must be an enum but is {:?}",
-                    v
-                )
-                .into()]);
+
+        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
+            let windows = join.windows(
+                &input_schema,
+                parents,
+                field.multiplicity,
+                &query.collection,
+            )?;
+            if windows.is_empty() {
+                return Ok((vec![], Trace::None));
             }
+            query.collection = EntityCollection::Window(windows);
         }
-        Ok(SelectedAttributes(map))
+        self.resolver
+            .store
+            .find_query_values(query)
+            .await
+            .map(|(values, trace)| (values.into_iter().map(Node::from).collect(), trace))
     }
 
-    pub fn get(&mut self, obj_type: &s::ObjectType) -> AttributeNames {
-        self.0.remove(&obj_type.name).unwrap_or(AttributeNames::All)
+    fn check_result_size(&self, parents: &[&mut Node]) -> Result<(), QueryExecutionError> {
+        let size = parents.iter().map(|parent| parent.weight()).sum::<usize>();
+
+        if size > ENV_VARS.graphql.warn_result_size {
+            warn!(self.ctx.logger, "Large query result"; "size" => size, "query_id" => &self.ctx.query.query_id);
+        }
+        if size > ENV_VARS.graphql.error_result_size {
+            return Err(QueryExecutionError::ResultTooBig(
+                size,
+                ENV_VARS.graphql.error_result_size,
+            ));
+        }
+        Ok(())
     }
 }
diff --git a/graphql/src/store/query.rs b/graphql/src/store/query.rs
index 578b971d76a..f893663b258 100644
--- a/graphql/src/store/query.rs
+++ b/graphql/src/store/query.rs
@@ -1,17 +1,21 @@
-use std::collections::{BTreeMap, BTreeSet, HashSet, VecDeque};
 use std::mem::discriminant;
 
-use graph::data::graphql::ext::DirectiveFinder;
+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::{components::store::EntityType, data::graphql::ObjectOrInterface};
+use graph::prelude::{ENV_VARS, TryFromValue, r};
+use graph::schema::ast::{self as sast, FilterOp};
+use graph::schema::kw;
+use graph::schema::{EntityType, InputSchema, ObjectOrInterface};
 
 use crate::execution::ast as a;
-use crate::schema::ast::{self as sast, FilterOp};
-
-use super::prefetch::SelectedAttributes;
 
 #[derive(Debug)]
 enum OrderDirection {
@@ -23,105 +27,28 @@ enum OrderDirection {
 ///
 /// 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<EntityType, Vec<s::ObjectType>>,
     max_first: u32,
     max_skip: u32,
-    mut column_names: SelectedAttributes,
-    schema: &ApiSchema,
+    schema: &InputSchema,
 ) -> Result<EntityQuery, QueryExecutionError> {
-    let entity = entity.into();
-    let entity_types = EntityCollection::All(match &entity {
-        ObjectOrInterface::Object(object) => {
-            let selected_columns = column_names.get(object);
-            vec![((*object).into(), selected_columns)]
-        }
-        ObjectOrInterface::Interface(interface) => types_for_interface
-            [&EntityType::from(*interface)]
-            .iter()
-            .map(|o| {
-                let selected_columns = column_names.get(o);
-                (o.into(), selected_columns)
-            })
-            .collect(),
-    });
-    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)
 }
@@ -170,22 +97,29 @@ fn build_range(
 
 /// Parses GraphQL arguments into an EntityFilter, if present.
 fn build_filter(
-    entity: ObjectOrInterface,
+    entity: &ObjectOrInterface,
     field: &a::Field,
-    schema: &ApiSchema,
+    schema: &InputSchema,
 ) -> Result<Option<EntityFilter>, QueryExecutionError> {
-    match field.argument_value("where") {
+    let where_filter = match field.argument_value("where") {
         Some(r::Value::Object(object)) => match build_filter_from_object(entity, object, schema) {
             Ok(filter) => Ok(Some(EntityFilter::And(filter))),
             Err(e) => Err(e),
         },
-        Some(r::Value::Null) => Ok(None),
-        None => match field.argument_value("text") {
-            Some(r::Value::Object(filter)) => build_fulltext_filter_from_object(filter),
-            None => Ok(None),
-            _ => Err(QueryExecutionError::InvalidFilterError),
-        },
+        Some(r::Value::Null) | None => Ok(None),
         _ => Err(QueryExecutionError::InvalidFilterError),
+    }?;
+
+    let text_filter = match field.argument_value("text") {
+        Some(r::Value::Object(filter)) => build_fulltext_filter_from_object(filter),
+        None => Ok(None),
+        _ => Err(QueryExecutionError::InvalidFilterError),
+    }?;
+
+    match (where_filter, text_filter) {
+        (None, None) => Ok(None),
+        (Some(f), None) | (None, Some(f)) => Ok(Some(f)),
+        (Some(w), Some(t)) => Ok(Some(EntityFilter::And(vec![t, w]))),
     }
 }
 
@@ -196,7 +130,7 @@ fn build_fulltext_filter_from_object(
         Err(QueryExecutionError::FulltextQueryRequiresFilter),
         |(key, value)| {
             if let r::Value::String(s) = value {
-                Ok(Some(EntityFilter::Equal(
+                Ok(Some(EntityFilter::Fulltext(
                     key.to_string(),
                     Value::String(s.clone()),
                 )))
@@ -260,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: &ApiSchema,
+    entity: &ObjectOrInterface,
+    schema: &InputSchema,
     value: &r::Value,
 ) -> Result<Vec<EntityFilter>, QueryExecutionError> {
     // We have object like this
@@ -287,9 +221,9 @@ fn build_list_filter_from_value(
 
 /// build a filter which has list of nested filters
 fn build_list_filter_from_object(
-    entity: ObjectOrInterface,
+    entity: &ObjectOrInterface,
     object: &Object,
-    schema: &ApiSchema,
+    schema: &InputSchema,
 ) -> Result<Vec<EntityFilter>, QueryExecutionError> {
     Ok(object
         .iter()
@@ -303,10 +237,36 @@ fn build_list_filter_from_object(
 
 /// Parses a GraphQL input object into an EntityFilter, if present.
 fn build_filter_from_object(
-    entity: ObjectOrInterface,
+    entity: &ObjectOrInterface,
     object: &Object,
-    schema: &ApiSchema,
+    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)| {
@@ -349,9 +309,9 @@ fn build_filter_from_object(
                         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(),
                             )
                         })?;
@@ -363,9 +323,9 @@ fn build_filter_from_object(
                     }
                 },
                 _ => {
-                    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(),
                         )
                     })?;
@@ -379,44 +339,38 @@ fn build_filter_from_object(
 }
 
 fn build_child_filter_from_object(
-    entity: ObjectOrInterface,
+    entity: &ObjectOrInterface,
     field_name: String,
     object: &Object,
-    schema: &ApiSchema,
+    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
-        .object_or_interface(type_name)
+        .object_or_interface(type_name, None)
         .ok_or(QueryExecutionError::InvalidFilterError)?;
     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.schema())
-                .ok_or(QueryExecutionError::AbstractTypeError(
-                    "Interface is not implemented by any types".to_string(),
-                ))?
-                .iter()
-                .map(|object_type| {
+                .object_types()
+                .into_iter()
+                .map(|entity_type| {
                     EntityFilter::Child(Child {
                         attr: attr.clone(),
-                        entity_type: EntityType::new(object_type.name.to_string()),
+                        entity_type,
                         filter: filter.clone(),
                         derived,
                     })
@@ -426,30 +380,22 @@ fn build_child_filter_from_object(
     } else if entity.is_interface() {
         Ok(EntityFilter::Or(
             entity
-                .object_types(schema.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: EntityType::new(child_entity.name().to_string()),
+                        entity_type: child_entity.entity_type(),
                         filter: filter.clone(),
                         derived,
                     }))
@@ -459,7 +405,7 @@ fn build_child_filter_from_object(
     } else {
         Ok(EntityFilter::Child(Child {
             attr,
-            entity_type: EntityType::new(type_name.to_string()),
+            entity_type: schema.entity_type(*type_name)?,
             filter,
             derived,
         }))
@@ -469,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(),
         )),
@@ -515,104 +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: &ApiSchema,
+    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) => {
-                if entity.is_interface() {
-                    return Err(QueryExecutionError::OrderByNotSupportedError(
-                        entity.name().to_owned(),
-                        parent_field_name,
-                    ));
-                }
-
-                let field =
-                    sast::get_field(entity, parent_field_name.as_str()).ok_or_else(|| {
+                // 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(
-                            entity.name().to_owned(),
+                            entity.typename().to_owned(),
                             parent_field_name.clone(),
                         )
                     })?;
-                let derived = field.is_derived();
+                let derived_from = field.derived_from(schema);
                 let base_type = field.field_type.get_base_type();
+
                 let child_entity = schema
-                    .object_or_interface(base_type)
+                    .object_or_interface(base_type, None)
                     .ok_or_else(|| QueryExecutionError::NamedTypeError(base_type.into()))?;
-                let child_field = sast::get_field(child_entity, child_field_name.as_str())
-                    .ok_or_else(|| {
-                        QueryExecutionError::EntityFieldError(
-                            child_entity.name().to_owned(),
-                            child_field_name.clone(),
-                        )
-                    })?;
-
-                let join_attribute = match derived {
-                    true => sast::get_derived_from_field(child_entity, field)
+                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: EntityType::new(base_type.into()),
+                    ObjectOrInterface::Object(_, _) => OrderByChild::Object(ObjectOrderDetails {
+                        entity_type: schema.entity_type(base_type)?,
                         join_attribute,
                         derived,
                     }),
-                    ObjectOrInterface::Interface(interface) => {
-                        let entity_types = schema
-                            .types_for_interface()
-                            .get(&EntityType::new(interface.name.to_string()))
-                            .map(|object_types| {
-                                object_types
-                                    .iter()
-                                    .map(|object_type| EntityType::new(object_type.name.clone()))
-                                    .collect::<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,
@@ -625,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(),
                         )
                     })
@@ -667,94 +683,79 @@ 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(
-    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))
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(entities
-        .into_iter()
-        .map(|(id, entity_type)| SubscriptionFilter::Entities(id, EntityType::new(entity_type)))
-        .collect())
-}
-
 #[cfg(test)]
 mod tests {
+    use graph::components::store::EntityQuery;
+    use graph::data::store::ID;
+    use graph::env::ENV_VARS;
     use graph::{
-        components::store::EntityType,
+        components::store::ChildMultiplicity,
         data::value::Object,
+        prelude::lazy_static,
         prelude::{
-            r, ApiSchema, AttributeNames, DeploymentHash, EntityCollection, EntityFilter,
-            EntityRange, Schema, 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::{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);
+        };
+
+        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 = (
             String::from("id"),
@@ -762,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()),
@@ -774,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()],
@@ -782,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],
@@ -793,7 +794,7 @@ mod tests {
         ObjectType {
             position: Default::default(),
             description: None,
-            name: String::new(),
+            name: DEFAULT_OBJECT.to_string(),
             implements_interfaces: vec![],
             directives: vec![subgraph_id_directive],
             fields: vec![name_field, email_field],
@@ -807,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,
@@ -831,198 +821,93 @@ mod tests {
             arguments,
             directives: vec![],
             selection_set: a::SelectionSet::new(vec![obj_type]),
+            multiplicity: ChildMultiplicity::Single,
         }
     }
 
-    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_schema(raw_schema: &str) -> ApiSchema {
-        let document = graphql_parser::parse_schema(raw_schema)
-            .expect("Failed to parse raw schema")
-            .into_static();
-
-        let schema = Schema::new(DeploymentHash::new("id").unwrap(), document).unwrap();
-        ApiSchema::from_api_schema(schema).expect("Failed to build schema")
-    }
-
-    fn build_default_schema() -> ApiSchema {
-        build_schema(
-            r#"
-                type Query {
-                    aField(first: Int, skip: Int): [SomeType]
-                }
-
-                type SomeType @entity {
-                    id: ID!
-                    name: String!
-                }
-            "#,
-        )
+    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,
-                Default::default(),
-                &schema
-            )
-            .unwrap()
-            .collection,
-            EntityCollection::All(vec![(EntityType::from("Entity1"), 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,
-                Default::default(),
-                &schema,
-            )
-            .unwrap()
-            .collection,
-            EntityCollection::All(vec![(EntityType::from("Entity2"), 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,
-                Default::default(),
-                &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,
-                Default::default(),
-                &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,
-                Default::default(),
-                &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,
-                Default::default(),
-                &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,
-                Default::default(),
-                &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,
-                Default::default(),
-                &schema,
-            )
-            .unwrap()
-            .order,
+            query(&field).order,
             EntityOrder::Ascending("name".to_string(), ValueType::String)
         );
 
@@ -1031,18 +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,
-                Default::default(),
-                &schema,
-            )
-            .unwrap()
-            .order,
+            query(&field).order,
             EntityOrder::Descending("name".to_string(), ValueType::String)
         );
 
@@ -1054,18 +928,7 @@ mod tests {
             ),
         ]);
         assert_eq!(
-            build_query(
-                &default_object(),
-                BLOCK_NUMBER_MAX,
-                &field,
-                &BTreeMap::new(),
-                std::u32::MAX,
-                std::u32::MAX,
-                Default::default(),
-                &schema,
-            )
-            .unwrap()
-            .order,
+            query(&field).order,
             EntityOrder::Ascending("name".to_string(), ValueType::String)
         );
 
@@ -1074,62 +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,
-                Default::default(),
-                &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,
-                Default::default(),
-                &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,
-                Default::default(),
-                &schema
-            )
-            .unwrap()
-            .range,
+            query(&field).range,
             EntityRange {
                 first: Some(100),
                 skip: 50,
@@ -1139,30 +961,15 @@ 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![(
-                "name_ends_with".to_string(),
+                "name_ends_with".into(),
                 r::Value::String("ello".to_string()),
             )])),
         );
         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,
-                Default::default(),
-                &schema
-            )
-            .unwrap()
-            .filter,
+            query(&query_field).filter,
             Some(EntityFilter::And(vec![EntityFilter::EndsWith(
                 "name".to_string(),
                 Value::String("ello".to_string()),
@@ -1170,36 +977,278 @@ 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![(
-                "_change_block".to_string(),
+                "_change_block".into(),
                 r::Value::Object(Object::from_iter(vec![(
-                    "number_gte".to_string(),
+                    "number_gte".into(),
                     r::Value::Int(10),
                 )])),
             )])),
         );
         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,
-                Default::default(),
-                &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 ff35d7b7838..1cfe64c4cbc 100644
--- a/graphql/src/store/resolver.rs
+++ b/graphql/src/store/resolver.rs
@@ -1,87 +1,42 @@
 use std::collections::BTreeMap;
-use std::result;
 use std::sync::Arc;
 
-use graph::data::query::Trace;
-use graph::data::value::Object;
-use graph::data::{
-    graphql::{object, ObjectOrInterface},
-    schema::META_FIELD_TYPE,
-};
+use async_trait::async_trait;
+use graph::components::graphql::GraphQLMetrics as _;
+use graph::components::store::QueryPermit;
+use graph::data::graphql::load_manager::LoadManager;
+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::{components::store::*, data::schema::BLOCK_FIELD_TYPE};
+use graph::schema::{BLOCK_FIELD_TYPE, ErrorPolicy};
+use graph::schema::{
+    INTROSPECTION_SCHEMA_FIELD_NAME, INTROSPECTION_TYPE_FIELD_NAME, LOGS_FIELD_NAME,
+    META_FIELD_NAME, META_FIELD_TYPE, ast as sast,
+};
 
-use crate::execution::ast as a;
+use crate::execution::{Query, ast as a};
 use crate::metrics::GraphQLMetrics;
+use crate::prelude::{ExecutionContext, Resolver};
 use crate::query::ext::BlockConstraint;
-use crate::schema::ast as sast;
-use crate::{prelude::*, schema::api::ErrorPolicy};
-
-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,
     graphql_metrics: Arc<GraphQLMetrics>,
+    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>,
-    ) -> 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,
-        }
-    }
-
     /// 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
@@ -91,28 +46,26 @@ 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.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,
             error_policy,
             graphql_metrics,
+            load_manager,
         };
         Ok(resolver)
     }
@@ -120,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,
@@ -139,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))
     }
 }
 
@@ -280,16 +255,17 @@ impl StoreResolver {
 impl Resolver for StoreResolver {
     const CACHEABLE: bool = true;
 
-    async fn query_permit(&self) -> Result<tokio::sync::OwnedSemaphorePermit, 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))
     }
 
@@ -319,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))
             }
@@ -348,26 +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 entities = collect_entities_from_query_field(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];
@@ -377,13 +383,54 @@ impl Resolver for StoreResolver {
             // Note that the meta field could have been queried under a different response key,
             // or a different field queried under the response key `_meta`.
             ErrorPolicy::Deny => {
-                let data = result.take_data();
-                let meta =
-                    data.and_then(|mut d| d.remove("_meta").map(|m| ("_meta".to_string(), m)));
-                result.set_data(meta.map(|m| Object::from_iter(Some(m))));
+                let mut data = result.take_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);
+
+                    // combine the fields into a vector
+                    let mut meta_fields = Vec::new();
+
+                    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));
+                    }
+                    if let Some(type_field) = type_field {
+                        meta_fields.push((Word::from(INTROSPECTION_TYPE_FIELD_NAME), type_field));
+                    }
+
+                    // return the object if it is not empty
+                    if meta_fields.is_empty() {
+                        None
+                    } else {
+                        Some(Object::from_iter(meta_fields))
+                    }
+                });
+
+                result.set_data(meta_fields);
             }
             ErrorPolicy::Allow => (),
         }
         Ok(())
     }
+
+    fn record_work(&self, query: &Query, elapsed: Duration, cache_status: CacheStatus) {
+        self.load_manager.record_work(
+            self.store.shard(),
+            self.store.deployment_id(),
+            query.shape_hash,
+            elapsed,
+            cache_status,
+        );
+    }
 }
diff --git a/graphql/src/subscription/mod.rs b/graphql/src/subscription/mod.rs
deleted file mode 100644
index ebb597a83e2..00000000000
--- a/graphql/src/subscription/mod.rs
+++ /dev/null
@@ -1,241 +0,0 @@
-use std::result::Result;
-use std::time::{Duration, Instant};
-
-use graph::components::store::UnitStream;
-use graph::{components::store::SubscriptionManager, prelude::*};
-
-use crate::metrics::GraphQLMetrics;
-use crate::{
-    execution::ast as a,
-    execution::*,
-    prelude::{BlockConstraint, StoreResolver},
-    schema::api::ErrorPolicy,
-};
-
-/// 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 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(),
-    );
-    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,
-    } = 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(),
-            )
-            .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>,
-) -> 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>,
-    ) -> 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,
-        )
-        .await
-    }
-
-    let resolver = match make_resolver(store, &logger, subscription_manager, &query, metrics).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 7f4f8cedd50..bd0bacbf677 100644
--- a/graphql/src/values/coercion.rs
+++ b/graphql/src/values/coercion.rs
@@ -1,6 +1,7 @@
-use crate::schema;
+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,12 +37,20 @@ 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))
                 }
             }
+            ("Int8", q::Value::Int(num)) => {
+                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(
@@ -79,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(),
@@ -202,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![],
             }],
@@ -251,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);
 
@@ -280,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)
@@ -320,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)
@@ -344,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)
@@ -375,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)
@@ -395,9 +403,24 @@ mod tests {
         );
     }
 
+    #[test]
+    fn coerce_int8_scalar() {
+        let int8_type = s::TypeDefinition::Scalar(s::ScalarType::new("Int8".to_string()));
+        let resolver = |_: &str| Some(&int8_type);
+
+        assert_eq!(
+            coerce_to_definition(Value::Int(1234.into()), "", &resolver),
+            Ok(Value::String("1234".to_string()))
+        );
+        assert_eq!(
+            coerce_to_definition(Value::Int((-1234_i32).into()), "", &resolver,),
+            Ok(Value::String("-1234".to_string()))
+        );
+    }
+
     #[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)
@@ -409,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/graphql/tests/README.md b/graphql/tests/README.md
new file mode 100644
index 00000000000..c2b55fa311e
--- /dev/null
+++ b/graphql/tests/README.md
@@ -0,0 +1,5 @@
+Put integration tests for this crate into `store/test-store/tests/graphql`.
+This avoids cyclic dev-dependencies which make rust-analyzer nearly
+unusable. Once [this
+issue](https://github.com/rust-lang/rust-analyzer/issues/14167) has been
+fixed, we can move tests back here
diff --git a/graphql/tests/introspection.rs b/graphql/tests/introspection.rs
deleted file mode 100644
index ab2360e2567..00000000000
--- a/graphql/tests/introspection.rs
+++ /dev/null
@@ -1,1288 +0,0 @@
-#[macro_use]
-extern crate pretty_assertions;
-
-use std::sync::Arc;
-
-use graph::data::graphql::{object, object_value, ObjectOrInterface};
-use graph::data::query::Trace;
-use graph::prelude::{
-    async_trait, o, r, s, slog, tokio, ApiSchema, DeploymentHash, Logger, Query,
-    QueryExecutionError, QueryResult, Schema,
-};
-use graph_graphql::prelude::{
-    a, api_schema, execute_query, ExecutionContext, Query as PreparedQuery, QueryExecutionOptions,
-    Resolver,
-};
-use test_store::graphql_metrics;
-use test_store::LOAD_MANAGER;
-
-/// Mock resolver used in tests that don't need a resolver.
-#[derive(Clone)]
-pub struct MockResolver;
-
-#[async_trait]
-impl Resolver for MockResolver {
-    const CACHEABLE: bool = false;
-
-    fn prefetch(
-        &self,
-        _: &ExecutionContext<Self>,
-        _: &a::SelectionSet,
-    ) -> Result<(Option<r::Value>, Trace), Vec<QueryExecutionError>> {
-        Ok((None, Trace::None))
-    }
-
-    async fn resolve_objects(
-        &self,
-        _: Option<r::Value>,
-        _field: &a::Field,
-        _field_definition: &s::Field,
-        _object_type: ObjectOrInterface<'_>,
-    ) -> Result<r::Value, QueryExecutionError> {
-        Ok(r::Value::Null)
-    }
-
-    async fn resolve_object(
-        &self,
-        __: Option<r::Value>,
-        _field: &a::Field,
-        _field_definition: &s::Field,
-        _object_type: ObjectOrInterface<'_>,
-    ) -> Result<r::Value, QueryExecutionError> {
-        Ok(r::Value::Null)
-    }
-
-    async fn query_permit(&self) -> Result<tokio::sync::OwnedSemaphorePermit, QueryExecutionError> {
-        Ok(Arc::new(tokio::sync::Semaphore::new(1))
-            .acquire_owned()
-            .await
-            .unwrap())
-    }
-}
-
-/// Creates a basic GraphQL schema that exercies scalars, directives,
-/// enums, interfaces, input objects, object types and field arguments.
-fn mock_schema() -> Schema {
-    Schema::parse(
-        "
-             scalar ID
-             scalar Int
-             scalar String
-             scalar Boolean
-
-             directive @language(
-               language: String = \"English\"
-             ) on FIELD_DEFINITION
-
-             enum Role {
-               USER
-               ADMIN
-             }
-
-             interface Node {
-               id: ID!
-             }
-
-             type User implements Node @entity {
-               id: ID!
-               name: String! @language(language: \"English\")
-               role: Role!
-             }
-
-             enum User_orderBy {
-               id
-               name
-             }
-
-             input User_filter {
-               name_eq: String = \"default name\",
-               name_not: String,
-             }
-
-             type Query @entity {
-               allUsers(orderBy: User_orderBy, filter: User_filter): [User!]
-               anyUserWithAge(age: Int = 99): User
-               User: User
-             }
-             ",
-        DeploymentHash::new("mockschema").unwrap(),
-    )
-    .unwrap()
-}
-
-/// Builds the expected result for GraphiQL's introspection query that we are
-/// using for testing.
-fn expected_mock_schema_introspection() -> r::Value {
-    let string_type = object! {
-        kind: r::Value::Enum("SCALAR".to_string()),
-        name: "String",
-        description: r::Value::Null,
-        fields: r::Value::Null,
-        inputFields: r::Value::Null,
-        interfaces: r::Value::Null,
-        enumValues: r::Value::Null,
-        possibleTypes: r::Value::Null,
-    };
-
-    let id_type = object! {
-        kind: r::Value::Enum("SCALAR".to_string()),
-        name: "ID",
-        description: r::Value::Null,
-        fields: r::Value::Null,
-        inputFields: r::Value::Null,
-        interfaces: r::Value::Null,
-        enumValues: r::Value::Null,
-        possibleTypes: r::Value::Null,
-    };
-
-    let int_type = object! {
-        kind: r::Value::Enum("SCALAR".to_string()),
-        name: "Int",
-        description: r::Value::Null,
-        fields: r::Value::Null,
-        inputFields: r::Value::Null,
-        interfaces: r::Value::Null,
-        enumValues: r::Value::Null,
-        possibleTypes: r::Value::Null,
-    };
-
-    let boolean_type = object! {
-        kind: r::Value::Enum("SCALAR".to_string()),
-        name: "Boolean",
-        description: r::Value::Null,
-        fields: r::Value::Null,
-        inputFields: r::Value::Null,
-        interfaces: r::Value::Null,
-        enumValues: r::Value::Null,
-        possibleTypes: r::Value::Null,
-    };
-
-    let role_type = object! {
-        kind: r::Value::Enum("ENUM".to_string()),
-        name: "Role",
-        description: r::Value::Null,
-        fields: r::Value::Null,
-        inputFields: r::Value::Null,
-        interfaces: r::Value::Null,
-        enumValues:
-            r::Value::List(vec![
-                object! {
-                    name: "USER",
-                    description: r::Value::Null,
-                    isDeprecated: r::Value::Boolean(false),
-                    deprecationReason: r::Value::Null,
-                },
-                object! {
-                    name: "ADMIN",
-                    description: r::Value::Null,
-                    isDeprecated: false,
-                    deprecationReason: r::Value::Null,
-                },
-            ]),
-        possibleTypes: r::Value::Null,
-    };
-
-    let node_type = object_value(vec![
-        ("kind", r::Value::Enum("INTERFACE".to_string())),
-        ("name", r::Value::String("Node".to_string())),
-        ("description", r::Value::Null),
-        (
-            "fields",
-            r::Value::List(vec![object_value(vec![
-                ("name", r::Value::String("id".to_string())),
-                ("description", r::Value::Null),
-                ("args", r::Value::List(vec![])),
-                (
-                    "type",
-                    object_value(vec![
-                        ("kind", r::Value::Enum("NON_NULL".to_string())),
-                        ("name", r::Value::Null),
-                        (
-                            "ofType",
-                            object_value(vec![
-                                ("kind", r::Value::Enum("SCALAR".to_string())),
-                                ("name", r::Value::String("ID".to_string())),
-                                ("ofType", r::Value::Null),
-                            ]),
-                        ),
-                    ]),
-                ),
-                ("isDeprecated", r::Value::Boolean(false)),
-                ("deprecationReason", r::Value::Null),
-            ])]),
-        ),
-        ("inputFields", r::Value::Null),
-        ("interfaces", r::Value::Null),
-        ("enumValues", r::Value::Null),
-        (
-            "possibleTypes",
-            r::Value::List(vec![object_value(vec![
-                ("kind", r::Value::Enum("OBJECT".to_string())),
-                ("name", r::Value::String("User".to_string())),
-                ("ofType", r::Value::Null),
-            ])]),
-        ),
-    ]);
-
-    let user_orderby_type = object_value(vec![
-        ("kind", r::Value::Enum("ENUM".to_string())),
-        ("name", r::Value::String("User_orderBy".to_string())),
-        ("description", r::Value::Null),
-        ("fields", r::Value::Null),
-        ("inputFields", r::Value::Null),
-        ("interfaces", r::Value::Null),
-        (
-            "enumValues",
-            r::Value::List(vec![
-                object_value(vec![
-                    ("name", r::Value::String("id".to_string())),
-                    ("description", r::Value::Null),
-                    ("isDeprecated", r::Value::Boolean(false)),
-                    ("deprecationReason", r::Value::Null),
-                ]),
-                object_value(vec![
-                    ("name", r::Value::String("name".to_string())),
-                    ("description", r::Value::Null),
-                    ("isDeprecated", r::Value::Boolean(false)),
-                    ("deprecationReason", r::Value::Null),
-                ]),
-            ]),
-        ),
-        ("possibleTypes", r::Value::Null),
-    ]);
-
-    let user_filter_type = object_value(vec![
-        ("kind", r::Value::Enum("INPUT_OBJECT".to_string())),
-        ("name", r::Value::String("User_filter".to_string())),
-        ("description", r::Value::Null),
-        ("fields", r::Value::Null),
-        (
-            "inputFields",
-            r::Value::List(vec![
-                object_value(vec![
-                    ("name", r::Value::String("name_eq".to_string())),
-                    ("description", r::Value::Null),
-                    (
-                        "type",
-                        object_value(vec![
-                            ("kind", r::Value::Enum("SCALAR".to_string())),
-                            ("name", r::Value::String("String".to_string())),
-                            ("ofType", r::Value::Null),
-                        ]),
-                    ),
-                    (
-                        "defaultValue",
-                        r::Value::String("\"default name\"".to_string()),
-                    ),
-                ]),
-                object_value(vec![
-                    ("name", r::Value::String("name_not".to_string())),
-                    ("description", r::Value::Null),
-                    (
-                        "type",
-                        object_value(vec![
-                            ("kind", r::Value::Enum("SCALAR".to_string())),
-                            ("name", r::Value::String("String".to_string())),
-                            ("ofType", r::Value::Null),
-                        ]),
-                    ),
-                    ("defaultValue", r::Value::Null),
-                ]),
-            ]),
-        ),
-        ("interfaces", r::Value::Null),
-        ("enumValues", r::Value::Null),
-        ("possibleTypes", r::Value::Null),
-    ]);
-
-    let user_type = object_value(vec![
-        ("kind", r::Value::Enum("OBJECT".to_string())),
-        ("name", r::Value::String("User".to_string())),
-        ("description", r::Value::Null),
-        (
-            "fields",
-            r::Value::List(vec![
-                object_value(vec![
-                    ("name", r::Value::String("id".to_string())),
-                    ("description", r::Value::Null),
-                    ("args", r::Value::List(vec![])),
-                    (
-                        "type",
-                        object_value(vec![
-                            ("kind", r::Value::Enum("NON_NULL".to_string())),
-                            ("name", r::Value::Null),
-                            (
-                                "ofType",
-                                object_value(vec![
-                                    ("kind", r::Value::Enum("SCALAR".to_string())),
-                                    ("name", r::Value::String("ID".to_string())),
-                                    ("ofType", r::Value::Null),
-                                ]),
-                            ),
-                        ]),
-                    ),
-                    ("isDeprecated", r::Value::Boolean(false)),
-                    ("deprecationReason", r::Value::Null),
-                ]),
-                object_value(vec![
-                    ("name", r::Value::String("name".to_string())),
-                    ("description", r::Value::Null),
-                    ("args", r::Value::List(vec![])),
-                    (
-                        "type",
-                        object_value(vec![
-                            ("kind", r::Value::Enum("NON_NULL".to_string())),
-                            ("name", r::Value::Null),
-                            (
-                                "ofType",
-                                object_value(vec![
-                                    ("kind", r::Value::Enum("SCALAR".to_string())),
-                                    ("name", r::Value::String("String".to_string())),
-                                    ("ofType", r::Value::Null),
-                                ]),
-                            ),
-                        ]),
-                    ),
-                    ("isDeprecated", r::Value::Boolean(false)),
-                    ("deprecationReason", r::Value::Null),
-                ]),
-                object_value(vec![
-                    ("name", r::Value::String("role".to_string())),
-                    ("description", r::Value::Null),
-                    ("args", r::Value::List(vec![])),
-                    (
-                        "type",
-                        object_value(vec![
-                            ("kind", r::Value::Enum("NON_NULL".to_string())),
-                            ("name", r::Value::Null),
-                            (
-                                "ofType",
-                                object_value(vec![
-                                    ("kind", r::Value::Enum("ENUM".to_string())),
-                                    ("name", r::Value::String("Role".to_string())),
-                                    ("ofType", r::Value::Null),
-                                ]),
-                            ),
-                        ]),
-                    ),
-                    ("isDeprecated", r::Value::Boolean(false)),
-                    ("deprecationReason", r::Value::Null),
-                ]),
-            ]),
-        ),
-        ("inputFields", r::Value::Null),
-        (
-            "interfaces",
-            r::Value::List(vec![object_value(vec![
-                ("kind", r::Value::Enum("INTERFACE".to_string())),
-                ("name", r::Value::String("Node".to_string())),
-                ("ofType", r::Value::Null),
-            ])]),
-        ),
-        ("enumValues", r::Value::Null),
-        ("possibleTypes", r::Value::Null),
-    ]);
-
-    let query_type = object_value(vec![
-        ("kind", r::Value::Enum("OBJECT".to_string())),
-        ("name", r::Value::String("Query".to_string())),
-        ("description", r::Value::Null),
-        (
-            "fields",
-            r::Value::List(vec![
-                object_value(vec![
-                    ("name", r::Value::String("allUsers".to_string())),
-                    ("description", r::Value::Null),
-                    (
-                        "args",
-                        r::Value::List(vec![
-                            object_value(vec![
-                                ("name", r::Value::String("orderBy".to_string())),
-                                ("description", r::Value::Null),
-                                (
-                                    "type",
-                                    object_value(vec![
-                                        ("kind", r::Value::Enum("ENUM".to_string())),
-                                        ("name", r::Value::String("User_orderBy".to_string())),
-                                        ("ofType", r::Value::Null),
-                                    ]),
-                                ),
-                                ("defaultValue", r::Value::Null),
-                            ]),
-                            object_value(vec![
-                                ("name", r::Value::String("filter".to_string())),
-                                ("description", r::Value::Null),
-                                (
-                                    "type",
-                                    object_value(vec![
-                                        ("kind", r::Value::Enum("INPUT_OBJECT".to_string())),
-                                        ("name", r::Value::String("User_filter".to_string())),
-                                        ("ofType", r::Value::Null),
-                                    ]),
-                                ),
-                                ("defaultValue", r::Value::Null),
-                            ]),
-                        ]),
-                    ),
-                    (
-                        "type",
-                        object_value(vec![
-                            ("kind", r::Value::Enum("LIST".to_string())),
-                            ("name", r::Value::Null),
-                            (
-                                "ofType",
-                                object_value(vec![
-                                    ("kind", r::Value::Enum("NON_NULL".to_string())),
-                                    ("name", r::Value::Null),
-                                    (
-                                        "ofType",
-                                        object_value(vec![
-                                            ("kind", r::Value::Enum("OBJECT".to_string())),
-                                            ("name", r::Value::String("User".to_string())),
-                                            ("ofType", r::Value::Null),
-                                        ]),
-                                    ),
-                                ]),
-                            ),
-                        ]),
-                    ),
-                    ("isDeprecated", r::Value::Boolean(false)),
-                    ("deprecationReason", r::Value::Null),
-                ]),
-                object_value(vec![
-                    ("name", r::Value::String("anyUserWithAge".to_string())),
-                    ("description", r::Value::Null),
-                    (
-                        "args",
-                        r::Value::List(vec![object_value(vec![
-                            ("name", r::Value::String("age".to_string())),
-                            ("description", r::Value::Null),
-                            (
-                                "type",
-                                object_value(vec![
-                                    ("kind", r::Value::Enum("SCALAR".to_string())),
-                                    ("name", r::Value::String("Int".to_string())),
-                                    ("ofType", r::Value::Null),
-                                ]),
-                            ),
-                            ("defaultValue", r::Value::String("99".to_string())),
-                        ])]),
-                    ),
-                    (
-                        "type",
-                        object_value(vec![
-                            ("kind", r::Value::Enum("OBJECT".to_string())),
-                            ("name", r::Value::String("User".to_string())),
-                            ("ofType", r::Value::Null),
-                        ]),
-                    ),
-                    ("isDeprecated", r::Value::Boolean(false)),
-                    ("deprecationReason", r::Value::Null),
-                ]),
-                object_value(vec![
-                    ("name", r::Value::String("User".to_string())),
-                    ("description", r::Value::Null),
-                    ("args", r::Value::List(vec![])),
-                    (
-                        "type",
-                        object_value(vec![
-                            ("kind", r::Value::Enum("OBJECT".to_string())),
-                            ("name", r::Value::String("User".to_string())),
-                            ("ofType", r::Value::Null),
-                        ]),
-                    ),
-                    ("isDeprecated", r::Value::Boolean(false)),
-                    ("deprecationReason", r::Value::Null),
-                ]),
-            ]),
-        ),
-        ("inputFields", r::Value::Null),
-        ("interfaces", r::Value::List(vec![])),
-        ("enumValues", r::Value::Null),
-        ("possibleTypes", r::Value::Null),
-    ]);
-
-    let expected_types = r::Value::List(vec![
-        boolean_type,
-        id_type,
-        int_type,
-        node_type,
-        query_type,
-        role_type,
-        string_type,
-        user_type,
-        user_filter_type,
-        user_orderby_type,
-    ]);
-
-    let expected_directives = r::Value::List(vec![object_value(vec![
-        ("name", r::Value::String("language".to_string())),
-        ("description", r::Value::Null),
-        (
-            "locations",
-            r::Value::List(vec![r::Value::Enum(String::from("FIELD_DEFINITION"))]),
-        ),
-        (
-            "args",
-            r::Value::List(vec![object_value(vec![
-                ("name", r::Value::String("language".to_string())),
-                ("description", r::Value::Null),
-                (
-                    "type",
-                    object_value(vec![
-                        ("kind", r::Value::Enum("SCALAR".to_string())),
-                        ("name", r::Value::String("String".to_string())),
-                        ("ofType", r::Value::Null),
-                    ]),
-                ),
-                ("defaultValue", r::Value::String("\"English\"".to_string())),
-            ])]),
-        ),
-    ])]);
-
-    let schema_type = object_value(vec![
-        (
-            "queryType",
-            object_value(vec![("name", r::Value::String("Query".to_string()))]),
-        ),
-        ("mutationType", r::Value::Null),
-        ("subscriptionType", r::Value::Null),
-        ("types", expected_types),
-        ("directives", expected_directives),
-    ]);
-
-    object_value(vec![("__schema", schema_type)])
-}
-
-/// Execute an introspection query.
-async fn introspection_query(schema: Schema, query: &str) -> QueryResult {
-    // Create the query
-    let query = Query::new(
-        graphql_parser::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,
-        load_manager: LOAD_MANAGER.clone(),
-        trace: false,
-    };
-
-    let schema = Arc::new(ApiSchema::from_api_schema(schema).unwrap());
-    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())
-            }
-            Err(e) => Err(e),
-        };
-    QueryResult::from(result)
-}
-
-#[tokio::test]
-async fn satisfies_graphiql_introspection_query_without_fragments() {
-    let result = introspection_query(
-        mock_schema(),
-        "
-      query IntrospectionQuery {
-        __schema {
-          queryType { name }
-          mutationType { name }
-          subscriptionType { name}
-          types {
-            kind
-            name
-            description
-            fields(includeDeprecated: true) {
-              name
-              description
-              args {
-                name
-                description
-                type {
-                  kind
-                  name
-                  ofType {
-                    kind
-                    name
-                    ofType {
-                      kind
-                      name
-                      ofType {
-                        kind
-                        name
-                        ofType {
-                          kind
-                          name
-                          ofType {
-                            kind
-                            name
-                            ofType {
-                              kind
-                              name
-                              ofType {
-                                kind
-                                name
-                              }
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-                defaultValue
-              }
-              type {
-                kind
-                name
-                ofType {
-                  kind
-                  name
-                  ofType {
-                    kind
-                    name
-                    ofType {
-                      kind
-                      name
-                      ofType {
-                        kind
-                        name
-                        ofType {
-                          kind
-                          name
-                          ofType {
-                            kind
-                            name
-                            ofType {
-                              kind
-                              name
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              isDeprecated
-              deprecationReason
-            }
-            inputFields {
-              name
-              description
-              type {
-                kind
-                name
-                ofType {
-                  kind
-                  name
-                  ofType {
-                    kind
-                    name
-                    ofType {
-                      kind
-                      name
-                      ofType {
-                        kind
-                        name
-                        ofType {
-                          kind
-                          name
-                          ofType {
-                            kind
-                            name
-                            ofType {
-                              kind
-                              name
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              defaultValue
-            }
-            interfaces {
-              kind
-              name
-              ofType {
-                kind
-                name
-                ofType {
-                  kind
-                  name
-                  ofType {
-                    kind
-                    name
-                    ofType {
-                      kind
-                      name
-                      ofType {
-                        kind
-                        name
-                        ofType {
-                          kind
-                          name
-                          ofType {
-                            kind
-                            name
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            enumValues(includeDeprecated: true) {
-              name
-              description
-              isDeprecated
-              deprecationReason
-            }
-            possibleTypes {
-              kind
-              name
-              ofType {
-                kind
-                name
-                ofType {
-                  kind
-                  name
-                  ofType {
-                    kind
-                    name
-                    ofType {
-                      kind
-                      name
-                      ofType {
-                        kind
-                        name
-                        ofType {
-                          kind
-                          name
-                          ofType {
-                            kind
-                            name
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-           }
-          }
-          directives {
-            name
-            description
-            locations
-            args {
-              name
-              description
-              type {
-                kind
-                name
-                ofType {
-                  kind
-                  name
-                  ofType {
-                    kind
-                    name
-                    ofType {
-                      kind
-                      name
-                      ofType {
-                        kind
-                        name
-                        ofType {
-                          kind
-                          name
-                          ofType {
-                            kind
-                            name
-                            ofType {
-                              kind
-                              name
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-              defaultValue
-            }
-          }
-        }
-      }
-    ",
-    )
-    .await;
-
-    let data = result
-        .to_result()
-        .expect("Introspection query returned no result")
-        .unwrap();
-    assert_eq!(data, expected_mock_schema_introspection());
-}
-
-#[tokio::test]
-async fn satisfies_graphiql_introspection_query_with_fragments() {
-    let result = introspection_query(
-        mock_schema(),
-        "
-      query IntrospectionQuery {
-        __schema {
-          queryType { name }
-          mutationType { name }
-          subscriptionType { name }
-          types {
-            ...FullType
-          }
-          directives {
-            name
-            description
-            locations
-            args {
-              ...InputValue
-            }
-          }
-        }
-      }
-
-      fragment FullType on __Type {
-        kind
-        name
-        description
-        fields(includeDeprecated: true) {
-          name
-          description
-          args {
-            ...InputValue
-          }
-          type {
-            ...TypeRef
-          }
-          isDeprecated
-          deprecationReason
-        }
-        inputFields {
-          ...InputValue
-        }
-        interfaces {
-          ...TypeRef
-        }
-        enumValues(includeDeprecated: true) {
-          name
-          description
-          isDeprecated
-          deprecationReason
-        }
-        possibleTypes {
-          ...TypeRef
-        }
-      }
-
-      fragment InputValue on __InputValue {
-        name
-        description
-        type { ...TypeRef }
-        defaultValue
-      }
-
-      fragment TypeRef on __Type {
-        kind
-        name
-        ofType {
-          kind
-          name
-          ofType {
-            kind
-            name
-            ofType {
-              kind
-              name
-              ofType {
-                kind
-                name
-                ofType {
-                  kind
-                  name
-                  ofType {
-                    kind
-                    name
-                    ofType {
-                      kind
-                      name
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    ",
-    )
-    .await;
-
-    let data = result
-        .to_result()
-        .expect("Introspection query returned no result")
-        .unwrap();
-    assert_eq!(data, expected_mock_schema_introspection());
-}
-
-const COMPLEX_SCHEMA: &str = "
-enum RegEntryStatus {
-  regEntry_status_challengePeriod
-  regEntry_status_commitPeriod
-  regEntry_status_revealPeriod
-  regEntry_status_blacklisted
-  regEntry_status_whitelisted
-}
-
-interface RegEntry {
-  regEntry_address: ID
-  regEntry_version: Int
-  regEntry_status: RegEntryStatus
-  regEntry_creator: User
-  regEntry_deposit: Int
-  regEntry_createdOn: String
-  regEntry_challengePeriodEnd: String
-  challenge_challenger: User
-  challenge_createdOn: String
-  challenge_comment: String
-  challenge_votingToken: String
-  challenge_rewardPool: Int
-  challenge_commitPeriodEnd: String
-  challenge_revealPeriodEnd: String
-  challenge_votesFor: Int
-  challenge_votesAgainst: Int
-  challenge_votesTotal: Int
-  challenge_claimedRewardOn: String
-  challenge_vote(vote_voter: ID!): Vote
-}
-
-enum VoteOption {
-  voteOption_noVote
-  voteOption_voteFor
-  voteOption_voteAgainst
-}
-
-type Vote @entity {
-  vote_secretHash: String
-  vote_option: VoteOption
-  vote_amount: Int
-  vote_revealedOn: String
-  vote_claimedRewardOn: String
-  vote_reward: Int
-}
-
-type Meme implements RegEntry @entity {
-  regEntry_address: ID
-  regEntry_version: Int
-  regEntry_status: RegEntryStatus
-  regEntry_creator: User
-  regEntry_deposit: Int
-  regEntry_createdOn: String
-  regEntry_challengePeriodEnd: String
-  challenge_challenger: User
-  challenge_createdOn: String
-  challenge_comment: String
-  challenge_votingToken: String
-  challenge_rewardPool: Int
-  challenge_commitPeriodEnd: String
-  challenge_revealPeriodEnd: String
-  challenge_votesFor: Int
-  challenge_votesAgainst: Int
-  challenge_votesTotal: Int
-  challenge_claimedRewardOn: String
-  challenge_vote(vote_voter: ID!): Vote
-  # Balance of voting token of a voter. This is client-side only, server doesn't return this
-  challenge_availableVoteAmount(voter: ID!): Int
-  meme_title: String
-  meme_number: Int
-  meme_metaHash: String
-  meme_imageHash: String
-  meme_totalSupply: Int
-  meme_totalMinted: Int
-  meme_tokenIdStart: Int
-  meme_totalTradeVolume: Int
-  meme_totalTradeVolumeRank: Int
-  meme_ownedMemeTokens(owner: String): [MemeToken]
-  meme_tags: [Tag]
-}
-
-type Tag  @entity {
-  tag_id: ID
-  tag_name: String
-}
-
-type MemeToken @entity {
-  memeToken_tokenId: ID
-  memeToken_number: Int
-  memeToken_owner: User
-  memeToken_meme: Meme
-}
-
-enum MemeAuctionStatus {
-  memeAuction_status_active
-  memeAuction_status_canceled
-  memeAuction_status_done
-}
-
-type MemeAuction @entity {
-  memeAuction_address: ID
-  memeAuction_seller: User
-  memeAuction_buyer: User
-  memeAuction_startPrice: Int
-  memeAuction_endPrice: Int
-  memeAuction_duration: Int
-  memeAuction_startedOn: String
-  memeAuction_boughtOn: String
-  memeAuction_status: MemeAuctionStatus
-  memeAuction_memeToken: MemeToken
-}
-
-type ParamChange implements RegEntry @entity {
-  regEntry_address: ID
-  regEntry_version: Int
-  regEntry_status: RegEntryStatus
-  regEntry_creator: User
-  regEntry_deposit: Int
-  regEntry_createdOn: String
-  regEntry_challengePeriodEnd: String
-  challenge_challenger: User
-  challenge_createdOn: String
-  challenge_comment: String
-  challenge_votingToken: String
-  challenge_rewardPool: Int
-  challenge_commitPeriodEnd: String
-  challenge_revealPeriodEnd: String
-  challenge_votesFor: Int
-  challenge_votesAgainst: Int
-  challenge_votesTotal: Int
-  challenge_claimedRewardOn: String
-  challenge_vote(vote_voter: ID!): Vote
-  # Balance of voting token of a voter. This is client-side only, server doesn't return this
-  challenge_availableVoteAmount(voter: ID!): Int
-  paramChange_db: String
-  paramChange_key: String
-  paramChange_value: Int
-  paramChange_originalValue: Int
-  paramChange_appliedOn: String
-}
-
-type User @entity {
-  # Ethereum address of an user
-  user_address: ID
-  # Total number of memes submitted by user
-  user_totalCreatedMemes: Int
-  # Total number of memes submitted by user, which successfully got into TCR
-  user_totalCreatedMemesWhitelisted: Int
-  # Largest sale creator has done with his newly minted meme
-  user_creatorLargestSale: MemeAuction
-  # Position of a creator in leaderboard according to user_totalCreatedMemesWhitelisted
-  user_creatorRank: Int
-  # Amount of meme tokenIds owned by user
-  user_totalCollectedTokenIds: Int
-  # Amount of unique memes owned by user
-  user_totalCollectedMemes: Int
-  # Largest auction user sold, in terms of price
-  user_largestSale: MemeAuction
-  # Largest auction user bought into, in terms of price
-  user_largestBuy: MemeAuction
-  # Amount of challenges user created
-  user_totalCreatedChallenges: Int
-  # Amount of challenges user created and ended up in his favor
-  user_totalCreatedChallengesSuccess: Int
-  # Total amount of DANK token user received from challenger rewards
-  user_challengerTotalEarned: Int
-  # Total amount of DANK token user received from challenger rewards
-  user_challengerRank: Int
-  # Amount of different votes user participated in
-  user_totalParticipatedVotes: Int
-  # Amount of different votes user voted for winning option
-  user_totalParticipatedVotesSuccess: Int
-  # Amount of DANK token user received for voting for winning option
-  user_voterTotalEarned: Int
-  # Position of voter in leaderboard according to user_voterTotalEarned
-  user_voterRank: Int
-  # Sum of user_challengerTotalEarned and user_voterTotalEarned
-  user_curatorTotalEarned: Int
-  # Position of curator in leaderboard according to user_curatorTotalEarned
-  user_curatorRank: Int
-}
-
-type Parameter @entity {
-  param_db: ID
-  param_key: ID
-  param_value: Int
-}
-";
-
-#[tokio::test]
-async fn successfully_runs_introspection_query_against_complex_schema() {
-    let mut schema = Schema::parse(
-        COMPLEX_SCHEMA,
-        DeploymentHash::new("complexschema").unwrap(),
-    )
-    .unwrap();
-    schema.document = api_schema(&schema.document).unwrap();
-
-    let result = introspection_query(
-        schema.clone(),
-        "
-        query IntrospectionQuery {
-          __schema {
-            queryType { name }
-            mutationType { name }
-            subscriptionType { name }
-            types {
-              ...FullType
-            }
-            directives {
-              name
-              description
-              locations
-              args {
-                ...InputValue
-              }
-            }
-          }
-        }
-
-        fragment FullType on __Type {
-          kind
-          name
-          description
-          fields(includeDeprecated: true) {
-            name
-            description
-            args {
-              ...InputValue
-            }
-            type {
-              ...TypeRef
-            }
-            isDeprecated
-            deprecationReason
-          }
-          inputFields {
-            ...InputValue
-          }
-          interfaces {
-            ...TypeRef
-          }
-          enumValues(includeDeprecated: true) {
-            name
-            description
-            isDeprecated
-            deprecationReason
-          }
-          possibleTypes {
-            ...TypeRef
-          }
-        }
-
-        fragment InputValue on __InputValue {
-          name
-          description
-          type { ...TypeRef }
-          defaultValue
-        }
-
-        fragment TypeRef on __Type {
-          kind
-          name
-          ofType {
-            kind
-            name
-            ofType {
-              kind
-              name
-              ofType {
-                kind
-                name
-                ofType {
-                  kind
-                  name
-                  ofType {
-                    kind
-                    name
-                    ofType {
-                      kind
-                      name
-                      ofType {
-                        kind
-                        name
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-    ",
-    )
-    .await;
-
-    assert!(!result.has_errors(), "{:#?}", result);
-}
-
-#[tokio::test]
-async fn introspection_possible_types() {
-    let mut schema = Schema::parse(
-        COMPLEX_SCHEMA,
-        DeploymentHash::new("complexschema").unwrap(),
-    )
-    .unwrap();
-    schema.document = api_schema(&schema.document).unwrap();
-
-    // Test "possibleTypes" introspection in interfaces
-    let response = introspection_query(
-        schema,
-        "query {
-          __type(name: \"RegEntry\") {
-              name
-              possibleTypes {
-                name
-              }
-          }
-        }",
-    )
-    .await
-    .to_result()
-    .unwrap()
-    .unwrap();
-
-    assert_eq!(
-        response,
-        object_value(vec![(
-            "__type",
-            object_value(vec![
-                ("name", r::Value::String("RegEntry".to_string())),
-                (
-                    "possibleTypes",
-                    r::Value::List(vec![
-                        object_value(vec![("name", r::Value::String("Meme".to_owned()))]),
-                        object_value(vec![("name", r::Value::String("ParamChange".to_owned()))])
-                    ])
-                )
-            ])
-        )])
-    )
-}
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/mock/Cargo.toml b/mock/Cargo.toml
deleted file mode 100644
index 02a1a333d74..00000000000
--- a/mock/Cargo.toml
+++ /dev/null
@@ -1,7 +0,0 @@
-[package]
-name = "graph-mock"
-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-graph = { path = "../graph" }
diff --git a/mock/src/lib.rs b/mock/src/lib.rs
deleted file mode 100644
index 8d4df4b3db9..00000000000
--- a/mock/src/lib.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod metrics_registry;
-
-pub use self::metrics_registry::MockMetricsRegistry;
diff --git a/mock/src/metrics_registry.rs b/mock/src/metrics_registry.rs
deleted file mode 100644
index 0b450523b64..00000000000
--- a/mock/src/metrics_registry.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-use graph::components::metrics::{Collector, Counter, Gauge, Opts, PrometheusError};
-use graph::prelude::MetricsRegistry as MetricsRegistryTrait;
-use graph::prometheus::{CounterVec, GaugeVec, HistogramOpts, HistogramVec};
-
-use std::collections::HashMap;
-
-#[derive(Clone)]
-pub struct MockMetricsRegistry {}
-
-impl MockMetricsRegistry {
-    pub fn new() -> Self {
-        Self {}
-    }
-}
-
-impl MetricsRegistryTrait for MockMetricsRegistry {
-    fn register(&self, _name: &str, _c: Box<dyn Collector>) {
-        // Ignore, we do not register metrics
-    }
-
-    fn global_counter(
-        &self,
-        name: &str,
-        help: &str,
-        const_labels: HashMap<String, String>,
-    ) -> Result<Counter, PrometheusError> {
-        let opts = Opts::new(name, help).const_labels(const_labels);
-        Counter::with_opts(opts)
-    }
-
-    fn global_gauge(
-        &self,
-        name: &str,
-        help: &str,
-        const_labels: HashMap<String, String>,
-    ) -> Result<Gauge, PrometheusError> {
-        let opts = Opts::new(name, help).const_labels(const_labels);
-        Gauge::with_opts(opts)
-    }
-
-    fn unregister(&self, _: Box<dyn Collector>) {}
-
-    fn global_counter_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: &[&str],
-    ) -> Result<CounterVec, PrometheusError> {
-        let opts = Opts::new(name, help);
-        let counters = CounterVec::new(opts, variable_labels)?;
-        Ok(counters)
-    }
-
-    fn global_deployment_counter_vec(
-        &self,
-        name: &str,
-        help: &str,
-        subgraph: &str,
-        variable_labels: &[&str],
-    ) -> Result<CounterVec, PrometheusError> {
-        let opts = Opts::new(name, help).const_label("deployment", subgraph);
-        let counters = CounterVec::new(opts, variable_labels)?;
-        Ok(counters)
-    }
-
-    fn global_gauge_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: &[&str],
-    ) -> Result<GaugeVec, PrometheusError> {
-        let opts = Opts::new(name, help);
-        let gauges = GaugeVec::new(opts, variable_labels)?;
-        Ok(gauges)
-    }
-
-    fn global_histogram_vec(
-        &self,
-        name: &str,
-        help: &str,
-        variable_labels: &[&str],
-    ) -> Result<HistogramVec, PrometheusError> {
-        let opts = HistogramOpts::new(name, help);
-        let histograms = HistogramVec::new(opts, variable_labels)?;
-        Ok(histograms)
-    }
-}
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 8ff16764655..b08fae8e53e 100644
--- a/node/Cargo.toml
+++ b/node/Cargo.toml
@@ -13,35 +13,38 @@ name = "graphman"
 path = "src/bin/manager.rs"
 
 [dependencies]
-clap = { version = "3.2.23", features = ["derive", "env"] }
-env_logger = "0.9.3"
-git-testament = "0.2"
-graphql-parser = "0.4.0"
-futures = { version = "0.3.1", features = ["compat"] }
-lazy_static = "1.2.0"
-url = "2.3.1"
-crossbeam-channel = "0.5.5"
+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-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"] }
-serde_regex = "1.1.0"
-toml = "0.7.1"
-shellexpand = "2.1.0"
-termcolor = "1.2.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 13dc90ce7c1..1053c90e300 100644
--- a/node/src/bin/manager.rs
+++ b/node/src/bin/manager.rs
@@ -2,36 +2,40 @@ use clap::{Parser, Subcommand};
 use config::PoolSize;
 use git_testament::{git_testament, render_testament};
 use graph::bail;
-use graph::prelude::BLOCK_NUMBER_MAX;
-use graph::{data::graphql::effort::LoadManager, prelude::chrono, prometheus::Registry};
+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::{BLOCK_NUMBER_MAX, BlockNumber, MetricsRegistry};
+use graph::{data::graphql::load_manager::LoadManager, prelude::chrono, prometheus::Registry};
 use graph::{
-    log::logger,
     prelude::{
-        anyhow::{self, Context as AnyhowContextTrait},
-        info, o, slog, tokio, Logger, NodeId, ENV_VARS,
+        Logger, NodeId,
+        anyhow::{self, Context as AnyhowContextTrait, anyhow},
+        info, tokio,
     },
     url::Url,
 };
-use graph_chain_ethereum::{EthereumAdapter, EthereumNetworks};
-use graph_core::MetricsRegistry;
+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::HashMap, env, num::ParseIntError, sync::Arc, time::Duration};
+use std::env;
+use std::str::FromStr;
+use std::{collections::HashMap, num::ParseIntError, sync::Arc, time::Duration};
 const VERSION_LABEL_KEY: &str = "version";
 
 git_testament!(TESTAMENT);
@@ -48,6 +52,13 @@ lazy_static! {
     version = RENDERED_TESTAMENT.as_str()
 )]
 pub struct Opt {
+    #[clap(
+        long,
+        default_value = "off",
+        env = "GRAPHMAN_LOG",
+        help = "level for log output in slog format"
+    )]
+    pub log_level: String,
     #[clap(
         long,
         default_value = "auto",
@@ -77,6 +88,14 @@ pub struct Opt {
         help = "HTTP addresses of IPFS nodes\n"
     )]
     pub ipfs: Vec<String>,
+    #[clap(
+        long,
+        value_name = "{HOST:PORT|URL}",
+        default_value = "https://arweave.net",
+        env = "GRAPH_NODE_ARWEAVE_URL",
+        help = "HTTP base URL for arweave gateway"
+    )]
+    pub arweave: String,
     #[clap(
         long,
         default_value = "3",
@@ -87,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,
 }
@@ -122,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
     ///
@@ -151,25 +185,64 @@ pub enum Command {
         /// The deployment (see `help info`)
         deployment: DeploymentSearch,
     },
+    /// Pause a deployment
+    Pause {
+        /// The deployment (see `help info`)
+        deployment: DeploymentSearch,
+    },
+    /// Resume a deployment
+    Resume {
+        /// The deployment (see `help info`)
+        deployment: DeploymentSearch,
+    },
+    /// Pause and resume one or multiple deployments
+    Restart {
+        /// The deployment(s) (see `help info`)
+        deployments: Vec<DeploymentSearch>,
+        /// Sleep for this many seconds after pausing subgraphs
+        #[clap(
+            long,
+            short,
+            default_value = "20",
+            value_parser = parse_duration_in_secs
+        )]
+        sleep: Duration,
+    },
     /// Rewind a subgraph to a specific block
     Rewind {
         /// Force rewinding even if the block hash is not found in the local
         /// database
         #[clap(long, short)]
         force: bool,
+        /// Rewind to the start block of the subgraph
+        #[clap(long)]
+        start_block: bool,
         /// Sleep for this many seconds after pausing subgraphs
         #[clap(
             long,
             short,
-            default_value = "10",
-            parse(try_from_str = parse_duration_in_secs)
+            default_value = "20",
+            value_parser = parse_duration_in_secs
         )]
         sleep: Duration,
         /// The block hash of the target block
-        block_hash: String,
+        #[clap(
+            required_unless_present = "start_block",
+            conflicts_with = "start_block",
+            long,
+            short = 'H'
+        )]
+        block_hash: Option<String>,
         /// The block number of the target block
-        block_number: i32,
+        #[clap(
+            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)]
         deployments: Vec<DeploymentSearch>,
     },
     /// Deploy and run an arbitrary subgraph up to a certain block
@@ -234,42 +307,70 @@ pub enum Command {
     #[clap(subcommand)]
     Index(IndexCommand),
 
-    /// Prune deployments
-    Prune {
-        /// The deployment to prune (see `help info`)
-        deployment: DeploymentSearch,
-        /// Prune tables with a ratio of entities to entity versions lower than this
-        #[clap(long, short, default_value = "0.20")]
-        prune_ratio: f64,
-        /// How much history to keep in blocks
-        #[clap(long, short = 'y', default_value = "10000")]
-        history: usize,
-    },
+    /// 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.
+    #[clap(subcommand)]
+    Prune(PruneCommand),
 
     /// General database management
     #[clap(subcommand)]
     Database(DatabaseCommand),
 
-    /// Delete a deployment and all it's indexed data
+    /// Deploy a subgraph
+    Deploy {
+        name: DeploymentSearch,
+        deployment: DeploymentSearch,
+
+        /// The url of the graph-node
+        #[clap(long, short, default_value = "http://localhost:8020")]
+        url: String,
+    },
+
+    /// Dump a subgraph deployment into a directory
     ///
-    /// 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
+    /// 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,
-        /// 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)]
+        /// 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,
     },
 }
@@ -288,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,
@@ -343,20 +448,32 @@ 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
+    /// subgraph-specific settings. This command determines which settings
+    /// would apply when a subgraph <name> is deployed and prints the result
+    Setting {
+        /// The subgraph name for which to print settings
+        name: String,
+    },
 }
 
 #[derive(Clone, Debug, Subcommand)]
 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
@@ -433,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>,
@@ -550,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.
@@ -563,26 +782,30 @@ 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.
+        after: Option<i32>,
     },
     /// Lists existing indexes for a given Entity
     List {
@@ -603,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,
     },
 }
@@ -686,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()
+        }
     }
 }
 
@@ -701,6 +923,7 @@ struct Context {
     node_id: NodeId,
     config: Cfg,
     ipfs_url: Vec<String>,
+    arweave_url: String,
     fork_base: Option<Url>,
     registry: Arc<MetricsRegistry>,
     pub prometheus_registry: Arc<Registry>,
@@ -712,6 +935,7 @@ impl Context {
         node_id: NodeId,
         config: Cfg,
         ipfs_url: Vec<String>,
+        arweave_url: String,
         fork_base: Option<Url>,
         version_label: Option<String>,
     ) -> Self {
@@ -739,6 +963,7 @@ impl Context {
             fork_base,
             registry,
             prometheus_registry,
+            arweave_url,
         }
     }
 
@@ -760,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,
@@ -773,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> {
@@ -787,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
     }
 
@@ -815,13 +1033,13 @@ 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.registry,
+            self.fork_base.clone(),
+            self.registry.clone(),
         );
 
         for pool in pools.values() {
@@ -833,54 +1051,59 @@ impl Context {
             pools.clone(),
             subgraph_store,
             HashMap::default(),
-            vec![],
-        );
+            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![], registry.clone()));
+        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();
-        create_all_ethereum_networks(logger, registry, &self.config).await
+        let metrics = Arc::new(EndpointMetrics::mock());
+
+        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))
     }
 
@@ -888,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
@@ -904,16 +1139,19 @@ 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);
 
     let version_label = opt.version_label.clone();
     // Set up logger
-    let logger = match ENV_VARS.log_levels {
-        Some(_) => logger(false),
-        None => Logger::root(slog::Discard, o!()),
-    };
+    let logger = logger_with_levels(false, Some(&opt.log_level));
 
     // Log version information
     info!(
@@ -923,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() {
@@ -935,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,
@@ -969,13 +1206,14 @@ async fn main() -> anyhow::Result<()> {
         node,
         config,
         opt.ipfs,
+        opt.arweave,
         fork_base,
         version_label.clone(),
     );
 
     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,
@@ -983,36 +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,
             };
 
-            Ok(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,
+            };
+
+            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,
@@ -1021,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
                 }
             }
         }
@@ -1028,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)
                 }
@@ -1039,17 +1291,62 @@ async fn main() -> anyhow::Result<()> {
                     commands::config::provider(logger, &ctx.config, registry, features, network)
                         .await
                 }
+                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 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 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 { 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,
@@ -1057,16 +1354,21 @@ async fn main() -> anyhow::Result<()> {
             block_hash,
             block_number,
             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,
             )
             .await
         }
@@ -1083,6 +1385,7 @@ async fn main() -> anyhow::Result<()> {
             let store_builder = ctx.store_builder().await;
             let job_name = version_label.clone();
             let ipfs_url = ctx.ipfs_url.clone();
+            let arweave_url = ctx.arweave_url.clone();
             let metrics_ctx = MetricsContext {
                 prometheus: ctx.prometheus_registry.clone(),
                 registry: registry.clone(),
@@ -1095,6 +1398,8 @@ async fn main() -> anyhow::Result<()> {
                 store_builder,
                 network_name,
                 ipfs_url,
+                arweave_url,
+                opt.amp_flight_service_address.clone(),
                 config,
                 metrics_ctx,
                 node_id,
@@ -1107,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) => {
@@ -1128,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 {
@@ -1147,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 {
@@ -1160,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?;
@@ -1209,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 {
@@ -1218,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)
@@ -1233,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) => {
@@ -1243,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,
@@ -1254,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,
@@ -1264,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,
@@ -1278,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(
@@ -1290,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 {
@@ -1303,6 +1665,7 @@ async fn main() -> anyhow::Result<()> {
                     entity,
                     fields,
                     method,
+                    after,
                 } => {
                     commands::index::create(
                         subgraph_store,
@@ -1311,6 +1674,7 @@ async fn main() -> anyhow::Result<()> {
                         &entity,
                         fields,
                         method,
+                        after,
                     )
                     .await
                 }
@@ -1363,36 +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,
-            prune_ratio,
+            name,
+            url,
         } => {
-            let (store, primary_pool) = ctx.store_and_primary();
-            commands::prune::run(store, primary_pool, deployment, history, prune_ratio).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,
+            directory,
+        } => {
+            let (store, primary_pool) = ctx.store_and_primary().await;
+            let subgraph_store = store.subgraph_store();
+
+            commands::dump::run(subgraph_store, primary_pool, deployment, directory).await
+        }
+
+        Restore {
+            directory,
+            shard,
+            name,
+            replace,
+            add,
             force,
         } => {
-            let sender = ctx.notification_sender();
-            let (store, primary_pool) = ctx.store_and_primary();
+            let store = ctx.store().await;
             let subgraph_store = store.subgraph_store();
 
-            commands::drop::run(
-                primary_pool,
-                subgraph_store,
-                sender,
-                deployment,
-                current,
-                pending,
-                used,
-                force,
-            )
-            .await
+            commands::restore::run(subgraph_store, directory, shard, name, replace, add, force)
+                .await
         }
     }
 }
@@ -1400,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 426ee413341..824cbf5faeb 100644
--- a/node/src/chain.rs
+++ b/node/src/chain.rs
@@ -1,21 +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::firehose::{FirehoseEndpoint, FirehoseNetworks, SubgraphLimit};
-use graph::ipfs_client::IpfsClient;
-use graph::prelude::{anyhow, tokio};
-use graph::prelude::{prost, MetricsRegistry as MetricsRegistryTrait};
-use graph::slog::{debug, error, info, o, Logger};
+use graph::components::network_provider::ChainName;
+use graph::components::store::BlockStore as _;
+use graph::endpoint::EndpointMetrics;
+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::security::SafeDisplay;
-use graph_chain_ethereum::{self as ethereum, EthereumAdapterTrait, Transport};
-use std::collections::{BTreeMap, HashMap};
+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)]
@@ -30,128 +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,
-) -> 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();
+impl ChainFilter for AnyChainFilter {
+    fn filter(&self, _: &str) -> bool {
+        true
+    }
+}
 
-    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,
-                );
+pub struct OneChainFilter {
+    chain_name: String,
+}
 
-                let parsed_networks = networks_by_kind
-                    .entry(chain.protocol)
-                    .or_insert_with(FirehoseNetworks::new);
-
-                for i in 0..firehose.conn_pool_size {
-                    parsed_networks.insert(
-                        name.to_string(),
-                        Arc::new(FirehoseEndpoint::new(
-                            &format!("{}-{}", provider.label, i),
-                            &firehose.url,
-                            firehose.token.clone(),
-                            firehose.filters_enabled(),
-                            firehose.compression_enabled(),
-                            SubgraphLimit::Unlimited,
-                        )),
-                    );
-                }
-            }
-        }
+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,
-) -> BTreeMap<BlockchainKind, FirehoseNetworks> {
+    endpoint_metrics: Arc<EndpointMetrics>,
+    chain_filter: &dyn ChainFilter,
+) -> Vec<AdapterConfiguration> {
     debug!(
         logger,
         "Creating firehose networks [{} chains, ingestor {}]",
@@ -159,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
@@ -180,227 +117,94 @@ pub fn create_firehose_networks(
                 // eg: pool_size = 3 and sg_limit 2 will result in 3 separate instances
                 // of FirehoseEndpoint and each of those instance can be used in 2 different
                 // SubgraphInstances.
-                for i in 0..firehose.conn_pool_size {
-                    parsed_networks.insert(
-                        name.to_string(),
-                        Arc::new(FirehoseEndpoint::new(
-                            &format!("{}-{}", provider.label, i),
-                            &firehose.url,
-                            firehose.token.clone(),
-                            firehose.filters_enabled(),
-                            firehose.compression_enabled(),
-                            firehose.limit_for(&config.node),
-                        )),
-                    );
+                for _ in 0..firehose.conn_pool_size {
+                    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,
-) -> (EthereumNetworks, Vec<(String, Vec<ChainIdentifier>)>) {
-    // 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: HashMap<String, Vec<ChainIdentifier>> =
-        statuses
-            .into_iter()
-            .fold(HashMap::new(), |mut networks, status| {
-                match status {
-                    ProviderNetworkStatus::Broken {
-                        chain_id: network,
-                        provider,
-                    } => eth_networks.remove(&network, &provider),
-                    ProviderNetworkStatus::Version {
-                        chain_id: network,
-                        ident,
-                    } => networks.entry(network).or_default().push(ident),
-                }
-                networks
-            });
-    let idents: Vec<_> = idents.into_iter().collect();
-    (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,
-) -> (FirehoseNetworks, Vec<(String, Vec<ChainIdentifier>)>)
-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,
-                );
-                match tokio::time::timeout(
-                    NET_VERSION_WAIT_TIME,
-                    endpoint.genesis_block_ptr::<M>(&logger),
-                )
-                .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,
-                            "genesis_block" => format_args!("{}", &ptr),
-                        );
-
-                        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: HashMap<String, Vec<ChainIdentifier>> =
-        statuses
-            .into_iter()
-            .fold(HashMap::new(), |mut networks, status| {
-                match status {
-                    ProviderNetworkStatus::Broken { chain_id, provider } => {
-                        firehose_networks.remove(&chain_id, &provider)
-                    }
-                    ProviderNetworkStatus::Version { chain_id, ident } => {
-                        networks.entry(chain_id).or_default().push(ident)
-                    }
-                }
-                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
-    });
-
-    let idents: Vec<_> = idents.into_iter().collect();
-    (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<dyn MetricsRegistryTrait>,
+    registry: Arc<MetricsRegistry>,
     config: &Config,
-) -> anyhow::Result<EthereumNetworks> {
+    endpoint_metrics: Arc<EndpointMetrics>,
+    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, eth_rpc_metrics.clone(), config, name)
+            create_ethereum_networks_for_chain(
+                &logger,
+                eth_rpc_metrics.clone(),
+                config,
+                name,
+                endpoint_metrics.cheap_clone(),
+            )
         });
 
-    Ok(try_join_all(eth_networks_futures)
-        .await?
-        .into_iter()
-        .reduce(|mut a, b| {
-            a.extend(b);
-            a
-        })
-        .unwrap_or_else(EthereumNetworks::new))
+    try_join_all(eth_networks_futures).await
 }
 
 /// Parses a single Ethereum connection string and returns its network name and `EthereumAdapter`.
@@ -409,19 +213,24 @@ pub async fn create_ethereum_networks_for_chain(
     eth_rpc_metrics: Arc<ProviderEthRpcMetrics>,
     config: &Config,
     network_name: &str,
-) -> anyhow::Result<EthereumNetworks> {
-    let mut parsed_networks = EthereumNetworks::new();
+    endpoint_metrics: Arc<EndpointMetrics>,
+) -> 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),
-            _ => continue,
+            _ => {
+                continue;
+            }
         };
 
         let capabilities = web3.node_capabilities();
@@ -430,58 +239,217 @@ 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()),
+            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(
                     logger,
                     provider.label.clone(),
-                    &web3.url,
                     transport,
                     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;
-    use graph::prometheus::Registry;
+    use graph::prelude::MetricsRegistry;
     use graph_chain_ethereum::NodeCapabilities;
-    use graph_core::MetricsRegistry;
     use std::sync::Arc;
 
-    #[tokio::test]
+    #[graph::test]
     async fn correctly_parse_ethereum_networks() {
         let logger = logger(true);
 
@@ -504,17 +472,18 @@ mod test {
             unsafe_config: false,
         };
 
+        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 metrics_registry = Arc::new(MetricsRegistry::mock());
 
-        let ethereum_networks = create_all_ethereum_networks(logger, metrics_registry, &config)
+        let networks = Networks::from_config(logger, &config, metrics_registry, metrics, &[])
             .await
-            .expect("Correctly parse Ethereum network args");
-        let mut network_names = ethereum_networks.networks.keys().collect::<Vec<&String>>();
+            .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 {
@@ -526,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 b571ed88a7a..4c9b776e43a 100644
--- a/node/src/config.rs
+++ b/node/src/config.rs
@@ -1,27 +1,36 @@
 use graph::{
     anyhow::Error,
     blockchain::BlockchainKind,
-    firehose::{SubgraphLimit, SUBGRAPHS_PER_CONN},
+    components::{
+        network_provider::{AmpChainNames, ChainName},
+        store::BLOCK_CACHE_SIZE,
+    },
+    env::ENV_VARS,
+    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, 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 std::fs::read_to_string;
+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};
 use url::Url;
 
 const ANY_NAME: &str = ".*";
@@ -67,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<()> {
@@ -99,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()) {
@@ -111,7 +158,7 @@ impl Config {
             ));
         }
         for (key, shard) in self.stores.iter_mut() {
-            shard.validate(key)?;
+            shard.validate(key, &self.node)?;
         }
         self.deployment.validate()?;
 
@@ -151,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,
@@ -161,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)
     }
@@ -178,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,
         })
     }
 
@@ -222,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,
@@ -236,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));
@@ -288,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)
@@ -394,37 +535,116 @@ 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> {
+        self.chains
+            .values()
+            .flat_map(|chain| {
+                chain
+                    .providers
+                    .iter()
+                    .map(|p| p.label.clone())
+                    .collect::<Vec<String>>()
+            })
+            .collect()
     }
 
     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://")
@@ -462,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())
@@ -482,6 +702,9 @@ impl ChainSection {
                     shard: PRIMARY_SHARD.to_string(),
                     protocol: BlockchainKind::Ethereum,
                     providers: vec![],
+                    amp: None,
+                    cache_size: 0,
+                    settings: ChainSettings::default(),
                 });
                 entry.providers.push(provider);
             }
@@ -490,6 +713,112 @@ 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 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,
@@ -497,6 +826,22 @@ pub struct Chain {
     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 {
@@ -505,11 +850,22 @@ fn default_blockchain_kind() -> BlockchainKind {
 
 impl Chain {
     fn validate(&mut self) -> Result<()> {
-        // `Config` validates that `self.shard` references a configured shard
+        let mut labels = self.providers.iter().map(|p| &p.label).collect_vec();
+        labels.sort();
+        labels.dedup();
+        if labels.len() != self.providers.len() {
+            return Err(anyhow!("provider labels must be unique"));
+        }
 
+        // `Config` validates that `self.shard` references a configured shard
         for provider in self.providers.iter_mut() {
             provider.validate()?
         }
+
+        if self.protocol == BlockchainKind::Ethereum {
+            self.settings.validate()?;
+        }
+
         Ok(())
     }
 }
@@ -526,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)),
         );
     }
@@ -546,7 +902,6 @@ pub struct Provider {
 pub enum ProviderDetails {
     Firehose(FirehoseProvider),
     Web3(Web3Provider),
-    Substreams(FirehoseProvider),
     Web3Call(Web3Provider),
 }
 
@@ -563,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)]
@@ -651,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 {
@@ -664,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)
@@ -683,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
@@ -715,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;
@@ -814,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
@@ -867,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,
@@ -877,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::*;
@@ -946,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))
@@ -994,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(())
@@ -1014,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) {
@@ -1099,6 +1487,66 @@ fn default_node_id() -> NodeId {
     NodeId::new("default").unwrap()
 }
 
+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>,
+{
+    let millis = u64::deserialize(data)?;
+    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
@@ -1134,16 +1582,26 @@ where
 #[cfg(test)]
 mod tests {
 
-    use crate::config::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::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};
@@ -1179,6 +1637,9 @@ mod tests {
                 shard: "primary".to_string(),
                 protocol: BlockchainKind::Ethereum,
                 providers: vec![],
+                amp: None,
+                cache_size: 0,
+                settings: ChainSettings::default(),
             },
             actual
         );
@@ -1200,11 +1661,39 @@ mod tests {
                 shard: "primary".to_string(),
                 protocol: BlockchainKind::Near,
                 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(
@@ -1268,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]
@@ -1283,14 +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
-        );
+        assert!(err_str.contains("missing field `features`"), "{}", err_str);
     }
 
     #[test]
@@ -1359,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]
@@ -1380,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![],
@@ -1390,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(
@@ -1429,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![],
@@ -1447,7 +1922,7 @@ mod tests {
                 details = { type = "firehose", url = "http://localhost:9000" }
                 match = [
                   { name = "some_node_.*", limit = 10 },
-                  { name = "other_node_.*", limit = 0 } ] 
+                  { name = "other_node_.*", limit = 0 } ]
             "#,
         )
         .unwrap();
@@ -1458,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![
@@ -1478,152 +1954,37 @@ 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();
+        ).unwrap().validate();
+        assert!(actual.is_err(), "{:?}", actual);
 
-        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()};
+        if let Err(error) = actual {
+            assert!(
+                error
+                    .to_string()
+                    .starts_with("supported firehose endpoint filters are:")
+            )
+        }
     }
 
     #[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);
-
-        if let Err(error) = actual {
-            assert_eq!(
-                true,
-                error
-                    .to_string()
-                    .starts_with("supported firehose endpoint filters are:")
-            )
-        }
-    }
-
-    #[test]
-    fn it_parses_web3_provider_rules() {
-        fn limit_for(node: &str) -> SubgraphLimit {
-            let prov = toml::from_str::<Web3Provider>(
-                r#"
-            label = "something"
-            url = "http://example.com"
-            features = []
-            match = [ { name = "some_node_.*", limit = 10 },
-                      { name = "other_node_.*", limit = 0 } ]
-        "#,
-            )
-            .unwrap();
+    fn it_parses_web3_provider_rules() {
+        fn limit_for(node: &str) -> SubgraphLimit {
+            let prov = toml::from_str::<Web3Provider>(
+                r#"
+            label = "something"
+            url = "http://example.com"
+            features = []
+            match = [ { name = "some_node_.*", limit = 10 },
+                      { name = "other_node_.*", limit = 0 } ]
+        "#,
+            )
+            .unwrap();
 
             prov.limit_for(&NodeId::new(node.to_string()).unwrap())
         }
@@ -1689,4 +2050,744 @@ mod tests {
         assert!(SubgraphLimit::Unlimited > SubgraphLimit::Limit(10));
         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>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "vip"
+            provider = [
+                { label = "mainnet1", url = "http://127.0.0.1", features = [], headers = { Authorization = "Bearer foo" } },
+                { label = "mainnet1", url = "http://127.0.0.1", features = [ "archive", "traces" ] }
+            ]
+            "#,
+        )
+        .unwrap();
+
+        let err = actual.validate();
+        assert!(err.is_err());
+        let err = err.unwrap_err();
+        assert!(err.to_string().contains("unique"), "result: {:?}", err);
+    }
+
+    #[test]
+    fn duplicated_labels_are_allowed_on_different_chain() {
+        let mut actual = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "vip"
+            provider = [
+                { label = "mainnet1", url = "http://127.0.0.1", features = [], headers = { Authorization = "Bearer foo" } },
+                { label = "mainnet2", url = "http://127.0.0.1", features = [ "archive", "traces" ] }
+            ]
+            [mainnet2]
+            shard = "vip"
+            provider = [
+                { label = "mainnet1", url = "http://127.0.0.1", features = [], headers = { Authorization = "Bearer foo" } },
+                { label = "mainnet2", url = "http://127.0.0.1", features = [ "archive", "traces" ] }
+            ]
+            "#,
+        )
+        .unwrap();
+
+        let result = actual.validate();
+        assert!(result.is_ok(), "error: {:?}", result.unwrap_err());
+    }
+
+    #[test]
+    fn polling_interval() {
+        let default = default_polling_interval();
+        let different = 2 * default;
+
+        // Polling interval not set explicitly, use default
+        let actual = toml::from_str::<ChainSection>(
+            r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "vip"
+            provider = []"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            default,
+            actual
+                .chains
+                .get("mainnet")
+                .unwrap()
+                .settings
+                .polling_interval
+        );
+
+        // Polling interval set explicitly, use that
+        let actual = toml::from_str::<ChainSection>(
+            format!(
+                r#"
+            ingestor = "block_ingestor_node"
+            [mainnet]
+            shard = "vip"
+            provider = []
+            polling_interval = {}"#,
+                different.as_millis()
+            )
+            .as_str(),
+        )
+        .unwrap();
+
+        assert_eq!(
+            different,
+            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 2d4f8ca0f3b..a0fe189f1f7 100644
--- a/node/src/lib.rs
+++ b/node/src/lib.rs
@@ -1,18 +1,18 @@
 use std::sync::Arc;
 
-use graph::prometheus::Registry;
-use graph_core::MetricsRegistry;
+use graph::{prelude::MetricsRegistry, prometheus::Registry};
 
 #[macro_use]
 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 3fd4718ad21..652258c734d 100644
--- a/node/src/main.rs
+++ b/node/src/main.rs
@@ -1,977 +1,68 @@
 use clap::Parser as _;
-use ethereum::chain::{EthereumAdapterSelector, EthereumBlockRefetcher, EthereumStreamBuilder};
-use ethereum::codec::HeaderOnlyBlock;
-use ethereum::{
-    BlockIngestor as EthereumBlockIngestor, EthereumAdapterTrait, EthereumNetworks, RuntimeAdapter,
-};
-use git_testament::{git_testament, render_testament};
-use graph::blockchain::client::ChainClient;
-use graph::blockchain::firehose_block_ingestor::{FirehoseBlockIngestor, Transforms};
-use graph::blockchain::{Block as BlockchainBlock, Blockchain, BlockchainKind, BlockchainMap};
-use graph::components::store::BlockStore;
-use graph::data::graphql::effort::LoadManager;
-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_substreams as substreams;
+use git_testament::git_testament;
+use graph::{env::EnvVars, log::logger, prelude::*};
 use graph_core::polling_monitor::ipfs_service;
-use graph_core::{
-    LinkResolver, MetricsRegistry, 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 near::NearStreamBuilder;
-use std::collections::BTreeMap;
-use std::io::{BufRead, BufReader};
-use std::path::Path;
-use std::time::Duration;
-use std::{collections::HashMap, env};
-use tokio::sync::mpsc;
+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);
 }
 
-#[tokio::main]
-async fn main() {
+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 })
+}
+
+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,
-    };
-    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)
-            };
-
-            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");
+    let (prometheus_registry, metrics_registry) = launcher::setup_metrics(&logger);
 
-    // 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,
+        ipfs_client.cheap_clone(),
+        env_vars.mappings.max_ipfs_file_bytes,
+        env_vars.mappings.ipfs_timeout,
+        env_vars.mappings.ipfs_request_limit,
     );
 
-    // 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());
-
-    // Ethereum clients; query nodes ignore all ethereum clients and never
-    // connect to them directly
-    let eth_networks = if query_only {
-        EthereumNetworks::new()
-    } else {
-        create_all_ethereum_networks(logger.clone(), metrics_registry.clone(), &config)
-            .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)
-    };
-
-    let substreams_networks_by_kind = if query_only {
-        BTreeMap::new()
-    } else {
-        create_substreams_networks(logger.clone(), &config)
-    };
-
-    let graphql_metrics_registry = metrics_registry.clone();
+    let link_resolver = Arc::new(IpfsResolver::new(ipfs_client, env_vars.cheap_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();
-
-        let (arweave_networks, arweave_idents) = connect_firehose_networks::<ArweaveBlock>(
-            &logger,
-            firehose_networks_by_kind
-                .remove(&BlockchainKind::Arweave)
-                .unwrap_or_else(FirehoseNetworks::new),
-        )
-        .await;
-
-        let (eth_networks, 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;
-
-        let (cosmos_networks, cosmos_idents) = connect_firehose_networks::<CosmosFirehoseBlock>(
-            &logger,
-            firehose_networks_by_kind
-                .remove(&BlockchainKind::Cosmos)
-                .unwrap_or_else(FirehoseNetworks::new),
-        )
-        .await;
-
-        let network_identifiers = ethereum_idents
-            .into_iter()
-            .chain(arweave_idents)
-            .chain(near_idents)
-            .chain(cosmos_idents)
-            .collect();
-
-        let network_store = store_builder.network_store(network_identifiers);
-
-        let arweave_chains = arweave_networks_as_chains(
-            &mut blockchain_map,
-            &logger,
-            &arweave_networks,
-            network_store.as_ref(),
-            &logger_factory,
-            metrics_registry.clone(),
-        );
-
-        let ethereum_chains = ethereum_networks_as_chains(
-            &mut blockchain_map,
-            &logger,
-            node_id.clone(),
-            metrics_registry.clone(),
-            firehose_networks_by_kind.get(&BlockchainKind::Ethereum),
-            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 = near_networks_as_chains(
-            &mut blockchain_map,
-            &logger,
-            &near_networks,
-            network_store.as_ref(),
-            &logger_factory,
-            metrics_registry.clone(),
-        );
-
-        let cosmos_chains = cosmos_networks_as_chains(
-            &mut blockchain_map,
-            &logger,
-            &cosmos_networks,
-            network_store.as_ref(),
-            &logger_factory,
-            metrics_registry.clone(),
-        );
-
-        let blockchain_map = Arc::new(blockchain_map);
-
-        let load_manager = Arc::new(LoadManager::new(
-            &logger,
-            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 {
-            if !ethereum_chains.is_empty() {
-                let block_polling_interval = Duration::from_millis(opt.ethereum_polling_interval);
-                // Each chain contains both the rpc and firehose endpoints so provided
-                // IS_FIREHOSE_PREFERRED is set to true, a chain will use firehose if it has
-                // endpoints set but chains are essentially guaranteed to use EITHER firehose or RPC
-                // but will never start both.
-                let (firehose_eth_chains, polling_eth_chains): (HashMap<_, _>, HashMap<_, _>) =
-                    ethereum_chains
-                        .into_iter()
-                        .partition(|(_, chain)| chain.chain_client().is_firehose());
-
-                start_block_ingestor(
-                    &logger,
-                    &logger_factory,
-                    block_polling_interval,
-                    polling_eth_chains,
-                );
-
-                if let Some(eth_firehose_endpoints) =
-                    firehose_networks_by_kind.get(&BlockchainKind::Ethereum)
-                {
-                    start_firehose_block_ingestor::<_, HeaderOnlyBlock>(
-                        &logger,
-                        &network_store,
-                        firehose_eth_chains
-                            .into_iter()
-                            .map(|(name, chain)| {
-                                let firehose_endpoints = eth_firehose_endpoints
-                                    .networks
-                                    .get(&name)
-                                    .unwrap_or_else(|| panic!("chain {} to have endpoints", name))
-                                    .clone();
-                                (
-                                    name,
-                                    FirehoseChain {
-                                        chain,
-                                        firehose_endpoints,
-                                    },
-                                )
-                            })
-                            .collect(),
-                    )
-                }
-            }
-
-            start_firehose_block_ingestor::<_, ArweaveBlock>(
-                &logger,
-                &network_store,
-                arweave_chains,
-            );
-
-            start_firehose_block_ingestor::<_, NearFirehoseHeaderOnlyBlock>(
-                &logger,
-                &network_store,
-                near_chains,
-            );
-            start_firehose_block_ingestor::<_, CosmosFirehoseBlock>(
-                &logger,
-                &network_store,
-                cosmos_chains,
-            );
-
-            // 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 subgraph_instance_manager = SubgraphInstanceManager::new(
-            &logger_factory,
-            env_vars.cheap_clone(),
-            network_store.subgraph_store(),
-            blockchain_map.cheap_clone(),
-            metrics_registry.clone(),
-            link_resolver.clone(),
-            ipfs_service,
-            static_filters,
-        );
-
-        // Create IPFS-based subgraph provider
-        let subgraph_provider = IpfsSubgraphAssignmentProvider::new(
-            &logger_factory,
-            link_resolver.clone(),
-            subgraph_instance_manager,
-        );
-
-        // 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,
-        ));
-        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,
-                        )
-                        .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::<crossbeam_channel::Sender<()>>(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) = crossbeam_channel::bounded(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(crossbeam_channel::RecvTimeoutError::Timeout)
-        {
-            debug!(contention_logger, "Possible contention in tokio threadpool";
-                                     "timeout_ms" => timeout.as_millis(),
-                                     "code" => LogCode::TokioContention);
-            if timeout < Duration::from_secs(10) {
-                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 Arweave chains and also add them to `blockchain_map`.
-fn arweave_networks_as_chains(
-    blockchain_map: &mut BlockchainMap,
-    logger: &Logger,
-    firehose_networks: &FirehoseNetworks,
-    store: &Store,
-    logger_factory: &LoggerFactory,
-    metrics_registry: Arc<MetricsRegistry>,
-) -> HashMap<String, FirehoseChain<arweave::Chain>> {
-    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 Arweave chain {}; ignoring this chain", chain_id
-                    );
-                    None
-                })
-        })
-        .map(|(chain_id, chain_store, endpoints)| {
-            (
-                chain_id.clone(),
-                FirehoseChain {
-                    chain: Arc::new(arweave::Chain::new(
-                        logger_factory.clone(),
-                        chain_id.clone(),
-                        chain_store,
-                        endpoints.clone(),
-                        metrics_registry.clone(),
-                    )),
-                    firehose_endpoints: endpoints.clone(),
-                },
-            )
-        })
-        .collect();
-
-    for (chain_id, firehose_chain) in chains.iter() {
-        blockchain_map.insert::<arweave::Chain>(chain_id.clone(), firehose_chain.chain.clone())
-    }
-
-    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,
-    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(),
-            });
-
-            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,
-                ethereum::ENV_VARS.reorg_threshold,
-                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)
-}
-
-fn cosmos_networks_as_chains(
-    blockchain_map: &mut BlockchainMap,
-    logger: &Logger,
-    firehose_networks: &FirehoseNetworks,
-    store: &Store,
-    logger_factory: &LoggerFactory,
-    metrics_registry: Arc<MetricsRegistry>,
-) -> HashMap<String, FirehoseChain<cosmos::Chain>> {
-    let chains: Vec<_> = firehose_networks
-        .networks
-        .iter()
-        .filter_map(|(network_name, firehose_endpoints)| {
-            store
-                .block_store()
-                .chain_store(network_name)
-                .map(|chain_store| (network_name, chain_store, firehose_endpoints))
-                .or_else(|| {
-                    error!(
-                        logger,
-                        "No store configured for Cosmos chain {}; ignoring this chain",
-                        network_name
-                    );
-                    None
-                })
-        })
-        .map(|(network_name, chain_store, firehose_endpoints)| {
-            (
-                network_name.clone(),
-                FirehoseChain {
-                    chain: Arc::new(cosmos::Chain::new(
-                        logger_factory.clone(),
-                        network_name.clone(),
-                        chain_store,
-                        firehose_endpoints.clone(),
-                        metrics_registry.clone(),
-                    )),
-                    firehose_endpoints: firehose_endpoints.clone(),
-                },
-            )
-        })
-        .collect();
-
-    for (network_name, firehose_chain) in chains.iter() {
-        blockchain_map.insert::<cosmos::Chain>(network_name.clone(), firehose_chain.chain.clone())
-    }
-
-    HashMap::from_iter(chains)
-}
-
-/// Return the hashmap of NEAR chains and also add them to `blockchain_map`.
-fn near_networks_as_chains(
-    blockchain_map: &mut BlockchainMap,
-    logger: &Logger,
-    firehose_networks: &FirehoseNetworks,
-    store: &Store,
-    logger_factory: &LoggerFactory,
-    metrics_registry: Arc<MetricsRegistry>,
-) -> HashMap<String, FirehoseChain<near::Chain>> {
-    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 NEAR chain {}; ignoring this chain", chain_id
-                    );
-                    None
-                })
-        })
-        .map(|(chain_id, chain_store, endpoints)| {
-            (
-                chain_id.clone(),
-                FirehoseChain {
-                    chain: Arc::new(near::Chain::new(
-                        logger_factory.clone(),
-                        chain_id.clone(),
-                        chain_store,
-                        endpoints.clone(),
-                        metrics_registry.clone(),
-                        Arc::new(NearStreamBuilder {}),
-                    )),
-                    firehose_endpoints: endpoints.clone(),
-                },
-            )
-        })
-        .collect();
-
-    for (chain_id, firehose_chain) in chains.iter() {
-        blockchain_map
-            .insert::<graph_chain_near::Chain>(chain_id.clone(), firehose_chain.chain.clone())
-    }
-
-    HashMap::from_iter(chains)
-}
-
-fn start_block_ingestor(
-    logger: &Logger,
-    logger_factory: &LoggerFactory,
-    block_polling_interval: Duration,
-    chains: HashMap<String, Arc<ethereum::Chain>>,
-) {
-    info!(
-        logger,
-        "Starting block ingestors with {} chains [{}]",
-        chains.len(),
-        chains.keys().cloned().collect::<Vec<String>>().join(", ")
-    );
-
-    // Create Ethereum block ingestors and spawn a thread to run each
-    chains
-        .iter()
-        .filter(|(network_name, chain)| {
-            if !chain.is_ingestible {
-                error!(logger, "Not starting block ingestor (chain is defective)"; "network_name" => &network_name);
-            }
-            chain.is_ingestible
-        })
-        .for_each(|(network_name, chain)| {
-            info!(
-                logger,
-                "Starting block ingestor for network";
-                "network_name" => &network_name
-            );
-
-            let eth_adapter = chain.cheapest_adapter();
-                let logger = logger_factory
-                    .component_logger(
-                        "BlockIngestor",
-                        Some(ComponentLoggerConfig {
-                            elastic: Some(ElasticComponentLoggerConfig {
-                                index: String::from("block-ingestor-logs"),
-                            }),
-                        }),
-                    )
-                    .new(o!("provider" => eth_adapter.provider().to_string()));
-
-            // The block ingestor must be configured to keep at least REORG_THRESHOLD ancestors,
-            // because the json-rpc BlockStream expects blocks after the reorg threshold to be
-            // present in the DB.
-            let block_ingestor = EthereumBlockIngestor::new(
-                logger,
-                ethereum::ENV_VARS.reorg_threshold,
-                eth_adapter,
-                chain.chain_store(),
-                block_polling_interval,
-            )
-            .expect("failed to create Ethereum block ingestor");
-
-            // Run the Ethereum block ingestor in the background
-            graph::spawn(block_ingestor.into_polling_stream());
-        });
-}
-
-#[derive(Clone)]
-struct FirehoseChain<C: Blockchain> {
-    chain: Arc<C>,
-    firehose_endpoints: FirehoseEndpoints,
-}
-
-fn start_firehose_block_ingestor<C, M>(
-    logger: &Logger,
-    store: &Store,
-    chains: HashMap<String, FirehoseChain<C>>,
-) where
-    C: Blockchain,
-    M: prost::Message + BlockchainBlock + Default + 'static,
-{
-    info!(
-        logger,
-        "Starting firehose block ingestors with {} chains [{}]",
-        chains.len(),
-        chains.keys().cloned().collect::<Vec<String>>().join(", ")
-    );
-
-    // Create Firehose block ingestors and spawn a thread to run each
-    chains
-        .iter()
-        .for_each(|(network_name, chain)| {
-            info!(
-                logger,
-                "Starting firehose block ingestor for network";
-                "network_name" => &network_name
-            );
-
-            let endpoint = chain
-                .firehose_endpoints
-                .random()
-                .expect("One Firehose endpoint should exist at that execution point");
-
-            match store.block_store().chain_store(network_name.as_ref()) {
-                Some(s) => {
-                    let mut block_ingestor = FirehoseBlockIngestor::<M>::new(
-                        s,
-                        endpoint.clone(),
-                        logger.new(o!("component" => "FirehoseBlockIngestor", "provider" => endpoint.provider.clone())),
-                    );
-
-                    if C::KIND == BlockchainKind::Ethereum {
-                        block_ingestor = block_ingestor.with_transforms(vec![Transforms::EthereumHeaderOnly]);
-                    }
-
-                    // Run the Firehose block ingestor in the background
-                    graph::spawn(block_ingestor.run());
-                },
-                None => {
-                    error!(logger, "Not starting firehose block ingestor (no chain store available)"; "network_name" => &network_name);
-                }
-            }
-        });
 }
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 aa045a1357f..3787145fb29 100644
--- a/node/src/manager/commands/assign.rs
+++ b/node/src/manager/commands/assign.rs
@@ -1,7 +1,8 @@
-use graph::prelude::{anyhow::anyhow, Error, NodeId, StoreEvent};
-use graph_store_postgres::{
-    command_support::catalog, connection_pool::ConnectionPool, NotificationSender,
-};
+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;
 
@@ -10,53 +11,122 @@ 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).await?.len();
+    if count == 1 {
+        println!("warning: this is the only deployment assigned to {node}");
+        println!("         are you sure it is spelled correctly?");
+    }
+    Ok(())
+}
+
+pub async fn pause_or_resume(
+    primary: ConnectionPool,
+    sender: &NotificationSender,
+    locator: &DeploymentLocator,
+    should_pause: bool,
+) -> Result<(), Error> {
+    let pconn = primary.get_permitted().await?;
+    let mut conn = catalog::Connection::new(pconn);
+
+    let site = conn
+        .locate_site(locator.clone())
+        .await?
+        .ok_or_else(|| anyhow!("failed to locate site for {locator}"))?;
+
+    let change = match conn.assignment_status(&site).await? {
+        Some((_, is_paused)) => {
+            if should_pause {
+                if is_paused {
+                    println!("deployment {locator} is already paused");
+                    return Ok(());
+                }
+                println!("pausing {locator}");
+                conn.pause_subgraph(&site).await?
+            } else {
+                println!("resuming {locator}");
+                conn.resume_subgraph(&site).await?
+            }
+        }
+        None => {
+            println!("deployment {locator} not found");
+            return Ok(());
+        }
+    };
+    println!("Operation completed");
+    conn.send_store_event(sender, &StoreEvent::new(change))
+        .await?;
+
+    Ok(())
+}
+
+pub async fn restart(
+    primary: ConnectionPool,
+    sender: &NotificationSender,
+    locator: &DeploymentLocator,
+    sleep: Duration,
+) -> Result<(), Error> {
+    pause_or_resume(primary.clone(), sender, locator, true).await?;
+    println!(
+        "Waiting {}s to make sure pausing was processed",
+        sleep.as_secs()
+    );
+    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 5d2f65714c3..d7014bd4b1c 100644
--- a/node/src/manager/commands/check_blocks.rs
+++ b/node/src/manager/commands/check_blocks.rs
@@ -1,10 +1,14 @@
 use crate::manager::prompt::prompt_for_confirmation;
 use graph::{
     anyhow::{bail, ensure},
-    components::store::ChainStore as ChainStoreTrait,
+    cheap_clone::CheapClone,
+    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,
 };
@@ -19,7 +23,7 @@ pub async fn by_hash(
     logger: &Logger,
 ) -> anyhow::Result<()> {
     let block_hash = helpers::parse_block_hash(hash)?;
-    run(&block_hash, &chain_store, ethereum_adapter, logger).await
+    run(&block_hash, chain_store, ethereum_adapter, logger).await
 }
 
 pub async fn by_number(
@@ -29,11 +33,11 @@ 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),
-        [block_hash] => run(block_hash, &chain_store, ethereum_adapter, logger).await,
+        [block_hash] => run(block_hash, chain_store, ethereum_adapter, logger).await,
         &block_hashes => {
             handle_multiple_block_hashes(number, block_hashes, &chain_store, delete_duplicates)
                 .await
@@ -53,17 +57,26 @@ 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] => run(block_hash, &chain_store, ethereum_adapter, logger).await?,
+            [block_hash] => {
+                run(
+                    block_hash,
+                    chain_store.cheap_clone(),
+                    ethereum_adapter,
+                    logger,
+                )
+                .await?
+            }
             &block_hashes => {
                 handle_multiple_block_hashes(
                     block_number,
@@ -78,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
@@ -90,29 +103,31 @@ 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,
-    chain_store: &ChainStore,
+    block_hash: &B256,
+    chain_store: Arc<ChainStore>,
     ethereum_adapter: &EthereumAdapter,
     logger: &Logger,
 ) -> anyhow::Result<()> {
-    let cached_block = steps::fetch_single_cached_block(*block_hash, chain_store)?;
+    let cached_block =
+        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<()> {
@@ -128,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!(
@@ -143,73 +158,86 @@ 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())
     }
 
     /// Queries the [`ChainStore`] for a cached block given a block hash.
     ///
     /// Errors on a non-unary result.
-    pub(super) fn fetch_single_cached_block(
-        block_hash: H256,
-        chain_store: &ChainStore,
-    ) -> anyhow::Result<Value> {
-        let blocks = chain_store.blocks(&[block_hash.into()])?;
+    pub(super) async fn fetch_single_cached_block(
+        block_hash: B256,
+        chain_store: Arc<ChainStore>,
+    ) -> 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 {
@@ -227,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}");
@@ -237,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 561a1da013e..35ee9ed573a 100644
--- a/node/src/manager/commands/config.rs
+++ b/node/src/manager/commands/config.rs
@@ -1,19 +1,22 @@
 use std::{collections::BTreeMap, sync::Arc};
 
+use graph::components::network_provider::ChainName;
 use graph::{
-    anyhow::bail,
-    components::metrics::MetricsRegistry,
+    anyhow::{Context, bail},
+    components::subgraph::{Setting, Settings},
+    endpoint::EndpointMetrics,
+    env::EnvVars,
     itertools::Itertools,
     prelude::{
-        anyhow::{anyhow, Error},
-        NodeId,
+        MetricsRegistry, NodeId, SubgraphName,
+        anyhow::{Error, anyhow},
     },
     slog::Logger,
 };
-use graph_chain_ethereum::{EthereumAdapterTrait, 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))? {
@@ -39,13 +42,27 @@ pub fn check(config: &Config, print: bool) -> Result<(), Error> {
         Ok(txt) => {
             if print {
                 println!("{}", txt);
-            } else {
-                println!("Successfully validated configuration");
+                return Ok(());
             }
-            Ok(())
         }
-        Err(e) => Err(anyhow!("error serializing config: {}", e)),
+        Err(e) => bail!("error serializing config: {}", e),
     }
+
+    let env_vars = EnvVars::from_env().unwrap();
+    if let Some(path) = &env_vars.subgraph_settings {
+        match Settings::from_file(path) {
+            Ok(_) => {
+                println!("Successfully validated subgraph settings from {path}");
+            }
+            Err(e) => {
+                eprintln!("configuration error in subgraph settings {}: {}", path, e);
+                std::process::exit(1);
+            }
+        }
+    };
+
+    println!("Successfully validated configuration");
+    Ok(())
 }
 
 pub fn pools(config: &Config, nodes: Vec<String>, shard: bool) -> Result<(), Error> {
@@ -55,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
@@ -100,7 +117,7 @@ pub fn pools(config: &Config, nodes: Vec<String>, shard: bool) -> Result<(), Err
 pub async fn provider(
     logger: Logger,
     config: &Config,
-    registry: Arc<dyn MetricsRegistry>,
+    registry: Arc<MetricsRegistry>,
     features: String,
     network: String,
 ) -> Result<(), Error> {
@@ -120,15 +137,13 @@ pub async fn provider(
         Ok(caps)
     }
 
+    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).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,
@@ -140,3 +155,25 @@ pub async fn provider(
     );
     Ok(())
 }
+
+pub fn setting(name: &str) -> Result<(), Error> {
+    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)
+            .with_context(|| format!("syntax error in subgraph settings `{}`", path))?;
+        match settings.for_name(&name) {
+            Some(Setting { history_blocks, .. }) => {
+                println!("setting for `{name}` will use history_blocks = {history_blocks}");
+            }
+            None => {
+                println!("no specific setting for `{name}`, defaults will be used");
+            }
+        }
+    } else {
+        println!("No subgraph-specific settings will be applied because");
+        println!("GRAPH_EXPERIMENTAL_SUBGRAPH_SETTINGS is not set");
+    };
+
+    Ok(())
+}
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
new file mode 100644
index 00000000000..603d09b63ca
--- /dev/null
+++ b/node/src/manager/commands/deploy.rs
@@ -0,0 +1,101 @@
+use std::sync::Arc;
+
+use graph::prelude::{
+    SubgraphName, SubgraphStore,
+    anyhow::{Result, anyhow, bail},
+    reqwest,
+    serde_json::{Value, json},
+};
+
+use crate::manager::deployment::DeploymentSearch;
+
+// Function to send an RPC request and handle errors
+async fn send_rpc_request(url: &str, payload: Value) -> Result<()> {
+    let client = reqwest::Client::new();
+    let response = client.post(url).json(&payload).send().await?;
+
+    if response.status().is_success() {
+        Ok(())
+    } else {
+        Err(response
+            .error_for_status()
+            .expect_err("Failed to parse error response")
+            .into())
+    }
+}
+
+// Function to send subgraph_create request
+async fn send_create_request(name: &str, url: &str) -> Result<()> {
+    // Construct the JSON payload for subgraph_create
+    let create_payload = json!({
+        "jsonrpc": "2.0",
+        "method": "subgraph_create",
+        "params": {
+            "name": name,
+        },
+        "id": "1"
+    });
+
+    // Send the subgraph_create request
+    send_rpc_request(url, create_payload)
+        .await
+        .map_err(|e| e.context(format!("Failed to create subgraph with name `{}`", name)))
+}
+
+// Function to send subgraph_deploy request
+async fn send_deploy_request(name: &str, deployment: &str, url: &str) -> Result<()> {
+    // Construct the JSON payload for subgraph_deploy
+    let deploy_payload = json!({
+        "jsonrpc": "2.0",
+        "method": "subgraph_deploy",
+        "params": {
+            "name": name,
+            "ipfs_hash": deployment,
+        },
+        "id": "1"
+    });
+
+    // Send the subgraph_deploy request
+    send_rpc_request(url, deploy_payload).await.map_err(|e| {
+        e.context(format!(
+            "Failed to deploy subgraph `{}` to `{}`",
+            deployment, name
+        ))
+    })
+}
+pub async fn run(
+    subgraph_store: Arc<impl SubgraphStore>,
+    deployment: DeploymentSearch,
+    search: DeploymentSearch,
+    url: String,
+) -> Result<()> {
+    let hash = match deployment {
+        DeploymentSearch::Hash { hash, shard: _ } => hash,
+        _ => bail!("The `deployment` argument must be a valid IPFS hash"),
+    };
+
+    let name = match search {
+        DeploymentSearch::Name { name } => name,
+        _ => bail!("The `name` must be a valid subgraph name"),
+    };
+
+    let subgraph_name =
+        SubgraphName::new(name.clone()).map_err(|_| anyhow!("Invalid subgraph name"))?;
+
+    let exists = subgraph_store.subgraph_exists(&subgraph_name).await?;
+
+    if !exists {
+        println!("Creating subgraph `{}`", name);
+
+        // Send the subgraph_create request
+        send_create_request(&name, &url).await?;
+        println!("Subgraph `{}` created", name);
+    }
+
+    // Send the subgraph_deploy request
+    println!("Deploying subgraph `{}` to `{}`", hash, name);
+    send_deploy_request(&name, &hash, &url).await?;
+    println!("Subgraph `{}` deployed to `{}`", name, url);
+
+    Ok(())
+}
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 ee6e66d5fa8..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() {
@@ -24,25 +25,51 @@ fn validate_fields<T: AsRef<str>>(fields: &[T]) -> Result<(), anyhow::Error> {
     }
     Ok(())
 }
+
+/// `after` allows for the creation of a partial index
+/// starting from a specified block number. This can improve
+/// performance for queries that are close to the subgraph head.
 pub async fn create(
     store: Arc<SubgraphStore>,
     pool: ConnectionPool,
     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, entity_name, field_names, index_method)
+        .create_manual_index(
+            &deployment_locator,
+            entity_name,
+            field_names,
+            index_method,
+            after,
+        )
         .await
     {
-        Ok(()) => Ok(()),
+        Ok(()) => {
+            println!("Index creation completed.",);
+            Ok(())
+        }
         Err(StoreError::Canceled) => {
             eprintln!("Index creation attempt failed. Please retry.");
             ::std::process::exit(1);
@@ -90,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::*;
 
@@ -144,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)
@@ -161,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;
@@ -185,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 8fb9c7ab4c3..2b65fde8006 100644
--- a/node/src/manager/commands/listen.rs
+++ b/node/src/manager/commands/listen.rs
@@ -1,71 +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 futures::future;
+use graph::futures03::{StreamExt, future};
+
 use graph::{
-    components::store::{EntityType, SubscriptionManager as _},
-    prelude::{serde_json, Error, Stream, SubscriptionFilter},
+    components::store::SubscriptionManager as _,
+    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> {
-    let locator = search.locate_unique(&primary_pool)?;
-    let filter = entity_types
-        .into_iter()
-        .map(|et| SubscriptionFilter::Entities(locator.hash.clone(), EntityType::new(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 de7267da828..9e5ba8e0b95 100644
--- a/node/src/manager/commands/mod.rs
+++ b/node/src/manager/commands/mod.rs
@@ -5,13 +5,16 @@ pub mod config;
 pub mod copy;
 pub mod create;
 pub mod database;
-pub mod drop;
+pub mod deploy;
+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 41e6754188b..82f4387dd4d 100644
--- a/node/src/manager/commands/prune.rs
+++ b/node/src/manager/commands/prune.rs
@@ -5,26 +5,36 @@ use std::{
     time::{Duration, Instant},
 };
 
+use graph::{
+    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::{
+    ConnectionPool, Store,
+    command_support::{Phase, PruneTableState},
 };
-use graph_chain_ethereum::ENV_VARS as ETH_ENV;
-use graph_store_postgres::{connection_pool::ConnectionPool, Store};
+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 {
     start: Instant,
     analyze_start: Instant,
     switch_start: Instant,
+    switch_time: Duration,
     table_start: Instant,
-    final_start: Instant,
-    nonfinal_start: Instant,
+    table_rows: usize,
+    initial_analyze: bool,
 }
 
 impl Progress {
@@ -33,9 +43,10 @@ impl Progress {
             start: Instant::now(),
             analyze_start: Instant::now(),
             switch_start: Instant::now(),
-            final_start: Instant::now(),
+            switch_time: Duration::from_secs(0),
             table_start: Instant::now(),
-            nonfinal_start: Instant::now(),
+            table_rows: 0,
+            initial_analyze: true,
         }
     }
 }
@@ -46,10 +57,22 @@ fn print_copy_header() {
     std::io::stdout().flush().ok();
 }
 
-fn print_copy_row(table: &str, total_rows: usize, elapsed: Duration) {
+fn print_batch(
+    table: &str,
+    total_rows: usize,
+    elapsed: Duration,
+    phase: PrunePhase,
+    finished: bool,
+) {
+    let phase = match (finished, phase) {
+        (true, _) => "          ",
+        (false, PrunePhase::CopyFinal) => "(final)",
+        (false, PrunePhase::CopyNonfinal) => "(nonfinal)",
+        (false, PrunePhase::Delete) => "(delete)",
+    };
     print!(
-        "\r{:<30} | {:>10} | {:>9}s",
-        abbreviate_table_name(table, 30),
+        "\r{:<30} | {:>10} | {:>9}s {phase}",
+        fmt::abbreviate(table, 30),
         total_rows,
         elapsed.as_secs()
     );
@@ -57,7 +80,14 @@ fn print_copy_row(table: &str, total_rows: usize, elapsed: Duration) {
 }
 
 impl PruneReporter for Progress {
+    fn start(&mut self, req: &PruneRequest) {
+        println!("Prune to {} historical blocks", req.history_blocks);
+    }
+
     fn start_analyze(&mut self) {
+        if !self.initial_analyze {
+            println!();
+        }
         print!("Analyze tables");
         self.analyze_start = Instant::now();
     }
@@ -67,89 +97,89 @@ impl PruneReporter for Progress {
         std::io::stdout().flush().ok();
     }
 
-    fn finish_analyze(&mut self, stats: &[graph::components::store::VersionStats]) {
+    fn finish_analyze(
+        &mut self,
+        stats: &[graph::components::store::VersionStats],
+        analyzed: &[&str],
+    ) {
+        let stats: Vec<_> = stats
+            .iter()
+            .filter(|stat| self.initial_analyze || analyzed.contains(&stat.tablename.as_str()))
+            .cloned()
+            .collect();
         println!(
-            "\rAnalyzed {} tables in {}s",
-            stats.len(),
-            self.analyze_start.elapsed().as_secs()
+            "\rAnalyzed {} tables in {}s{: ^30}",
+            analyzed.len(),
+            self.analyze_start.elapsed().as_secs(),
+            ""
         );
-        show_stats(stats, HashSet::new()).ok();
+        show_stats(stats.as_slice(), HashSet::new()).ok();
         println!();
-    }
-
-    fn copy_final_start(&mut self, earliest_block: BlockNumber, final_block: BlockNumber) {
-        println!("Copy final entities (versions live between {earliest_block} and {final_block})");
-        print_copy_header();
 
-        self.final_start = Instant::now();
-        self.table_start = self.final_start;
+        if self.initial_analyze {
+            // After analyzing, we start the actual work
+            println!("Pruning tables");
+            print_copy_header();
+        }
+        self.initial_analyze = false;
     }
 
-    fn copy_final_batch(&mut self, table: &str, _rows: usize, total_rows: usize, finished: bool) {
-        print_copy_row(table, total_rows, self.table_start.elapsed());
-        if finished {
-            println!();
-            self.table_start = Instant::now();
-        }
-        std::io::stdout().flush().ok();
+    fn start_table(&mut self, _table: &str) {
+        self.table_start = Instant::now();
+        self.table_rows = 0
     }
 
-    fn copy_final_finish(&mut self) {
-        println!(
-            "Finished copying final entity versions in {}s\n",
-            self.final_start.elapsed().as_secs()
+    fn prune_batch(&mut self, table: &str, rows: usize, phase: PrunePhase, finished: bool) {
+        self.table_rows += rows;
+        print_batch(
+            table,
+            self.table_rows,
+            self.table_start.elapsed(),
+            phase,
+            finished,
         );
+        std::io::stdout().flush().ok();
     }
 
     fn start_switch(&mut self) {
-        println!("Blocking writes and switching tables");
-        print_copy_header();
         self.switch_start = Instant::now();
     }
 
     fn finish_switch(&mut self) {
-        println!(
-            "Enabling writes. Switching took {}s\n",
-            self.switch_start.elapsed().as_secs()
-        );
+        self.switch_time += self.switch_start.elapsed();
     }
 
-    fn copy_nonfinal_start(&mut self, table: &str) {
-        print_copy_row(table, 0, Duration::from_secs(0));
-        self.nonfinal_start = Instant::now();
+    fn finish_table(&mut self, _table: &str) {
+        println!();
     }
 
-    fn copy_nonfinal_batch(
-        &mut self,
-        table: &str,
-        _rows: usize,
-        total_rows: usize,
-        finished: bool,
-    ) {
-        print_copy_row(table, total_rows, self.table_start.elapsed());
-        if finished {
-            println!();
-            self.table_start = Instant::now();
-        }
-        std::io::stdout().flush().ok();
+    fn finish(&mut self) {
+        println!(
+            "Finished pruning in {}s. Writing was blocked for {}s",
+            self.start.elapsed().as_secs(),
+            self.switch_time.as_secs()
+        );
     }
+}
 
-    fn finish_prune(&mut self) {
-        println!("Finished pruning in {}s", self.start.elapsed().as_secs());
-    }
+struct Args {
+    history: BlockNumber,
+    deployment: DeploymentLocator,
+    earliest_block: BlockNumber,
+    latest_block: BlockNumber,
 }
 
-pub async fn run(
-    store: Arc<Store>,
+async fn check_args(
+    store: &Arc<Store>,
     primary_pool: ConnectionPool,
     search: DeploymentSearch,
     history: usize,
-    prune_ratio: f64,
-) -> 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 {
@@ -162,31 +192,247 @@ 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,
+    })
+}
+
+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
+    );
 
-    println!("prune {deployment}");
-    println!("    latest: {latest}");
-    println!("     final: {}", latest - ETH_ENV.reorg_threshold);
-    println!("  earliest: {}\n", latest - history);
+    let mut req = PruneRequest::new(
+        &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;
+    }
+    if let Some(delete_threshold) = delete_threshold {
+        req.delete_threshold = delete_threshold;
+    }
 
     let reporter = Box::new(Progress::new());
+
     store
         .subgraph_store()
-        .prune(
-            reporter,
-            &deployment,
-            latest - history,
-            // Using the setting for eth chains is a bit lazy; the value
-            // should really depend on the chain, but we don't have a
-            // convenient way to figure out how each chain deals with
-            // finality
-            ETH_ENV.reorg_threshold,
-            prune_ratio,
-        )
+        .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(&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 0e9a6515d11..57937200839 100644
--- a/node/src/manager/commands/query.rs
+++ b/node/src/manager/commands/query.rs
@@ -1,25 +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::prelude::r;
+use graph::log::escape_control_chars;
+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>,
@@ -32,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| {
@@ -65,7 +64,10 @@ pub async fn run(
 
     if let Some(output) = output {
         let mut f = File::create(output)?;
-        let json = serde_json::to_string(&res)?;
+
+        // Escape control characters in the query output, as a precaution against injecting control
+        // characters in a terminal.
+        let json = escape_control_chars(serde_json::to_string(&res)?);
         writeln!(f, "{}", json)?;
     }
 
@@ -73,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 b370fa34b0f..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 {}",
@@ -59,74 +67,133 @@ pub async fn run(
     primary: ConnectionPool,
     store: Arc<Store>,
     searches: Vec<DeploymentSearch>,
-    block_hash: String,
-    block_number: BlockNumber,
+    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(());
     }
 
-    let block_ptr_to = block_ptr(
-        block_store,
-        &searches,
-        &deployments,
-        &block_hash,
-        block_number,
-        force,
-    )
-    .await?;
+    let block_ptr_to = if start_block {
+        None
+    } else {
+        Some(
+            block_ptr(
+                block_store,
+                &locators,
+                &searches,
+                block_hash.as_deref().unwrap_or_default(),
+                block_number.unwrap_or_default(),
+                force,
+            )
+            .await?,
+        )
+    };
 
-    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 10s to make sure pausing was processed");
-        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();
-        subgraph_store.rewind(loc.hash.clone(), block_ptr_to.clone())?;
-        println!("  ... rewound {}", loc);
+    for (chain, loc) in &locators {
+        let block_store = store.block_store();
+        let deployment_details = subgraph_store
+            .load_deployment_by_id(loc.clone().into())
+            .await?;
+        let block_ptr_to = block_ptr_to.clone();
+
+        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.id.into(), block_ptr).await?;
+                println!("  ... rewound {}", loc);
+            }
+            (None, Some(start_block_ptr)) => {
+                subgraph_store
+                    .truncate(loc.id.into(), start_block_ptr)
+                    .await?;
+                println!("  ... truncated {}", loc);
+            }
+            (None, None) => {
+                println!("  ... Failed to find start block for {}", loc);
+            }
+        }
     }
 
     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 2e3e1fa53d9..bbe9e1faf18 100644
--- a/node/src/manager/commands/run.rs
+++ b/node/src/manager/commands/run.rs
@@ -2,37 +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::store::{BlockStore as _, DeploymentLocator};
+use graph::components::link_resolver::{ArweaveClient, FileSizeLimit};
+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,
-    SubgraphName, SubgraphRegistrar, SubgraphStore, SubgraphVersionSwitchingMode, ENV_VARS,
-};
-use graph::slog::{debug, info, Logger};
-use graph_chain_ethereum as ethereum;
-use graph_core::polling_monitor::ipfs_service;
-use graph_core::{
-    LinkResolver, SubgraphAssignmentProvider as IpfsSubgraphAssignmentProvider,
-    SubgraphInstanceManager, SubgraphRegistrar as IpfsSubgraphRegistrar,
+    BlockNumber, DeploymentHash, ENV_VARS, IpfsResolver, LoggerFactory, NodeId,
+    SubgraphCountMetric, SubgraphName, SubgraphRegistrar, SubgraphStore,
+    SubgraphVersionSwitchingMode, anyhow, tokio,
 };
+use graph::slog::{Logger, debug, info};
+use graph_core::polling_monitor::{arweave_service, ipfs_service};
+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()),
@@ -43,8 +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,
@@ -56,128 +52,176 @@ 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_request_limit,
+        match env_vars.mappings.max_ipfs_file_bytes {
+            0 => FileSizeLimit::Unlimited,
+            n => FileSizeLimit::MaxBytes(n as u64),
+        },
+    );
+
+    let endpoint_metrics = Arc::new(EndpointMetrics::new(
+        logger.clone(),
+        &config.chains.providers(),
+        metrics_registry.cheap_clone(),
+    ));
+
     // 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)
-            .await
-            .expect("Failed to parse Ethereum networks");
-    let firehose_networks_by_kind = create_firehose_networks(logger.clone(), &config);
-    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 = 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),
-        }),
-        ethereum::ENV_VARS.reorg_threshold,
-        // 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 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),
+            );
 
-    let blockchain_map = Arc::new(blockchain_map);
-    let subgraph_instance_manager = SubgraphInstanceManager::new(
+            Some(amp_client)
+        }
+        None => None,
+    };
+
+    let subgraph_instance_manager = graph_core::subgraph::SubgraphInstanceManager::new(
         &logger_factory,
         env_vars.cheap_clone(),
         subgraph_store.clone(),
         blockchain_map.clone(),
+        sg_metrics.cheap_clone(),
         metrics_registry.clone(),
         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,
+        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(':') {
@@ -213,13 +257,16 @@ pub async fn run(
         None,
         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;
@@ -242,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 1f8d7474df5..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.namespace)?;
+    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 9720b546a1b..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 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 fn lookup_with_conn(&self, conn: &PgConnection) -> Result<Vec<Deployment>, anyhow::Error> {
+    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,59 +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!["synced", "health", "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.synced.to_string(),
-                    status.health.as_str().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 321cf47b0cd..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,37 +77,46 @@ 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(
+        long,
+        value_name = "{HOST:PORT|URL}",
+        default_value = "https://arweave.net",
+        env = "GRAPH_NODE_ARWEAVE_URL",
+        help = "HTTP base URL for arweave gateway"
+    )]
+    pub arweave: String,
     #[clap(
         long,
         default_value = "8000",
@@ -123,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",
@@ -164,36 +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 = "MILLISECONDS",
-        default_value = "1000",
-        env = "ETHEREUM_POLLING_INTERVAL",
-        help = "How often to poll the Ethereum node for new blocks"
-    )]
-    pub ethereum_polling_interval: u64,
     #[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 a0b145bf41b..fb3737e5b89 100644
--- a/node/src/store_builder.rs
+++ b/node/src/store_builder.rs
@@ -1,21 +1,19 @@
 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,
-    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};
@@ -27,8 +25,10 @@ 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>,
 }
 
 impl StoreBuilder {
@@ -40,7 +40,7 @@ impl StoreBuilder {
         node: &NodeId,
         config: &Config,
         fork_base: Option<Url>,
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
     ) -> Self {
         let primary_shard = config.primary_store().clone();
 
@@ -62,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(
@@ -84,6 +84,7 @@ impl StoreBuilder {
             chain_head_update_listener,
             chains,
             coord,
+            registry,
         }
     }
 
@@ -95,7 +96,7 @@ impl StoreBuilder {
         node: &NodeId,
         config: &Config,
         fork_base: Option<Url>,
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
     ) -> (
         Arc<SubgraphStore>,
         HashMap<ShardName, ConnectionPool>,
@@ -110,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,
@@ -137,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();
 
@@ -159,47 +175,53 @@ 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: Vec<(String, Vec<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 block_store = Arc::new(
-            DieselBlockStore::new(
-                logger,
-                networks,
-                pools,
-                subgraph_store.notification_sender(),
-            )
-            .expect("Creating the BlockStore works"),
-        );
+        let chain_store_metrics = Arc::new(ChainStoreMetrics::new(registry));
+        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,
         name: &str,
         shard: &Shard,
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
         coord: Arc<PoolCoordinator>,
     ) -> ConnectionPool {
         let logger = logger.new(o!("pool" => "main"));
@@ -221,7 +243,7 @@ impl StoreBuilder {
         coord.create_pool(
             &logger,
             name,
-            PoolName::Main,
+            PoolRole::Main,
             shard.connection.clone(),
             pool_size,
             Some(fdw_pool_size),
@@ -235,7 +257,7 @@ impl StoreBuilder {
         node: &NodeId,
         name: &str,
         shard: &Shard,
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
         coord: Arc<PoolCoordinator>,
     ) -> (Vec<ConnectionPool>, Vec<usize>) {
         let mut weights: Vec<_> = vec![shard.weight];
@@ -261,7 +283,7 @@ impl StoreBuilder {
                     coord.clone().create_pool(
                         &logger,
                         name,
-                        PoolName::Replica(pool),
+                        PoolRole::Replica(pool),
                         replica.connection.clone(),
                         pool_size,
                         None,
@@ -275,14 +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: Vec<(String, Vec<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 c78a5441897..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.51"
-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 d01644fae55..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::DeterministicHostError> {
-                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 3d59fd08d46..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::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::DeterministicHostError> {
-
-                    #(#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 8e2a56725c2..783596feb40 100644
--- a/runtime/test/Cargo.toml
+++ b/runtime/test/Cargo.toml
@@ -4,16 +4,14 @@ 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]
 test-store = { path = "../../store/test-store" }
-graph-mock = { path = "../../mock" }
diff --git a/runtime/test/README.md b/runtime/test/README.md
index c55561780f3..7beeb342351 100644
--- a/runtime/test/README.md
+++ b/runtime/test/README.md
@@ -1,6 +1,6 @@
 # Runtime tests
 
-These are the unit tests that check if the WASM runtime code is working. For now we only run code compiled from the [`AssemblyScript`](https://www.assemblyscript.org/) language, which is done by [`asc`](https://github.com/AssemblyScript/assemblyscript) (the AssemblyScript Compiler) in our [`CLI`](https://github.com/graphprotocol/graph-cli).
+These are the unit tests that check if the WASM runtime code is working. For now we only run code compiled from the [`AssemblyScript`](https://www.assemblyscript.org/) language, which is done by [`asc`](https://github.com/AssemblyScript/assemblyscript) (the AssemblyScript Compiler) in our [`CLI`](https://github.com/graphprotocol/graph-tooling/tree/main/packages/cli).
 
 We support two versions of their compiler/language for now:
 
diff --git a/runtime/test/src/common.rs b/runtime/test/src/common.rs
index 50360e2a7d2..b08251c8604 100644
--- a/runtime/test/src/common.rs
+++ b/runtime/test/src/common.rs
@@ -1,19 +1,20 @@
-use ethabi::Contract;
-use graph::components::store::DeploymentLocator;
+use graph::blockchain::BlockTime;
+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") {
@@ -27,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"),
@@ -56,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,
@@ -72,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": [
@@ -83,8 +93,7 @@ fn mock_abi() -> MappingABI {
                 ],
                 "type": "constructor"
             }
-        ]"#
-            .as_bytes(),
+        ]"#,
         )
         .unwrap(),
     }
@@ -95,13 +104,14 @@ 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 {
             hash: Default::default(),
             number: 0,
         },
+        timestamp: BlockTime::NONE,
         host_exports: Arc::new(mock_host_exports(
             deployment.hash.clone(),
             data_source,
@@ -109,12 +119,20 @@ pub fn mock_context(
             api_version,
         )),
         state: BlockState::new(
-            futures03::executor::block_on(store.writable(LOGGER.clone(), deployment.id)).unwrap(),
+            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!()),
+        instrument: false,
     }
 }
 
@@ -128,6 +146,7 @@ pub fn mock_data_source(path: &str, api_version: Version) -> DataSource {
         network: Some(String::from("mainnet")),
         address: Some(Address::from_str("0123123123012312312301231231230123123123").unwrap()),
         start_block: 0,
+        end_block: None,
         mapping: Mapping {
             kind: String::from("ethereum/events"),
             api_version,
diff --git a/runtime/test/src/test.rs b/runtime/test/src/test.rs
index 500bf83fb51..14af4d0f8e3 100644
--- a/runtime/test/src/test.rs
+++ b/runtime/test/src/test.rs
@@ -1,20 +1,28 @@
-use graph::data::store::scalar;
+use async_trait::async_trait;
+use graph::blockchain::BlockTime;
+use graph::components::metrics::gas::GasMetrics;
+use graph::components::store::*;
+use graph::data::store::{Id, IdType, scalar};
 use graph::data::subgraph::*;
-use graph::prelude::web3::types::U256;
-use graph::prelude::*;
-use graph::runtime::{AscIndexId, AscType};
+use graph::data::value::Word;
+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::{components::store::*, ipfs_client::IpfsClient};
-use graph_chain_ethereum::{Chain, DataSource};
-use graph_mock::MockMetricsRegistry;
+use graph::schema::{EntityType, InputSchema};
+use graph::{entity, prelude::*};
+use graph_chain_ethereum::DataSource;
 use graph_runtime_wasm::asc_abi::class::{Array, AscBigInt, AscEntity, AscString, Uint8Array};
-use graph_runtime_wasm::{ExperimentalFeatures, ValidModule, WasmInstance};
-
+use graph_runtime_wasm::{
+    ExperimentalFeatures, MappingContext, ValidModule, WasmInstance, host_exports,
+};
 use semver::Version;
 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};
 
@@ -37,231 +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(MockMetricsRegistry::new());
-    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,
-        }
+) -> 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());
+
+        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,
+            }
+
+            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 gas_metrics = GasMetrics::new(deployment_id.clone(), metrics_registry.clone());
+
+        let host_metrics = Arc::new(HostMetrics::new(
+            metrics_registry,
+            deployment_id.as_str(),
+            stopwatch.cheap_clone(),
+            gas_metrics,
+        ));
 
-        type Thing @entity {
-            id: ID!,
-            value: String,
-            extra: String
-        }",
-    )
-    .await;
-    let stopwatch_metrics = StopwatchMetrics::new(
-        logger.clone(),
-        deployment_id.clone(),
-        "test",
-        metrics_registry.clone(),
-    );
-    let host_metrics = Arc::new(HostMetrics::new(
-        metrics_registry,
-        deployment_id.as_str(),
-        stopwatch_metrics,
-    ));
-
-    let experimental_features = ExperimentalFeatures {
-        allow_non_deterministic_ipfs: true,
-    };
+        let experimental_features = ExperimentalFeatures {
+            allow_non_deterministic_ipfs: true,
+        };
 
-    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 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, store.subgraph_store(), deployment)
+        (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>;
+        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>;
 }
 
-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(())
+#[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()
     }
 }
@@ -279,40 +368,46 @@ 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!(
         scalar::BigInt::from_str(number).unwrap(),
-        scalar::BigInt::from_signed_bytes_le(&bytes)
+        scalar::BigInt::from_signed_bytes_le(&bytes).unwrap()
     );
 
     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) {
@@ -326,175 +421,164 @@ async fn test_json_parsing(api_version: Version, gas_used: u64) {
     )
     .await;
 
+    // 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).await;
+
+    let output: String = module.asc_get(return_value).unwrap();
+    assert_eq!(output, "OK: foo, ERROR: false");
+    assert_eq!(module.gas_used(), gas_used);
+
     // 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 valid JSON and get it back
-    let s = "\"foo\""; // Valid because there are quotes around `foo`
+    // 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, "OK: foo, ERROR: false");
-    assert_eq!(module.gas_used(), gas_used);
+    assert_eq!(output, "ERROR: true");
 }
 
-#[tokio::test]
+#[graph::test]
 async fn json_parsing_v0_0_4() {
-    test_json_parsing(API_VERSION_0_0_4, 2722284).await;
+    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, 3862933).await;
+    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) {
-    let mut data = Entity::new();
-    data.set("id", id);
-    data.set("value", value);
-    data.set("extra", USER_DATA);
-    let key = EntityKey::data("Thing".to_string(), id);
+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, vid: vid };
+    let key = THING_TYPE.parse_key(id).unwrap();
     (
         format!("{{ \"id\": \"{}\", \"value\": \"{}\"}}", id, value),
-        EntityModification::Insert { key, data },
+        EntityModification::insert(key, data, 0),
     )
 }
 
 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()?
-            .modifications;
-
-        // Bring the modifications into a predictable order (by entity_id)
-        mods.sort_by(|a, b| {
-            a.entity_ref()
-                .entity_id
-                .partial_cmp(&b.entity_ref().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(),
@@ -506,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."),
         "{:#}",
@@ -521,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(),
@@ -558,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;
 }
@@ -627,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),
@@ -635,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()),
@@ -657,37 +711,68 @@ 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);
+}
+
+#[graph::test]
+async fn test_big_int_size_limit() {
+    let mut module = test_module(
+        "BigIntSizeLimit",
+        mock_data_source(
+            &wasm_file_path("big_int_size_limit.wasm", API_VERSION_0_0_5),
+            API_VERSION_0_0_5,
+        ),
+        API_VERSION_0_0_5,
+    )
+    .await;
+
+    let len = BigInt::MAX_BITS / 8;
+    module
+        .invoke_export1_val_void("bigIntWithLength", len)
+        .await
+        .unwrap();
+
+    let len = BigInt::MAX_BITS / 8 + 1;
+    let err = module
+        .invoke_export1_val_void("bigIntWithLength", len)
+        .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) {
@@ -704,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()),
@@ -766,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,
@@ -779,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,
@@ -800,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;
 }
@@ -837,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."
@@ -850,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()),
@@ -861,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) {
@@ -893,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()),
@@ -924,13 +1027,11 @@ async fn test_entity_store(api_version: Version) {
     )
     .await;
 
-    let mut alex = Entity::new();
-    alex.set("id", "alex");
-    alex.set("name", "Alex");
-    let mut steve = Entity::new();
-    steve.set("id", "steve");
-    steve.set("name", "Steve");
-    let user_type = EntityType::from("User");
+    let schema = store.input_schema(&deployment.hash).await.unwrap();
+
+    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,
         vec![(user_type.clone(), alex), (user_type, steve)],
@@ -938,62 +1039,75 @@ 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 {
-            Some(Entity::from(
-                module
-                    .asc_get::<HashMap<String, Value>, _>(entity_ptr)
+            Some(
+                schema
+                    .make_entity(
+                        module
+                            .asc_get::<HashMap<Word, Value>, _>(entity_ptr)
+                            .unwrap(),
+                    )
                     .unwrap(),
-            ))
+            )
         }
     };
 
-    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).await.unwrap();
+    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().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()
+        .as_modifications(0, &STOPWATCH)
+        .await
         .unwrap()
         .modifications;
     assert_eq!(1, mods.len());
@@ -1002,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;
 }
@@ -1021,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()),
@@ -1061,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`
@@ -1074,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()),
@@ -1085,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()),
@@ -1105,56 +1222,635 @@ 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()
+        );
+    }
+}
+
+#[graph::test]
+async fn recursion_limit() {
+    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`");
+
+    let err = module
+        .invoke_export1_val_void("recursionLimit", 129)
+        .await
+        .unwrap_err();
+    assert!(
+        format!("{err:?}").contains("recursion limit reached"),
+        "{}",
+        err.to_string()
+    );
+}
+
+struct Host {
+    ctx: MappingContext,
+    host_exports: host_exports::test_support::HostExports,
+    stopwatch: StopwatchMetrics,
+    gas: GasCounter,
+}
+
+impl Host {
+    async fn new(
+        schema: &str,
+        deployment_hash: &str,
+        wasm_file: &str,
+        api_version: Option<Version>,
+    ) -> Host {
+        let version = api_version.unwrap_or(ENV_VARS.mappings.max_api_version.clone());
+        let wasm_file = wasm_file_path(wasm_file, API_VERSION_0_0_5);
+
+        let ds = mock_data_source(&wasm_file, version.clone());
+
+        let store = STORE.clone();
+        let deployment = DeploymentHash::new(deployment_hash.to_string()).unwrap();
+        let deployment = test_store::create_test_subgraph(&deployment, schema).await;
+        let ctx = mock_context(deployment.clone(), ds, store.subgraph_store(), version);
+        let host_exports = host_exports::test_support::HostExports::new(&ctx);
+
+        let metrics_registry: Arc<MetricsRegistry> = Arc::new(MetricsRegistry::mock());
+        let stopwatch = StopwatchMetrics::new(
+            ctx.logger.clone(),
+            deployment.hash.clone(),
+            "test",
+            metrics_registry.clone(),
+            "test_shard".to_string(),
+        );
+        let gas_metrics = GasMetrics::new(deployment.hash.clone(), metrics_registry);
+
+        let gas = GasCounter::new(gas_metrics);
+
+        Host {
+            ctx,
+            host_exports,
+            stopwatch,
+            gas,
+        }
+    }
+
+    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).await
+    }
+
+    async fn store_setv(
+        &mut self,
+        entity_type: &str,
+        id: &str,
+        data: Vec<(&str, Value)>,
+    ) -> 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,
+                &self.ctx.proof_of_indexing,
+                entity_type.to_string(),
+                id,
+                data,
+                &self.stopwatch,
+                &self.gas,
+            )
+            .await
+    }
+
+    async fn store_get(
+        &mut self,
+        entity_type: &str,
+        id: &str,
+    ) -> 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,
+            )
+            .await
+    }
+}
+
+#[track_caller]
+fn err_says<E: std::fmt::Debug + std::fmt::Display>(err: E, exp: &str) {
+    let err = err.to_string();
+    assert!(err.contains(exp), "expected `{err}` to contain `{exp}`");
+}
+
+/// Test the various ways in which `store_set` sets the `id` of entities and
+/// errors when there are issues
+#[graph::test]
+async fn test_store_set_id() {
+    const UID: &str = "u1";
+    const USER: &str = "User";
+    const BID: &str = "0xdeadbeef";
+    const BINARY: &str = "Binary";
+
+    let schema = "type User @entity {
+        id: ID!,
+        name: String,
+    }
+
+    type Binary @entity {
+        id: Bytes!,
+        name: String,
+    }";
+
+    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).await.unwrap().unwrap();
+    assert_eq!(
+        "u1",
+        entity.id().to_string(),
+        "store.set sets id automatically"
+    );
+
+    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,
+        "Attribute `User.id` has wrong type: expected String but got Bytes",
+    );
+
+    host.store_setv(USER, UID, vec![("id", Value::Int(32))])
+        .await
+        .expect_err("id must be a string");
+
+    //
+    // Now for bytes id
+    //
+    let bid_bytes = Value::Bytes(BID.parse().unwrap());
+
+    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,
+        "Attribute `Binary.id` has wrong type: expected Bytes but got String",
+    );
+
+    host.store_setv(
+        BINARY,
+        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).await.unwrap().unwrap();
+    assert_eq!(
+        BID,
+        entity.id().to_string(),
+        "store.set sets id automatically"
+    );
+
+    let err = host
+        .store_setv(BINARY, BID, vec![("id", Value::Int(32))])
+        .await
+        .expect_err("id must be Bytes");
+    err_says(
+        err,
+        "Attribute `Binary.id` has wrong type: expected Bytes but got Int",
+    );
+}
+
+/// Test setting fields that are not defined in the schema
+/// This should return an error
+#[graph::test]
+async fn test_store_set_invalid_fields() {
+    const UID: &str = "u1";
+    const USER: &str = "User";
+    let schema = "
+    type User @entity {
+        id: ID!,
+        name: String
+    }
+
+    type Binary @entity {
+        id: Bytes!,
+        test: String,
+        test2: String
+    }";
+
+    let mut host = Host::new(
+        schema,
+        "hostStoreSetInvalidFields",
+        "boolean.wasm",
+        Some(API_VERSION_0_0_8),
+    )
+    .await;
+
+    host.store_set(USER, UID, vec![("id", "u1"), ("name", "user1")])
+        .await
+        .unwrap();
+
+    let err = host
+        .store_set(
+            USER,
+            UID,
+            vec![
+                ("id", "u1"),
+                ("name", "user1"),
+                ("test", "invalid_field"),
+                ("test2", "invalid_field"),
+            ],
+        )
+        .await
+        .err()
+        .unwrap();
+
+    // The order of `test` and `test2` is not guranteed
+    // So we just check the string contains them
+    let err_string = err.to_string();
+    assert!(err_string.contains("Attempted to set undefined fields [test, test2] for the entity type `User`. Make sure those fields are defined in the schema."));
+
+    let err = host
+        .store_set(
+            USER,
+            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.",
+    );
+
+    // For apiVersion below 0.0.8, we should not error out
+    let mut host2 = Host::new(
+        schema,
+        "hostStoreSetInvalidFields",
+        "boolean.wasm",
+        Some(API_VERSION_0_0_7),
+    )
+    .await;
+
+    let err_is_none = host2
+        .store_set(
+            USER,
+            UID,
+            vec![
+                ("id", "u1"),
+                ("name", "user1"),
+                ("test", "invalid_field"),
+                ("test2", "invalid_field"),
+            ],
+        )
+        .await
+        .err()
+        .is_none();
+
+    assert!(err_is_none);
+}
+
+/// Test generating ids through `store_set`
+#[graph::test]
+async fn generate_id() {
+    const AUTO: &str = "auto";
+    const INT8: &str = "Int8";
+    const BINARY: &str = "Binary";
+
+    let schema = "type Int8 @entity(immutable: true) {
+        id: Int8!,
+        name: String,
+    }
+
+    type Binary @entity(immutable: true) {
+        id: Bytes!,
+        name: String,
+    }";
+
+    let mut host = Host::new(schema, "hostGenerateId", "boolean.wasm", None).await;
+
+    // Since these entities are immutable, storing twice would generate an
+    // error; but since the ids are autogenerated, each invocation creates a
+    // 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, &STOPWATCH)
+        .await
+        .unwrap()
+        .modifications;
+    let id_map: HashMap<&str, Id> = HashMap::from_iter(
+        vec![
+            (
+                "bin1",
+                IdType::Bytes.parse("0x0000000c00000002".into()).unwrap(),
+            ),
+            (
+                "bin2",
+                IdType::Bytes.parse("0x0000000c00000003".into()).unwrap(),
+            ),
+            ("int1", Id::Int8(0x0000_000c_0000_0000)),
+            ("int2", Id::Int8(0x0000_000c_0000_0001)),
+        ]
+        .into_iter(),
+    );
+    assert_eq!(4, mods.len());
+    for m in &mods {
+        match m {
+            EntityModification::Insert { data, .. } => {
+                let id = data.get("id").unwrap();
+                let name = data.get("name").unwrap().as_str().unwrap();
+                let exp = id_map.get(name).unwrap();
+                assert_eq!(exp, id, "Wrong id for entity with name `{name}`");
+            }
+            _ => panic!("expected Insert modification"),
+        }
+    }
+}
+
+#[graph::test]
+async fn test_store_intf() {
+    const UID: &str = "u1";
+    const USER: &str = "User";
+    const PERSON: &str = "Person";
+
+    let schema = "type User implements Person @entity {
+        id: String!,
+        name: String,
+    }
+
+    interface Person {
+        id: String!,
+        name: String,
+    }";
+
+    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");
+}
+
+#[graph::test]
+async fn test_store_ts() {
+    const DATA: &str = "Data";
+    const STATS: &str = "Stats";
+    const SID: &str = "1";
+    const DID: &str = "fe";
+
+    let schema = r#"
+    type Data @entity(timeseries: true) {
+        id: Int8!
+        timestamp: Timestamp!
+        amount: BigDecimal!
     }
+
+    type Stats @aggregation(intervals: ["hour"], source: "Data") {
+        id: Int8!
+        timestamp: Timestamp!
+        max: BigDecimal! @aggregate(fn: "max", arg:"amount")
+    }"#;
+
+    let mut host = Host::new(schema, "hostStoreTs", "boolean.wasm", None).await;
+
+    let block_time = host.ctx.timestamp;
+    let other_time = BlockTime::since_epoch(7000, 0);
+    // If this fails, something is wrong with the test setup
+    assert_ne!(block_time, other_time);
+
+    let b20 = Value::BigDecimal(20.into());
+
+    host.store_setv(
+        DATA,
+        DID,
+        vec![
+            ("timestamp", Value::from(other_time)),
+            ("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.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,
+        "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,
+        "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 274d44395fc..bd1b2de04d9 100644
--- a/runtime/test/src/test/abi.rs
+++ b/runtime/test/src/test/abi.rs
@@ -1,17 +1,13 @@
-use graph::prelude::{ethabi::Token, web3::types::U256};
-use graph_runtime_wasm::{
-    asc_abi::class::{
-        ArrayBuffer, AscAddress, AscEnum, AscEnumArray, EthereumValueKind, StoreValueKind,
-        TypedArray,
-    },
-    TRAP_TIMEOUT,
+use graph::{abi, prelude::alloy::primitives::Address};
+use graph_runtime_wasm::asc_abi::class::{
+    ArrayBuffer, AscAddress, AscEnum, AscEnumArray, EthereumValueKind, StoreValueKind, TypedArray,
 };
 
 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()),
@@ -22,22 +18,32 @@ async fn test_unbounded_loop(api_version: Version) {
     )
     .await
     .0;
-    let res: Result<(), _> = module.get_func("loop").typed().unwrap().call(());
-    assert!(res.unwrap_err().to_string().contains(TRAP_TIMEOUT));
+    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()),
@@ -46,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;
 }
@@ -78,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);
@@ -94,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) {
@@ -116,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;
 }
@@ -145,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();
@@ -155,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(),
@@ -177,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()),
@@ -273,52 +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;
+    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)])
@@ -328,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![
@@ -340,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))
+        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;
 }
@@ -374,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;
 }
@@ -409,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;
 }
@@ -436,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;
 }
@@ -476,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()),
@@ -502,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;
@@ -521,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 85da8f3fa9d..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,20 +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, DeterministicHostError> {
+        ) -> 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,
             })
         }
@@ -173,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, DeterministicHostError> {
+        ) -> 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,
             })
@@ -189,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()),
@@ -266,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(),
@@ -289,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()),
@@ -299,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 69e67eab20a..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
@@ -11,6 +11,8 @@ enum ValueKind {
     NULL = 5,
     BYTES = 6,
     BIG_INT = 7,
+    INT8 = 8,
+    TIMESTAMP = 9,
 }
 
 // Big enough to fit any pointer or native `this.data`.
@@ -43,6 +45,20 @@ 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;
+    value.data = int as i64
+    return value
+}
+
 export function value_from_big_decimal(float: BigInt): Value {
     let value = new Value();
     value.kind = ValueKind.BIG_DECIMAL;
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 635271b6f39..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 4a2a58b99d7..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
@@ -15,6 +15,20 @@ export function value_from_int(int: i32): Value {
     return value
 }
 
+export function value_from_int8(int: i64): Value {
+    let value = new Value();
+    value.kind = ValueKind.INT8;
+    value.data = int as i64
+    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();
     value.kind = ValueKind.BIG_DECIMAL;
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 5ac9f91d55d..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/big_int_size_limit.ts b/runtime/test/wasm_test/api_version_0_0_5/big_int_size_limit.ts
new file mode 100644
index 00000000000..33700277740
--- /dev/null
+++ b/runtime/test/wasm_test/api_version_0_0_5/big_int_size_limit.ts
@@ -0,0 +1,33 @@
+export * from './common/global'
+import { Entity, BigDecimal, Value, BigInt } from './common/types'
+
+/** Definitions copied from graph-ts/index.ts */
+declare namespace store {
+  function get(entity: string, id: string): Entity | null
+  function set(entity: string, id: string, data: Entity): void
+  function remove(entity: string, id: string): void
+}
+
+/** Host interface for BigInt arithmetic */
+declare namespace bigInt {
+  function plus(x: BigInt, y: BigInt): BigInt
+  function minus(x: BigInt, y: BigInt): BigInt
+  function times(x: BigInt, y: BigInt): BigInt
+  function dividedBy(x: BigInt, y: BigInt): BigInt
+  function dividedByDecimal(x: BigInt, y: BigDecimal): BigDecimal
+  function mod(x: BigInt, y: BigInt): BigInt
+}
+
+/**
+ * Test functions
+ */
+export function bigIntWithLength(bytes: u32): void {
+  let user = new Entity();
+  user.set("id", Value.fromString("jhon"));
+
+  let array = new Uint8Array(bytes);
+  array.fill(127);
+  let big_int = changetype<BigInt>(array);
+  user.set("count", Value.fromBigInt(big_int));
+  store.set("User", "jhon", user);
+}
diff --git a/runtime/test/wasm_test/api_version_0_0_5/big_int_size_limit.wasm b/runtime/test/wasm_test/api_version_0_0_5/big_int_size_limit.wasm
new file mode 100644
index 00000000000..400e92bc0a5
Binary files /dev/null and b/runtime/test/wasm_test/api_version_0_0_5/big_int_size_limit.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 73a6189c13b..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,6 +30,8 @@ export enum ValueKind {
   NULL = 5,
   BYTES = 6,
   BIG_INT = 7,
+  INT8 = 8,
+  TIMESTAMP = 9
 }
 // Big enough to fit any pointer or native `this.data`.
 export type Payload = u64
@@ -72,12 +74,12 @@ export class Value {
   }
 
   toBigInt(): BigInt {
-    assert(this.kind == ValueKind.BIGINT, 'Value is not a BigInt.')
+    assert(this.kind == ValueKind.BIG_INT, 'Value is not a BigInt.')
     return changetype<BigInt>(this.data as u32)
   }
 
   toBigDecimal(): BigDecimal {
-    assert(this.kind == ValueKind.BIGDECIMAL, 'Value is not a BigDecimal.')
+    assert(this.kind == ValueKind.BIG_DECIMAL, 'Value is not a BigDecimal.')
     return changetype<BigDecimal>(this.data as u32)
   }
 
@@ -197,8 +199,8 @@ export class Value {
 
   static fromBigInt(n: BigInt): Value {
     let value = new Value()
-    value.kind = ValueKind.BIGINT
-    value.data = n as u64
+    value.kind = ValueKind.BIG_INT
+    value.data = changetype<u32>(n) as u64
     return value
   }
 
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/recursion_limit.ts b/runtime/test/wasm_test/api_version_0_0_5/recursion_limit.ts
new file mode 100644
index 00000000000..0781475e234
--- /dev/null
+++ b/runtime/test/wasm_test/api_version_0_0_5/recursion_limit.ts
@@ -0,0 +1,19 @@
+export * from './common/global';
+
+import { Entity, Value } from './common/types'
+
+declare namespace store {
+    function get(entity: string, id: string): Entity | null
+    function set(entity: string, id: string, data: Entity): void
+    function remove(entity: string, id: string): void
+}
+
+export function recursionLimit(depth: i32): void {
+    let user = new Entity();
+    var val = Value.fromI32(7);
+    for (let i = 0; i < depth; i++) {
+        val = Value.fromArray([val]);
+    }
+    user.set("foobar", val);
+    store.set("User", "user_id", user);
+}
\ No newline at end of file
diff --git a/runtime/test/wasm_test/api_version_0_0_5/recursion_limit.wasm b/runtime/test/wasm_test/api_version_0_0_5/recursion_limit.wasm
new file mode 100644
index 00000000000..c31b4bc8304
Binary files /dev/null and b/runtime/test/wasm_test/api_version_0_0_5/recursion_limit.wasm differ
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 bd95ac89e28..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.9"
-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.16"
-lazy_static = "1.4"
-uuid = { version = "1.3.0", features = ["v4"] }
-strum = "0.21.0"
-strum_macros = "0.21.1"
-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 fda9b6bda7e..ac3256661b2 100644
--- a/runtime/wasm/src/asc_abi/class.rs
+++ b/runtime/wasm/src/asc_abi/class.rs
@@ -1,10 +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, IndexForAscTypeId, ToAscObj,
+        AscHeap, AscIndexId, AscType, AscValue, HostExportError, IndexForAscTypeId, ToAscObj,
+        gas::GasCounter,
     },
 };
 use graph::{prelude::serde_json, runtime::DeterministicHostError};
@@ -12,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.
@@ -26,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)?)),
@@ -88,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, DeterministicHostError> {
+    ) -> 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,
-            )?)),
         }
     }
 
@@ -142,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, DeterministicHostError> {
-        self.0.to_asc_obj(heap, gas)
+    ) -> Result<Uint8Array, HostExportError> {
+        self.0.to_asc_obj(heap, gas).await
     }
 }
 
@@ -200,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)?)),
@@ -268,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, DeterministicHostError> {
+    ) -> 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,
-            )?)),
         }
     }
 
@@ -397,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)]
@@ -427,6 +442,12 @@ impl From<EnumPayload> for f64 {
     }
 }
 
+impl From<EnumPayload> for i64 {
+    fn from(payload: EnumPayload) -> i64 {
+        payload.0 as i64
+    }
+}
+
 impl From<EnumPayload> for bool {
     fn from(payload: EnumPayload) -> bool {
         payload.0 != 0
@@ -457,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)
@@ -492,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,
@@ -507,44 +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 {
@@ -554,6 +587,8 @@ impl StoreValueKind {
         match value {
             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,
@@ -564,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
@@ -596,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)]
@@ -608,6 +641,10 @@ impl AscIndexId for AscTypedMap<AscString, AscEnum<StoreValueKind>> {
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::TypedMapStringStoreValue;
 }
 
+impl AscIndexId for Array<AscPtr<AscEntity>> {
+    const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::ArrayTypedMapStringStoreValue;
+}
+
 impl AscIndexId for AscTypedMap<AscString, AscEnum<JsonValueKind>> {
     const INDEX_ASC_TYPE_ID: IndexForAscTypeId = IndexForAscTypeId::TypedMapStringJsonValue;
 }
@@ -617,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,
@@ -631,12 +673,6 @@ pub enum JsonValueKind {
     Object,
 }
 
-impl Default for JsonValueKind {
-    fn default() -> Self {
-        JsonValueKind::Null
-    }
-}
-
 impl AscValue for JsonValueKind {}
 
 impl JsonValueKind {
@@ -704,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> {
@@ -721,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 ba37c063d25..3eb796434e6 100644
--- a/runtime/wasm/src/asc_abi/v0_0_4.rs
+++ b/runtime/wasm/src/asc_abi/v0_0_4.rs
@@ -6,13 +6,13 @@ use std::mem::{size_of, size_of_val};
 use anyhow::anyhow;
 use semver::Version;
 
-use graph::runtime::{AscHeap, AscPtr, AscType, AscValue, DeterministicHostError};
+use graph::runtime::{AscHeap, AscPtr, AscType, AscValue, DeterministicHostError, HostExportError};
 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,18 +149,18 @@ 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, DeterministicHostError> {
+    ) -> Result<Self, HostExportError> {
         let buffer = class::ArrayBuffer::new(content, heap.api_version())?;
         let buffer_byte_length = if let class::ArrayBuffer::ApiVersion0_0_4(ref a) = buffer {
             a.byte_length
         } 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, DeterministicHostError> {
+    ) -> 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 31503af0b5a..c09ce7a167f 100644
--- a/runtime/wasm/src/asc_abi/v0_0_5.rs
+++ b/runtime/wasm/src/asc_abi/v0_0_5.rs
@@ -2,11 +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, HEADER_SIZE};
-use graph_runtime_derive::AscType;
+use graph::runtime::{
+    AscHeap, AscPtr, AscType, AscValue, DeterministicHostError, HEADER_SIZE, HostExportError,
+};
 
 use crate::asc_abi::class;
 
@@ -14,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 {
@@ -32,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"
             )));
@@ -50,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;
@@ -58,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()
     }
 }
@@ -73,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)
     }
@@ -112,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, DeterministicHostError> {
+    ) -> 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(),
@@ -174,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"
             )));
@@ -203,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)
     }
@@ -262,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, DeterministicHostError> {
+    ) -> 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 ad05a576653..77b03594a5e 100644
--- a/runtime/wasm/src/host.rs
+++ b/runtime/wasm/src/host.rs
@@ -2,8 +2,8 @@ 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::{Blockchain, HostFn, RuntimeAdapter};
 use graph::components::store::{EnsLookup, SubgraphFork};
@@ -11,15 +11,19 @@ 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, *,
 };
 
-use crate::mapping::{MappingContext, MappingRequest};
+use crate::mapping::{MappingContext, WasmRequest};
 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>,
@@ -55,7 +59,7 @@ where
     <C as Blockchain>::MappingTrigger: ToAscPtr,
 {
     type Host = RuntimeHost<C>;
-    type Req = MappingRequest<C>;
+    type Req = WasmRequest<C>;
 
     fn spawn_mapping(
         raw_module: &[u8],
@@ -83,7 +87,7 @@ where
         subgraph_id: DeploymentHash,
         data_source: DataSource<C>,
         templates: Arc<Vec<DataSourceTemplate<C>>>,
-        mapping_request_sender: Sender<MappingRequest<C>>,
+        mapping_request_sender: Sender<WasmRequest<C>>,
         metrics: Arc<HostMetrics>,
     ) -> Result<Self::Host, Error> {
         RuntimeHost::new(
@@ -103,8 +107,8 @@ where
 pub struct RuntimeHost<C: Blockchain> {
     host_fns: Arc<Vec<HostFn>>,
     data_source: DataSource<C>,
-    mapping_request_sender: Sender<MappingRequest<C>>,
-    host_exports: Arc<HostExports<C>>,
+    mapping_request_sender: Sender<WasmRequest<C>>,
+    host_exports: Arc<HostExports>,
     metrics: Arc<HostMetrics>,
 }
 
@@ -119,26 +123,26 @@ where
         subgraph_id: DeploymentHash,
         data_source: DataSource<C>,
         templates: Arc<Vec<DataSourceTemplate<C>>>,
-        mapping_request_sender: Sender<MappingRequest<C>>,
+        mapping_request_sender: Sender<WasmRequest<C>>,
         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>>,
-        block_ptr: BlockPtr,
         proof_of_indexing: SharedProofOfIndexing,
         debug_fork: &Option<Arc<dyn SubgraphFork>>,
-    ) -> Result<BlockState<C>, MappingError> {
+        instrument: bool,
+    ) -> Result<BlockState, MappingError> {
         let handler = trigger.handler_name().to_string();
 
         let extras = trigger.logging_extras();
@@ -176,19 +180,22 @@ where
 
         self.mapping_request_sender
             .clone()
-            .send(MappingRequest {
-                ctx: MappingContext {
+            .send(WasmRequest::new_trigger(
+                MappingContext {
                     logger: logger.cheap_clone(),
                     state,
                     host_exports: self.host_exports.cheap_clone(),
-                    block_ptr,
+                    block_ptr: trigger.block_ptr(),
+                    timestamp: trigger.timestamp(),
                     proof_of_indexing,
                     host_fns: self.host_fns.cheap_clone(),
                     debug_fork: debug_fork.cheap_clone(),
+                    mapping_logger: Logger::new(logger, o!("component" => "UserMapping")),
+                    instrument,
                 },
                 trigger,
                 result_sender,
-            })
+            ))
             .compat()
             .await
             .context("Mapping terminated before passing in trigger")?;
@@ -202,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(),
@@ -234,19 +241,19 @@ impl<C: Blockchain> RuntimeHostTrait<C> for RuntimeHost<C> {
     async fn process_mapping_trigger(
         &self,
         logger: &Logger,
-        block_ptr: BlockPtr,
         trigger: TriggerWithHandler<MappingTrigger<C>>,
-        state: BlockState<C>,
+        state: BlockState,
         proof_of_indexing: SharedProofOfIndexing,
         debug_fork: &Option<Arc<dyn SubgraphFork>>,
-    ) -> Result<BlockState<C>, MappingError> {
+        instrument: bool,
+    ) -> Result<BlockState, MappingError> {
         self.send_mapping_request(
             logger,
             state,
             trigger,
-            block_ptr,
             proof_of_indexing,
             debug_fork,
+            instrument,
         )
         .await
     }
@@ -261,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,
         }
     }
 
@@ -268,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 ae8288d191f..b6ab94a066f 100644
--- a/runtime/wasm/src/host_exports.rs
+++ b/runtime/wasm/src/host_exports.rs
@@ -1,43 +1,36 @@
 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::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::abi;
+use graph::blockchain::BlockTime;
 use graph::blockchain::Blockchain;
-use graph::components::store::EnsLookup;
-use graph::components::store::{EntityKey, EntityType};
+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 {
@@ -47,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
             ))),
         }
     }
@@ -123,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(Gas::new(gas::DEFAULT_BASE_COST))?;
+        Self::track_gas_and_ops(gas, state, Gas::new(gas::DEFAULT_BASE_COST), "abort")?;
 
         let message = message
             .map(|message| format!("message: {}", message))
@@ -148,41 +162,183 @@ impl<C: Blockchain> HostExports<C> {
         )))
     }
 
-    pub(crate) fn store_set(
+    fn check_invalid_fields(
+        &self,
+        api_version: Version,
+        data: &HashMap<Word, Value>,
+        state: &BlockState,
+        entity_type: &EntityType,
+    ) -> Result<(), HostExportError> {
+        if api_version >= API_VERSION_0_0_8 {
+            let has_invalid_fields = data.iter().any(|(field_name, _)| {
+                !state
+                    .entity_cache
+                    .schema
+                    .has_field_with_name(entity_type, field_name)
+            });
+
+            if has_invalid_fields {
+                let mut invalid_fields: Vec<Word> = data
+                    .keys()
+                    .filter_map(|field_name| {
+                        if !state
+                            .entity_cache
+                            .schema
+                            .has_field_with_name(entity_type, field_name)
+                        {
+                            Some(field_name.clone())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+
+                invalid_fields.sort();
+
+                return Err(HostExportError::Deterministic(anyhow!(
+                    "Attempted to set undefined fields [{}] for the entity type `{}`. Make sure those fields are defined in the schema.",
+                    invalid_fields
+                        .iter()
+                        .map(|f| f.as_str())
+                        .collect::<Vec<_>>()
+                        .join(", "),
+                    entity_type
+                )));
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Ensure that `entity_type` is of the right kind
+    fn expect_object_type(entity_type: &EntityType, op: &str) -> Result<(), HostExportError> {
+        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) async fn store_set(
         &self,
         logger: &Logger,
-        state: &mut BlockState<C>,
+        state: &mut BlockState,
         proof_of_indexing: &SharedProofOfIndexing,
+        block_time: BlockTime,
         entity_type: String,
         entity_id: String,
-        data: HashMap<String, Value>,
+        mut data: HashMap<Word, Value>,
         stopwatch: &StopwatchMetrics,
         gas: &GasCounter,
     ) -> Result<(), HostExportError> {
+        let entity_type = state.entity_cache.schema.entity_type(&entity_type)?;
+
+        Self::expect_object_type(&entity_type, "set")?;
+
+        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.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)?;
+        self.check_entity_type_access(&key.entity_type)?;
+
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::STORE_SET.with_args(complexity::Linear, (&key, &data)),
+            "store_set",
+        )?;
+
+        if entity_type.object_type()?.timeseries {
+            data.insert(Word::from("timestamp"), block_time.into());
+        }
+
+        // Set the id if there isn't one yet, and make sure that a
+        // previously set id agrees with the one in the `key`
+        match data.get(&store::ID) {
+            Some(v) => {
+                if v != &key.entity_id {
+                    if v.type_name() != key.entity_id.id_type().as_str() {
+                        return Err(anyhow!(
+                            "Attribute `{}.id` has wrong type: expected {} but got {}",
+                            key.entity_type,
+                            key.entity_id.id_type().as_str(),
+                            v.type_name(),
+                        )
+                        .into());
+                    }
+                    return Err(anyhow!(
+                        "Value of {} attribute 'id' conflicts with ID passed to `store.set()`: \
+                    {:?} != {:?}",
+                        key.entity_type,
+                        v,
+                        key.entity_id,
+                    )
+                    .into());
+                }
+            }
+            None => {
+                let value = Value::from(key.entity_id.clone());
+                data.insert(store::ID.clone(), value);
+            }
+        }
+
+        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, _)| {
+            state
+                .entity_cache
+                .schema
+                .has_field_with_name(&key.entity_type, field_name)
+        });
+
+        let entity = state
+            .entity_cache
+            .make_entity(filtered_entity_data)
+            .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: &entity_type,
-                id: &entity_id,
-                data: &data,
+                entity_type: key.entity_type.typename(),
+                id: &key.entity_id.to_string(),
+                data: &entity,
             },
             &self.poi_causality_region,
             logger,
         );
         poi_section.end();
 
-        let key = EntityKey {
-            entity_type: EntityType::new(entity_type),
-            entity_id: entity_id.into(),
-            causality_region: self.data_source_causality_region,
-        };
-        self.check_entity_type_access(&key.entity_type)?;
-
-        gas.consume_host_fn(gas::STORE_SET.with_args(complexity::Linear, (&key, &data)))?;
+        state.metrics.track_entity_write(&entity_type, &entity);
 
-        let entity = Entity::from(data);
-        state.entity_cache.set(key, entity)?;
+        state
+            .entity_cache
+            .set(key, entity, Some(&mut state.write_capacity_remaining))
+            .await?;
 
         Ok(())
     }
@@ -190,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,
@@ -205,36 +360,85 @@ impl<C: Blockchain> HostExports<C> {
             &self.poi_causality_region,
             logger,
         );
-        let key = EntityKey {
-            entity_type: EntityType::new(entity_type),
-            entity_id: entity_id.into(),
-            causality_region: self.data_source_causality_region,
-        };
+        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)?;
         self.check_entity_type_access(&key.entity_type)?;
 
-        gas.consume_host_fn(gas::STORE_REMOVE.with_args(complexity::Size, &key))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::STORE_REMOVE.with_args(complexity::Size, &key),
+            "store_remove",
+        )?;
 
         state.entity_cache.remove(key);
 
         Ok(())
     }
 
-    pub(crate) fn store_get(
+    pub(crate) async fn store_get(
+        &self,
+        state: &mut BlockState,
+        entity_type: String,
+        entity_id: String,
+        gas: &GasCounter,
+        scope: GetScope,
+    ) -> 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)?;
+        self.check_entity_type_access(&store_key.entity_type)?;
+
+        let result = state.entity_cache.get(&store_key, scope).await?;
+
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::STORE_GET.with_args(
+                complexity::Linear,
+                (&store_key, result.as_ref().map(|e| e.as_ref())),
+            ),
+            "store_get",
+        )?;
+
+        if let Some(ref entity) = result {
+            state.metrics.track_entity_read(&entity_type, entity)
+        }
+
+        Ok(result)
+    }
+
+    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<Option<Entity>, anyhow::Error> {
-        let store_key = EntityKey {
-            entity_type: EntityType::new(entity_type),
-            entity_id: entity_id.into(),
-            causality_region: self.data_source_causality_region,
+    ) -> 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 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,
         };
         self.check_entity_type_access(&store_key.entity_type)?;
 
-        let result = state.entity_cache.get(&store_key)?;
-        gas.consume_host_fn(gas::STORE_GET.with_args(complexity::Linear, (&store_key, &result)))?;
+        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)
     }
@@ -248,8 +452,14 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         n: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<String, DeterministicHostError> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &n))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &n),
+            "big_int_to_hex",
+        )?;
 
         if n == 0.into() {
             return Ok("0x0".to_string());
@@ -262,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,
@@ -277,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
@@ -287,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.
@@ -305,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!(
@@ -320,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!(
@@ -347,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.
@@ -355,8 +586,14 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         json: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<i64, DeterministicHostError> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json),
+            "json_to_i64",
+        )?;
         i64::from_str(&json)
             .with_context(|| format!("JSON `{}` cannot be parsed as i64", json))
             .map_err(DeterministicHostError::from)
@@ -367,8 +604,14 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         json: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<u64, DeterministicHostError> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json),
+            "json_to_u64",
+        )?;
 
         u64::from_str(&json)
             .with_context(|| format!("JSON `{}` cannot be parsed as u64", json))
@@ -380,8 +623,14 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         json: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<f64, DeterministicHostError> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json),
+            "json_to_f64",
+        )?;
 
         f64::from_str(&json)
             .with_context(|| format!("JSON `{}` cannot be parsed as f64", json))
@@ -393,8 +642,14 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         json: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<Vec<u8>, DeterministicHostError> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &json),
+            "json_to_big_int",
+        )?;
 
         let big_int = BigInt::from_str(&json)
             .with_context(|| format!("JSON `{}` is not a decimal string", json))
@@ -406,10 +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(gas::DEFAULT_GAS_OP.with_args(complexity::Size, data))?;
-        Ok(tiny_keccak::keccak256(data))
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, data),
+            "crypto_keccak_256",
+        )?;
+        Ok(alloy::primitives::keccak256(data).0)
     }
 
     pub(crate) fn big_int_plus(
@@ -417,8 +678,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Max, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Max, (&x, &y)),
+            "big_int_plus",
+        )?;
         Ok(x + y)
     }
 
@@ -427,8 +694,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Max, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Max, (&x, &y)),
+            "big_int_minus",
+        )?;
         Ok(x - y)
     }
 
@@ -437,8 +710,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)),
+            "big_int_times",
+        )?;
         Ok(x * y)
     }
 
@@ -447,8 +726,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)),
+            "big_int_divided_by",
+        )?;
         if y == 0.into() {
             return Err(DeterministicHostError::from(anyhow!(
                 "attempted to divide BigInt `{}` by zero",
@@ -463,8 +748,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)),
+            "big_int_mod",
+        )?;
         if y == 0.into() {
             return Err(DeterministicHostError::from(anyhow!(
                 "attempted to calculate the remainder of `{}` with a divisor of zero",
@@ -480,20 +771,30 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         exp: u8,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(
+        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",
         )?;
-        Ok(x.pow(exp))
+        Ok(x.pow(exp)?)
     }
 
     pub(crate) fn big_int_from_string(
         &self,
         s: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &s))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &s),
+            "big_int_from_string",
+        )?;
         BigInt::from_str(&s)
             .with_context(|| format!("string is not a BigInt: `{}`", s))
             .map_err(DeterministicHostError::from)
@@ -504,8 +805,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Max, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Max, (&x, &y)),
+            "big_int_bit_or",
+        )?;
         Ok(x | y)
     }
 
@@ -514,8 +821,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         y: BigInt,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Min, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Min, (&x, &y)),
+            "big_int_bit_and",
+        )?;
         Ok(x & y)
     }
 
@@ -524,8 +837,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         bits: u8,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &bits)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &bits)),
+            "big_int_left_shift",
+        )?;
         Ok(x << bits)
     }
 
@@ -534,8 +853,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigInt,
         bits: u8,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigInt, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &bits)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &bits)),
+            "big_int_right_shift",
+        )?;
         Ok(x >> bits)
     }
 
@@ -544,8 +869,14 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         bytes: Vec<u8>,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<String, DeterministicHostError> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &bytes))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &bytes),
+            "bytes_to_base58",
+        )?;
         Ok(::bs58::encode(&bytes).into_string())
     }
 
@@ -554,8 +885,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigDecimal,
         y: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigDecimal, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &y)),
+            "big_decimal_plus",
+        )?;
         Ok(x + y)
     }
 
@@ -564,8 +901,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigDecimal,
         y: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigDecimal, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Linear, (&x, &y)),
+            "big_decimal_minus",
+        )?;
         Ok(x - y)
     }
 
@@ -574,8 +917,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigDecimal,
         y: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigDecimal, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)),
+            "big_decimal_times",
+        )?;
         Ok(x * y)
     }
 
@@ -585,8 +934,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigDecimal,
         y: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigDecimal, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Mul, (&x, &y)),
+            "big_decimal_divided_by",
+        )?;
         if y == 0.into() {
             return Err(DeterministicHostError::from(anyhow!(
                 "attempted to divide BigDecimal `{}` by zero",
@@ -601,8 +956,14 @@ impl<C: Blockchain> HostExports<C> {
         x: BigDecimal,
         y: BigDecimal,
         gas: &GasCounter,
-    ) -> Result<bool, DeterministicHostError> {
-        gas.consume_host_fn(gas::BIG_MATH_GAS_OP.with_args(complexity::Min, (&x, &y)))?;
+        state: &mut BlockState,
+    ) -> Result<bool, HostExportError> {
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::BIG_MATH_GAS_OP.with_args(complexity::Min, (&x, &y)),
+            "big_decimal_equals",
+        )?;
         Ok(x == y)
     }
 
@@ -610,8 +971,14 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         x: BigDecimal,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<String, DeterministicHostError> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &x))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Mul, (&x, &x)),
+            "big_decimal_to_string",
+        )?;
         Ok(x.to_string())
     }
 
@@ -619,8 +986,14 @@ impl<C: Blockchain> HostExports<C> {
         &self,
         s: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<BigDecimal, DeterministicHostError> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &s))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &s),
+            "big_decimal_from_string",
+        )?;
         BigDecimal::from_str(&s)
             .with_context(|| format!("string  is not a BigDecimal: '{}'", s))
             .map_err(DeterministicHostError::from)
@@ -629,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(gas::CREATE_DATA_SOURCE)?;
+        Self::track_gas_and_ops(gas, state, gas::CREATE_DATA_SOURCE, "data_source_create")?;
         info!(
             logger,
             "Create data source";
@@ -646,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(", ")
                 )
@@ -667,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,
@@ -677,12 +1052,18 @@ impl<C: Blockchain> HostExports<C> {
         Ok(())
     }
 
-    pub(crate) fn ens_name_by_hash(&self, hash: &str) -> Result<Option<String>, anyhow::Error> {
-        Ok(self.ens_lookup.find_name(hash)?)
+    pub(crate) async fn ens_name_by_hash(
+        &self,
+        hash: &str,
+        gas: &GasCounter,
+        state: &mut BlockState,
+    ) -> Result<Option<String>, anyhow::Error> {
+        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(
@@ -691,20 +1072,27 @@ impl<C: Blockchain> HostExports<C> {
         level: slog::Level,
         msg: String,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<(), DeterministicHostError> {
-        gas.consume_host_fn(gas::LOG_OP.with_args(complexity::Size, &msg))?;
+        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(())
@@ -713,48 +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(Gas::new(gas::DEFAULT_BASE_COST))?;
-        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(Gas::new(gas::DEFAULT_BASE_COST))?;
+        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,
-    ) -> Result<Entity, DeterministicHostError> {
-        gas.consume_host_fn(Gas::new(gas::DEFAULT_BASE_COST))?;
-        Ok(self
-            .data_source_context
-            .as_ref()
-            .clone()
-            .unwrap_or_default())
+        state: &mut BlockState,
+    ) -> Result<Option<DataSourceContext>, DeterministicHostError> {
+        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> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(gas::complexity::Size, &bytes))?;
-        serde_json::from_reader(bytes.as_slice())
+        // Max JSON size is 10MB.
+        const MAX_JSON_SIZE: usize = 10_000_000;
+
+        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
+            )));
+        }
+
+        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(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &string))?;
-        string_to_h160(string)
+        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_address(string)
     }
 
     pub(crate) fn bytes_to_string(
@@ -762,20 +1187,32 @@ impl<C: Blockchain> HostExports<C> {
         logger: &Logger,
         bytes: Vec<u8>,
         gas: &GasCounter,
+        state: &mut BlockState,
     ) -> Result<String, DeterministicHostError> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &bytes))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &bytes),
+            "bytes_to_string",
+        )?;
 
         Ok(bytes_to_string(logger, bytes))
     }
 
     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(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &encoded))?;
+        Self::track_gas_and_ops(
+            gas,
+            state,
+            gas::DEFAULT_GAS_OP.with_args(complexity::Size, &encoded),
+            "ethereum_encode",
+        )?;
 
         Ok(encoded)
     }
@@ -785,26 +1222,75 @@ impl<C: Blockchain> HostExports<C> {
         types: String,
         data: Vec<u8>,
         gas: &GasCounter,
-    ) -> Result<Token, anyhow::Error> {
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(complexity::Size, &data))?;
+        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")?;
 
-        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")
+        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
+            )));
+        }
+
+        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)
 }
 
@@ -827,11 +1313,79 @@ fn bytes_to_string(logger: &Logger, bytes: Vec<u8>) -> String {
     s.trim_end_matches('\u{0000}').to_string()
 }
 
+/// Expose some host functions for testing only
+#[cfg(debug_assertions)]
+pub mod test_support {
+    use std::{collections::HashMap, sync::Arc};
+
+    use graph::{
+        blockchain::BlockTime,
+        components::{store::GetScope, subgraph::SharedProofOfIndexing},
+        data::value::Word,
+        prelude::{BlockState, Entity, StopwatchMetrics, Value},
+        runtime::{HostExportError, gas::GasCounter},
+        slog::Logger,
+    };
+
+    use crate::MappingContext;
+
+    pub struct HostExports {
+        host_exports: Arc<super::HostExports>,
+        block_time: BlockTime,
+    }
+
+    impl HostExports {
+        pub fn new(ctx: &MappingContext) -> Self {
+            HostExports {
+                host_exports: ctx.host_exports.clone(),
+                block_time: ctx.timestamp,
+            }
+        }
+
+        pub async fn store_set(
+            &self,
+            logger: &Logger,
+            state: &mut BlockState,
+            proof_of_indexing: &SharedProofOfIndexing,
+            entity_type: String,
+            entity_id: String,
+            data: HashMap<Word, Value>,
+            stopwatch: &StopwatchMetrics,
+            gas: &GasCounter,
+        ) -> Result<(), HostExportError> {
+            self.host_exports
+                .store_set(
+                    logger,
+                    state,
+                    proof_of_indexing,
+                    self.block_time,
+                    entity_type,
+                    entity_id,
+                    data,
+                    stopwatch,
+                    gas,
+                )
+                .await
+        }
+
+        pub async fn store_get(
+            &self,
+            state: &mut BlockState,
+            entity_type: String,
+            entity_id: String,
+            gas: &GasCounter,
+        ) -> 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()
     )
 }
 
@@ -841,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 2a365b9468f..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;
 
@@ -21,6 +21,3 @@ pub use host::RuntimeHostBuilder;
 pub use host_exports::HostExports;
 pub use mapping::{MappingContext, ValidModule};
 pub use module::{ExperimentalFeatures, WasmInstance};
-
-#[cfg(debug_assertions)]
-pub use module::TRAP_TIMEOUT;
diff --git a/runtime/wasm/src/mapping.rs b/runtime/wasm/src/mapping.rs
index 03b33d807f0..c185148bff0 100644
--- a/runtime/wasm/src/mapping.rs
+++ b/runtime/wasm/src/mapping.rs
@@ -1,16 +1,22 @@
 use crate::gas_rules::GasRules;
-use crate::module::{ExperimentalFeatures, ToAscPtr, WasmInstance};
-use futures::sync::mpsc;
-use futures03::channel::oneshot::Sender;
-use graph::blockchain::{Blockchain, HostFn};
+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::thread;
+use std::sync::atomic::{AtomicUsize, Ordering};
+use std::{panic, thread};
 
 /// Spawn a wasm module in its own thread.
 pub fn spawn_module<C: Blockchain>(
@@ -21,23 +27,33 @@ pub fn spawn_module<C: Blockchain>(
     runtime: tokio::runtime::Handle,
     timeout: Option<Duration>,
     experimental_features: ExperimentalFeatures,
-) -> Result<mpsc::Sender<MappingRequest<C>>, anyhow::Error>
+) -> Result<mpsc::Sender<WasmRequest<C>>, anyhow::Error>
 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();
 
@@ -46,20 +62,48 @@ where
         match mapping_request_receiver
             .map_err(|()| unreachable!())
             .for_each(move |request| {
-                let MappingRequest {
+                let WasmRequest {
                     ctx,
-                    trigger,
+                    inner,
                     result_sender,
                 } = request;
+                let logger = ctx.logger.clone();
 
-                let result = instantiate_module_and_handle_trigger(
-                    valid_module.cheap_clone(),
-                    ctx,
-                    trigger,
-                    host_metrics.cheap_clone(),
-                    timeout,
-                    experimental_features,
-                );
+                let handle_fut = async {
+                    let result = instantiate_module::<C>(
+                        valid_module.cheap_clone(),
+                        ctx,
+                        host_metrics.cheap_clone(),
+                        experimental_features,
+                    )
+                    .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,
+                    Err(panic_info) => {
+                        let err_msg = if let Some(payload) = panic_info
+                            .downcast_ref::<String>()
+                            .map(String::as_str)
+                            .or(panic_info.downcast_ref::<&str>().copied())
+                        {
+                            anyhow!("Subgraph panicked with message: {}", payload)
+                        } else {
+                            anyhow!("Subgraph panicked with an unknown payload.")
+                        };
+                        Err(MappingError::Unknown(err_msg))
+                    }
+                };
 
                 result_sender
                     .send(result)
@@ -78,72 +122,123 @@ where
     Ok(mapping_request_sender)
 }
 
-fn instantiate_module_and_handle_trigger<C: Blockchain>(
+async fn instantiate_module<C: Blockchain>(
     valid_module: Arc<ValidModule>,
-    ctx: MappingContext<C>,
-    trigger: TriggerWithHandler<MappingTrigger<C>>,
+    ctx: MappingContext,
     host_metrics: Arc<HostMetrics>,
-    timeout: Option<Duration>,
     experimental_features: ExperimentalFeatures,
-) -> Result<(BlockState<C>, Gas), MappingError>
+) -> Result<WasmInstance, anyhow::Error>
 where
     <C as Blockchain>::MappingTrigger: ToAscPtr,
 {
-    let logger = ctx.logger.cheap_clone();
-
     // Start the WASM module runtime.
-    let section = host_metrics.stopwatch.start_section("module_init");
-    let module = WasmInstance::from_valid_module_with_ctx(
+    let _section = host_metrics.stopwatch.start_section("module_init");
+    WasmInstance::from_valid_module_with_ctx(
         valid_module,
         ctx,
         host_metrics.cheap_clone(),
-        timeout,
         experimental_features,
     )
-    .context("module instantiation failed")?;
-    section.end();
+    .await
+    .context("module instantiation failed")
+}
+
+async fn handle_trigger<C: Blockchain>(
+    logger: &Logger,
+    module: WasmInstance,
+    trigger: TriggerWithHandler<MappingTrigger<C>>,
+    host_metrics: Arc<HostMetrics>,
+) -> Result<(BlockState, Gas), MappingError>
+where
+    <C as Blockchain>::MappingTrigger: ToAscPtr,
+{
+    let logger = logger.cheap_clone();
 
     let _section = host_metrics.stopwatch.start_section("run_handler");
     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,
+    pub(crate) inner: WasmRequestInner<C>,
+    pub(crate) result_sender: Sender<Result<(BlockState, Gas), MappingError>>,
+}
+
+impl<C: Blockchain> WasmRequest<C> {
+    pub(crate) fn new_trigger(
+        ctx: MappingContext,
+        trigger: TriggerWithHandler<MappingTrigger<C>>,
+        result_sender: Sender<Result<(BlockState, Gas), MappingError>>,
+    ) -> Self {
+        WasmRequest {
+            ctx,
+            inner: WasmRequestInner::TriggerRequest(trigger),
+            result_sender,
+        }
+    }
 }
 
-pub struct MappingRequest<C: Blockchain> {
-    pub(crate) ctx: MappingContext<C>,
-    pub(crate) trigger: TriggerWithHandler<MappingTrigger<C>>,
-    pub(crate) result_sender: Sender<Result<(BlockState<C>, Gas), MappingError>>,
+pub enum WasmRequestInner<C: Blockchain> {
+    TriggerRequest(TriggerWithHandler<MappingTrigger<C>>),
 }
 
-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 state: BlockState<C>,
+    pub timestamp: BlockTime,
+    pub state: BlockState,
     pub proof_of_indexing: SharedProofOfIndexing,
     pub host_fns: Arc<Vec<HostFn>>,
     pub debug_fork: Option<Arc<dyn SubgraphFork>>,
+    /// Logger for messages coming from mappings
+    pub mapping_logger: Logger,
+    /// Whether to log details about host fn execution
+    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(),
-            state: BlockState::new(self.state.entity_cache.store.clone(), Default::default()),
+            timestamp: self.timestamp,
+            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(),
+            mapping_logger: Logger::new(&self.logger, o!("component" => "UserMapping")),
+            instrument: self.instrument,
         }
     }
 }
 
+// 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
@@ -153,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 {
@@ -177,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)?;
@@ -201,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())
@@ -209,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 f38ba6e8626..fc9b5e0ca09 100644
--- a/runtime/wasm/src/module/mod.rs
+++ b/runtime/wasm/src/module/mod.rs
@@ -1,283 +1,159 @@
-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 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};
+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_get, 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;
 
-pub const TRAP_TIMEOUT: &str = "trap: interrupt";
+// Convenience for a 'top-level' asc_get, with depth 0.
+fn asc_get<T, C, H: AscHeap + ?Sized>(
+    heap: &H,
+    ptr: AscPtr<C>,
+    gas: &GasCounter,
+) -> Result<T, DeterministicHostError>
+where
+    C: AscType + AscIndexId,
+    T: FromAscObj<C>,
+{
+    graph::runtime::asc_get(heap, ptr, gas, 0)
+}
 
 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<()>, DeterministicHostError>;
+    ) -> 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<()>, DeterministicHostError> {
-        asc_new(heap, self.data.as_ref() as &[u8], gas).map(|ptr| ptr.erase())
+    ) -> 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.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<()>, DeterministicHostError> {
+    ) -> 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<()>, DeterministicHostError> {
-        self.trigger.to_asc_ptr(heap, gas)
+    ) -> Result<AscPtr<()>, HostExportError> {
+        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>>>>,
-
-    // 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);
+fn is_trap_deterministic(trap: &Error) -> bool {
+    let trap = match trap.downcast_ref() {
+        Some(trap) => trap,
+        None => return false,
+    };
+
+    use wasmtime::Trap::*;
+
+    // We try to be exhaustive, even though `TrapCode` is non-exhaustive.
+    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.
+        Interrupt | StackOverflow | _ => false,
     }
 }
 
-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>, DeterministicHostError>
-    where
-        P: AscType + AscIndexId,
-        T: ToAscObj<P>,
-    {
-        asc_new(self.instance_ctx_mut().deref_mut(), rust_obj, &self.gas)
-    }
+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,
 }
 
-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 = GasCounter::default();
-        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_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 asc_trigger = trigger.to_asc_ptr(self.instance_ctx_mut().deref_mut(), &gas)?;
-        self.invoke_handler(&handler_name, asc_trigger)
-    }
-
-    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>,
-    ) -> Result<(BlockState<C>, Gas), MappingError> {
-        let func = self
-            .instance
-            .get_func(handler)
-            .with_context(|| format!("function {} not found", handler))?;
-
-        let func = func
-            .typed()
-            .context("wasm function has incorrect signature")?;
-
-        // Caution: Make sure all exit paths from this function call `exit_handler`.
-        self.instance_ctx_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(arg.wasm_ptr()) {
-            Ok(()) => None,
-            Err(trap) if self.instance_ctx().possible_reorg => {
-                self.instance_ctx_mut().ctx.state.exit_handler();
-                return Err(MappingError::PossibleReorg(trap.into()));
-            }
-            Err(trap) if trap.to_string().contains(TRAP_TIMEOUT) => {
-                self.instance_ctx_mut().ctx.state.exit_handler();
-                return Err(MappingError::Unknown(Error::from(trap).context(format!(
-                    "Handler '{}' hit the timeout of '{}' seconds",
-                    handler,
-                    self.instance_ctx().timeout.unwrap().as_secs()
-                ))));
-            }
-            Err(trap) => {
-                use wasmtime::TrapCode::*;
-                let trap_code = trap.trap_code();
-                let e = Error::from(trap);
-                match trap_code {
-                    Some(MemoryOutOfBounds)
-                    | Some(HeapMisaligned)
-                    | Some(TableOutOfBounds)
-                    | Some(IndirectCallToNull)
-                    | Some(BadSignature)
-                    | Some(IntegerOverflow)
-                    | Some(IntegerDivisionByZero)
-                    | Some(BadConversionToInteger)
-                    | Some(UnreachableCodeReached) => Some(e),
-                    _ if self.instance_ctx().deterministic_host_trap => Some(e),
-                    _ => {
-                        self.instance_ctx_mut().ctx.state.exit_handler();
-                        return Err(MappingError::Unknown(e));
-                    }
-                }
-            }
-        };
-
-        if let Some(deterministic_error) = 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,
-            );
-            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();
-        }
-
-        let gas = self.gas.get();
-        Ok((self.take_ctx().ctx.state, gas))
+impl Arena {
+    fn new() -> Self {
+        Self { start: 0, size: 0 }
     }
 }
 
@@ -286,379 +162,109 @@ pub struct ExperimentalFeatures {
     pub allow_non_deterministic_ipfs: bool,
 }
 
-pub struct WasmInstanceContext<C: Blockchain> {
-    // In the future there may be multiple memories, but currently there is only one memory per
-    // module. And at least AS calls it "memory". There is no uninitialized memory in Wasm, memory
-    // is zeroed when initialized or grown.
-    memory: Memory,
+pub struct AscHeapCtx {
+    // Function wrapper for `idof<T>` from AssemblyScript
+    id_of_type: Option<wasmtime::TypedFunc<u32, u32>>,
 
     // Function exported by the wasm module that will allocate the request number of bytes and
     // return a pointer to the first byte of allocated space.
     memory_allocate: wasmtime::TypedFunc<i32, i32>,
 
-    // Function wrapper for `idof<T>` from AssemblyScript
-    id_of_type: Option<wasmtime::TypedFunc<u32, u32>>,
-
-    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>>,
-
-    // 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,
+    api_version: semver::Version,
 
-    // 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,
+    // In the future there may be multiple memories, but currently there is only one memory per
+    // module. And at least AS calls it "memory". There is no uninitialized memory in Wasm, memory
+    // is zeroed when initialized or grown.
+    memory: Memory,
 
-    pub(crate) experimental_features: ExperimentalFeatures,
+    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::default();
-        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 ctx = HostFnCtx {
-                        logger: instance.ctx.logger.cheap_clone(),
-                        block_ptr: instance.ctx.block_ptr.cheap_clone(),
-                        heap: instance,
-                        gas: gas.cheap_clone(),
-                    };
-                    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.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);
+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")?;
 
-        link!("log.log", log_log, level, msg_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();
 
-        // `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 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(),
+            ),
+        };
 
-        // 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(gas_used.saturating_into()) {
-                    deterministic_host_trap.store(true, Ordering::SeqCst);
-                    return Err(e.into_trap());
-                }
+        Ok(Arc::new(AscHeapCtx {
+            memory_allocate,
+            memory,
+            arena: RwLock::new(Arena::new()),
+            api_version,
+            id_of_type,
+        }))
+    }
 
-                Ok(())
-            })?;
-        }
+    fn arena_start_ptr(&self) -> i32 {
+        self.arena.read().start
+    }
 
-        let instance = linker.instantiate(&valid_module.module)?;
+    fn arena_free_size(&self) -> i32 {
+        self.arena.read().size
+    }
 
-        // 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 set_arena(&self, start_ptr: i32, size: i32) {
+        let mut arena = self.arena.write();
+        arena.start = start_ptr;
+        arena.size = size;
+    }
 
-        match api_version {
-            version if version <= Version::new(0, 0, 4) => {}
-            _ => {
-                instance
-                    .get_func("_start")
-                    .context("`_start` function not found")?
-                    .typed::<(), ()>()?
-                    .call(())?;
-            }
-        }
+    fn allocated(&self, size: i32) {
+        let mut arena = self.arena.write();
+        arena.start += size;
+        arena.size -= size;
+    }
+}
 
-        Ok(WasmInstance {
-            instance,
-            instance_ctx: shared_ctx,
-            gas,
-        })
+fn host_export_error_from_trap(trap: Error, context: String) -> HostExportError {
+    let trap_is_deterministic = is_trap_deterministic(&trap);
+    let e = trap.context(context);
+    match trap_is_deterministic {
+        true => HostExportError::Deterministic(e),
+        false => HostExportError::Unknown(e),
     }
 }
 
-impl<C: Blockchain> AscHeap for WasmInstanceContext<C> {
-    fn raw_new(&mut self, bytes: &[u8], gas: &GasCounter) -> Result<u32, DeterministicHostError> {
+#[async_trait]
+impl AscHeap for WasmInstanceContext<'_> {
+    async fn raw_new(
+        &mut self,
+        bytes: &[u8],
+        gas: &GasCounter,
+    ) -> 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(Gas::new(GAS_COST_STORE as u64 * bytes.len() as u64))?;
+        gas.consume_host_fn_with_metrics(
+            Gas::new(GAS_COST_STORE as u64 * bytes.len() as u64),
+            "raw_new",
+        )?;
 
         // We request large chunks from the AssemblyScript allocator to use as arenas that we
         // manage directly.
@@ -666,18 +272,21 @@ impl<C: Blockchain> AscHeap for WasmInstanceContext<C> {
         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.ctx.host_exports.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`
@@ -686,32 +295,36 @@ impl<C: Blockchain> AscHeap for WasmInstanceContext<C> {
                     // `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)
     }
 
     fn read_u32(&self, offset: u32, gas: &GasCounter) -> Result<u32, DeterministicHostError> {
-        gas.consume_host_fn(Gas::new(GAS_COST_LOAD as u64 * 4))?;
+        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))
     }
 
@@ -723,1049 +336,60 @@ impl<C: Blockchain> AscHeap for WasmInstanceContext<C> {
     ) -> Result<&'a mut [u8], DeterministicHostError> {
         // The cost of reading wasm memory from the host is the same as of reading from wasm using
         // load instructions.
-        gas.consume_host_fn(Gas::new(GAS_COST_LOAD as u64 * (buffer.len() as u64)))?;
+        gas.consume_host_fn_with_metrics(
+            Gas::new(GAS_COST_LOAD as u64 * (buffer.len() as u64)),
+            "read",
+        )?;
 
         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()
-                )))?;
+        // 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(init_slice(src, buffer))
-        }
+        Ok(init_slice(src, buffer))
     }
 
-    fn api_version(&self) -> Version {
-        self.ctx.host_exports.api_version.clone()
+    fn api_version(&self) -> &Version {
+        &self.asc_heap().api_version
     }
 
-    fn asc_type_id(
+    async fn asc_type_id(
         &mut self,
         type_id_index: IndexForAscTypeId,
-    ) -> Result<u32, DeterministicHostError> {
-        let type_id = 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)
-            .with_context(|| format!("Failed to call 'asc_type_id' with '{:?}'", type_id_index))
-            .map_err(DeterministicHostError::from)?;
-        Ok(type_id)
-    }
-}
-
-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 {
-            memory_allocate,
-            id_of_type,
-            memory,
-            ctx,
-            valid_module,
-            host_metrics,
-            timeout,
-            timeout_stopwatch,
-            arena_free_size: 0,
-            arena_start_ptr: 0,
-            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 {
-            id_of_type,
-            memory_allocate,
-            memory,
-            ctx,
-            valid_module,
-            host_metrics,
-            timeout,
-            timeout_stopwatch,
-            arena_free_size: 0,
-            arena_start_ptr: 0,
-            possible_reorg: false,
-            deterministic_host_trap: false,
-            experimental_features,
-        })
-    }
-}
-
-// 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)
-    }
-
-    /// function store.set(entity: string, id: string, data: Entity): void
-    pub fn store_set(
-        &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 = asc_get(self, entity_ptr, gas)?;
-        let id = asc_get(self, id_ptr, gas)?;
-        let data = asc_get(self, data_ptr, gas)?;
-
-        self.ctx.host_exports.store_set(
-            &self.ctx.logger,
-            &mut self.ctx.state,
-            &self.ctx.proof_of_indexing,
-            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 = asc_get(self, entity_ptr, gas)?;
-        let id = asc_get(self, id_ptr, gas)?;
-        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> {
-        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,
-        )?;
-
-        let ret = match entity_option {
-            Some(entity) => {
-                let _section = self
-                    .host_metrics
-                    .stopwatch
-                    .start_section("store_get_asc_new");
-                asc_new(self, &entity.sorted(), 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(),
-            },
-        };
-
-        Ok(ret)
-    }
-
-    /// function typeConversion.bytesToString(bytes: Bytes): string
-    pub fn bytes_to_string(
-        &mut self,
-        gas: &GasCounter,
-        bytes_ptr: AscPtr<Uint8Array>,
-    ) -> Result<AscPtr<AscString>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        let bytes: Vec<u8> = asc_get(self, bytes_ptr, gas)?;
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(gas::complexity::Size, &bytes))?;
-
-        // 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>, DeterministicHostError> {
-        let n: BigInt = asc_get(self, big_int_ptr, gas)?;
-        gas.consume_host_fn(gas::DEFAULT_GAS_OP.with_args(gas::complexity::Size, &n))?;
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>>, DeterministicHostError> {
-        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)],
-                )
-            })
-            .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>>, DeterministicHostError>
-    {
-        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"
-            )));
+    ) -> 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);
         }
 
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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, DeterministicHostError> {
-        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)?;
-        self.ctx.host_exports.data_source_create(
-            &self.ctx.logger,
-            &mut self.ctx.state,
-            name,
-            params,
-            Some(context.into()),
-            self.ctx.block_ptr.number,
-            gas,
-        )
-    }
-
-    /// function dataSource.address(): Bytes
-    pub fn data_source_address(
-        &mut self,
-        gas: &GasCounter,
-    ) -> Result<AscPtr<Uint8Array>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        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>, DeterministicHostError> {
-        asc_new(
-            self,
-            &self.ctx.host_exports.data_source_context(gas)?.sorted(),
-            gas,
-        )
-    }
-
-    pub fn ens_name_by_hash(
-        &mut self,
-        gas: &GasCounter,
-        hash_ptr: AscPtr<AscString>,
-    ) -> Result<AscPtr<AscString>, HostExportError> {
-        // Not enabled on the network, no gas consumed.
-        // This is unrelated to IPFS, but piggyback on the config to disallow it on the network.
-        if !self.experimental_features.allow_non_deterministic_ipfs {
-            return Err(HostExportError::Deterministic(anyhow!(
-                "`ens_name_by_hash` is deprecated"
-            )));
-        }
-
-        let hash: String = asc_get(self, hash_ptr, gas)?;
-        let name = self.ctx.host_exports.ens_name_by_hash(&hash)?;
-        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.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>, DeterministicHostError> {
-        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>>, DeterministicHostError> {
-        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."
-        )))
-    }
+        // 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),
+                )
+            })?;
 
-    /// 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 40ca4722e1c..e917ffa2fa9 100644
--- a/runtime/wasm/src/to_from/external.rs
+++ b/runtime/wasm/src/to_from/external.rs
@@ -1,76 +1,75 @@
-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, ToAscObj};
+use graph::runtime::{
+    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, DeterministicHostError> {
-        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,
         gas: &GasCounter,
+        depth: usize,
     ) -> Result<Self, DeterministicHostError> {
-        let data = <[u8; 20]>::from_asc_obj(typed_array, heap, gas)?;
-        Ok(Self(data))
+        let data = <[u8; 20]>::from_asc_obj(typed_array, heap, gas, depth)?;
+        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,
-    ) -> Result<Self, DeterministicHostError> {
-        let data = <[u8; 32]>::from_asc_obj(typed_array, heap, gas)?;
-        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, DeterministicHostError> {
-        self.0.to_asc_obj(heap, gas)
+    ) -> Result<Uint8Array, HostExportError> {
+        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, DeterministicHostError> {
-        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, DeterministicHostError> {
+    ) -> Result<AscBigInt, HostExportError> {
         let bytes = self.to_signed_bytes_le();
-        bytes.to_asc_obj(heap, gas)
+        bytes.to_asc_obj(heap, gas).await
     }
 }
 
@@ -79,24 +78,26 @@ impl FromAscObj<AscBigInt> for BigInt {
         array_buffer: AscBigInt,
         heap: &H,
         gas: &GasCounter,
+        depth: usize,
     ) -> Result<Self, DeterministicHostError> {
-        let bytes = <Vec<u8>>::from_asc_obj(array_buffer, heap, gas)?;
-        Ok(BigInt::from_signed_bytes_le(&bytes))
+        let bytes = <Vec<u8>>::from_asc_obj(array_buffer, heap, gas, depth)?;
+        Ok(BigInt::from_signed_bytes_le(&bytes)?)
     }
 }
 
+#[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,
-    ) -> Result<AscBigDecimal, DeterministicHostError> {
+    ) -> Result<AscBigDecimal, HostExportError> {
         // From the docs: "Note that a positive exponent indicates a negative power of 10",
         // 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::from(digits), gas)?,
+            exp: asc_new(heap, &BigInt::from(-negative_exp), gas).await?,
+            digits: asc_new(heap, &BigInt::new(digits)?, gas).await?,
         })
     }
 }
@@ -106,9 +107,10 @@ impl FromAscObj<AscBigDecimal> for BigDecimal {
         big_decimal: AscBigDecimal,
         heap: &H,
         gas: &GasCounter,
+        depth: usize,
     ) -> Result<Self, DeterministicHostError> {
-        let digits: BigInt = asc_get(heap, big_decimal.digits, gas)?;
-        let exp: BigInt = asc_get(heap, big_decimal.exp, gas)?;
+        let digits: BigInt = asc_get(heap, big_decimal.digits, gas, depth)?;
+        let exp: BigInt = asc_get(heap, big_decimal.exp, gas, depth)?;
 
         let bytes = exp.to_signed_bytes_le();
         let mut byte_array = if exp >= 0.into() { [0; 8] } else { [255; 8] };
@@ -132,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>>, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Array::new(&content, heap, gas)
+    ) -> Result<Array<AscPtr<AscString>>, HostExportError> {
+        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>, DeterministicHostError> {
-        use ethabi::Token::*;
-
+    ) -> Result<AscEnum<EthereumValueKind>, HostExportError> {
         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 {
@@ -180,56 +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)?)
+                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)?)
+                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)?)
+                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)?;
-                Token::Int(n.to_signed_u256())
+                let n: BigInt = asc_get(heap, ptr, gas, depth)?;
+                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)?;
-                Token::Uint(n.to_unsigned_u256())
+                let n: BigInt = asc_get(heap, ptr, gas, depth)?;
+                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)?)
+
+                Self::String(asc_get(heap, ptr, gas, depth)?)
             }
             EthereumValueKind::FixedArray => {
                 let ptr: AscEnumArray<EthereumValueKind> = AscPtr::from(payload);
-                Token::FixedArray(asc_get(heap, ptr, gas)?)
+
+                Self::FixedArray(asc_get(heap, ptr, gas, depth)?)
             }
             EthereumValueKind::Array => {
                 let ptr: AscEnumArray<EthereumValueKind> = AscPtr::from(payload);
-                Token::Array(asc_get(heap, ptr, gas)?)
+
+                Self::Array(asc_get(heap, ptr, gas, depth)?)
             }
             EthereumValueKind::Tuple => {
                 let ptr: AscEnumArray<EthereumValueKind> = AscPtr::from(payload);
-                Token::Tuple(asc_get(heap, ptr, gas)?)
+
+                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)
     }
 }
 
@@ -238,6 +282,7 @@ impl FromAscObj<AscEnum<StoreValueKind>> for store::Value {
         asc_enum: AscEnum<StoreValueKind>,
         heap: &H,
         gas: &GasCounter,
+        depth: usize,
     ) -> Result<Self, DeterministicHostError> {
         use self::store::Value;
 
@@ -245,55 +290,65 @@ impl FromAscObj<AscEnum<StoreValueKind>> for store::Value {
         Ok(match asc_enum.kind {
             StoreValueKind::String => {
                 let ptr: AscPtr<AscString> = AscPtr::from(payload);
-                Value::String(asc_get(heap, ptr, gas)?)
+                Value::String(asc_get(heap, ptr, gas, depth)?)
             }
             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)?)
+                Value::BigDecimal(asc_get(heap, ptr, gas, depth)?)
             }
             StoreValueKind::Bool => Value::Bool(bool::from(payload)),
             StoreValueKind::Array => {
                 let ptr: AscEnumArray<StoreValueKind> = AscPtr::from(payload);
-                Value::List(asc_get(heap, ptr, gas)?)
+                Value::List(asc_get(heap, ptr, gas, depth)?)
             }
             StoreValueKind::Null => Value::Null,
             StoreValueKind::Bytes => {
                 let ptr: AscPtr<Uint8Array> = AscPtr::from(payload);
-                let array: Vec<u8> = asc_get(heap, ptr, gas)?;
+                let array: Vec<u8> = asc_get(heap, ptr, gas, depth)?;
                 Value::Bytes(array.as_slice().into())
             }
             StoreValueKind::BigInt => {
                 let ptr: AscPtr<AscBigInt> = AscPtr::from(payload);
-                let array: Vec<u8> = asc_get(heap, ptr, gas)?;
-                Value::BigInt(store::scalar::BigInt::from_signed_bytes_le(&array))
+                let array: Vec<u8> = asc_get(heap, ptr, gas, depth)?;
+                Value::BigInt(store::scalar::BigInt::from_signed_bytes_le(&array)?)
             }
         })
     }
 }
 
+#[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,
-    ) -> Result<AscEnum<StoreValueKind>, DeterministicHostError> {
+    ) -> Result<AscEnum<StoreValueKind>, HostExportError> {
         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::BigDecimal(n) => asc_new(heap, n, gas)?.into(),
+            Value::Int8(n) => EnumPayload::from(*n),
+            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()
             }
         };
@@ -306,46 +361,77 @@ 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, DeterministicHostError> {
+    ) -> 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.
-impl ToAscObj<AscEntity> for Vec<(String, store::Value)> {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+#[async_trait]
+impl ToAscObj<AscEntity> for Vec<(Word, store::Value)> {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
-    ) -> Result<AscEntity, DeterministicHostError> {
+    ) -> 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)> {
+    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).await?,
+        })
+    }
+}
+
+#[async_trait]
+impl ToAscObj<Array<AscPtr<AscEntity>>> for Vec<Vec<(Word, store::Value)>> {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
+        &self,
+        heap: &mut H,
+        gas: &GasCounter,
+    ) -> Result<Array<AscPtr<AscEntity>>, HostExportError> {
+        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,
-    ) -> Result<AscEnum<JsonValueKind>, DeterministicHostError> {
+    ) -> Result<AscEnum<JsonValueKind>, HostExportError> {
         use 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 {
@@ -369,33 +455,36 @@ 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>, DeterministicHostError> {
+    ) -> Result<AscWrapped<T>, HostExportError> {
         Ok(*self)
     }
 }
 
+#[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,
-    ) -> Result<AscResult<AscPtr<VAsc>, bool>, DeterministicHostError> {
+    ) -> Result<AscResult<AscPtr<VAsc>, bool>, HostExportError> {
         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(),
             },
@@ -403,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 ca4c20faa22..5318aac2fd2 100644
--- a/runtime/wasm/src/to_from/mod.rs
+++ b/runtime/wasm/src/to_from/mod.rs
@@ -1,34 +1,41 @@
+//! 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;
 
-use graph::runtime::{
-    asc_get, asc_new, gas::GasCounter, AscHeap, AscIndexId, AscPtr, AscType, AscValue,
-    DeterministicHostError, FromAscObj, ToAscObj,
+use graph::{
+    data::value::Word,
+    runtime::{
+        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>, DeterministicHostError> {
-        TypedArray::new(self, heap, gas)
+    ) -> Result<TypedArray<T>, HostExportError> {
+        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,
     ) -> Result<Self, DeterministicHostError> {
         typed_array.to_vec(heap, gas)
     }
@@ -37,8 +44,10 @@ 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,
     ) -> Result<Self, DeterministicHostError> {
         let v = typed_array.to_vec(heap, gas)?;
         let array = <[T; LEN]>::try_from(v)
@@ -47,23 +56,53 @@ 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,
+    ) -> Result<AscString, HostExportError> {
+        Ok(AscString::new(
+            &self.encode_utf16().collect::<Vec<_>>(),
+            heap.api_version(),
+        )?)
+    }
+}
+
+#[async_trait]
+impl ToAscObj<AscString> for &str {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         _gas: &GasCounter,
-    ) -> Result<AscString, DeterministicHostError> {
-        AscString::new(&self.encode_utf16().collect::<Vec<_>>(), heap.api_version())
+    ) -> Result<AscString, HostExportError> {
+        Ok(AscString::new(
+            &self.encode_utf16().collect::<Vec<_>>(),
+            heap.api_version(),
+        )?)
     }
 }
 
+#[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).await
+    }
+}
+
+#[async_trait]
+impl ToAscObj<AscString> for Word {
+    async fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,
         heap: &mut H,
         gas: &GasCounter,
-    ) -> Result<AscString, DeterministicHostError> {
-        self.as_str().to_asc_obj(heap, gas)
+    ) -> Result<AscString, HostExportError> {
+        self.as_str().to_asc_obj(heap, gas).await
     }
 }
 
@@ -72,6 +111,7 @@ impl FromAscObj<AscString> for String {
         asc_string: AscString,
         _: &H,
         _gas: &GasCounter,
+        _depth: usize,
     ) -> Result<Self, DeterministicHostError> {
         let mut string = String::from_utf16(asc_string.content())
             .map_err(|e| DeterministicHostError::from(anyhow::Error::from(e)))?;
@@ -84,15 +124,34 @@ impl FromAscObj<AscString> for String {
     }
 }
 
-impl<C: AscType + AscIndexId, T: ToAscObj<C>> ToAscObj<Array<AscPtr<C>>> for [T] {
-    fn to_asc_obj<H: AscHeap + ?Sized>(
+impl FromAscObj<AscString> for Word {
+    fn from_asc_obj<H: AscHeap + ?Sized>(
+        asc_string: AscString,
+
+        heap: &H,
+        gas: &GasCounter,
+        depth: usize,
+    ) -> Result<Self, DeterministicHostError> {
+        let string = String::from_asc_obj(asc_string, heap, gas, depth)?;
+
+        Ok(Word::from(string))
+    }
+}
+
+#[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>>, DeterministicHostError> {
-        let content: Result<Vec<_>, _> = self.iter().map(|x| asc_new(heap, x, gas)).collect();
-        let content = content?;
-        Array::new(&content, heap, gas)
+    ) -> Result<Array<AscPtr<C>>, HostExportError> {
+        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
     }
 }
 
@@ -101,11 +160,12 @@ impl<C: AscType + AscIndexId, T: FromAscObj<C>> FromAscObj<Array<AscPtr<C>>> for
         array: Array<AscPtr<C>>,
         heap: &H,
         gas: &GasCounter,
+        depth: usize,
     ) -> Result<Self, DeterministicHostError> {
         array
             .to_vec(heap, gas)?
             .into_iter()
-            .map(|x| asc_get(heap, x, gas))
+            .map(|x| asc_get(heap, x, gas, depth))
             .collect()
     }
 }
@@ -117,35 +177,41 @@ impl<K: AscType + AscIndexId, V: AscType + AscIndexId, T: FromAscObj<K>, U: From
         asc_entry: AscTypedMapEntry<K, V>,
         heap: &H,
         gas: &GasCounter,
+        depth: usize,
     ) -> Result<Self, DeterministicHostError> {
         Ok((
-            asc_get(heap, asc_entry.key, gas)?,
-            asc_get(heap, asc_entry.value, gas)?,
+            asc_get(heap, asc_entry.key, gas, depth)?,
+            asc_get(heap, asc_entry.value, gas, depth)?,
         ))
     }
 }
 
-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>, DeterministicHostError> {
+    ) -> 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,
@@ -154,8 +220,9 @@ where
         asc_map: AscTypedMap<K, V>,
         heap: &H,
         gas: &GasCounter,
+        depth: usize,
     ) -> Result<Self, DeterministicHostError> {
-        let entries: Vec<(T, U)> = asc_get(heap, asc_map.entries, gas)?;
-        Ok(HashMap::from_iter(entries.into_iter()))
+        let entries: Vec<(T, U)> = asc_get(heap, asc_map.entries, gas, depth)?;
+        Ok(HashMap::from_iter(entries))
     }
 }
diff --git a/rust-toolchain.toml b/rust-toolchain.toml
index f0d51c34aef..529ab8268aa 100644
--- a/rust-toolchain.toml
+++ b/rust-toolchain.toml
@@ -1,3 +1,9 @@
 [toolchain]
-channel = "1.66.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/scripts/README.md b/scripts/README.md
deleted file mode 100644
index c749a79d70f..00000000000
--- a/scripts/README.md
+++ /dev/null
@@ -1,19 +0,0 @@
-# Scripts
-
-## `release.sh`
-
-1. Checks that all workspace crates use the same version via `version.workspace = true`.
-2. Updates the version in the root `Cargo.toml` as indicated by the user: `major`, `minor`, or `patch`.
-3. Updates `Cargo.lock` via `cargo check --tests`.
-4. Adds the changes in a `Release vX.Y.Z` commit.
-
-Upon failure, the script will print some kind of error message and stop before committing the changes.
-
-### Usage
-
-The only argument it accepts is the type of release you want to do.
-
-```bash
-# E.g. you're on v0.28.0 and must relese v0.28.1.
-$ ./scripts/release.sh patch
-```
diff --git a/scripts/release.sh b/scripts/release.sh
deleted file mode 100755
index d86e6113e21..00000000000
--- a/scripts/release.sh
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/env bash
-set -eo pipefail
-
-# TODO: Maybe we should revert all changes if the script fails halfway through?
-
-abort () {
-  local FAIL_MSG=$@
-  echo "$FAIL_MSG"
-  exit 1
-}
-
-abort_failed_to_update () {
-  local FILE_NAME=$@
-  abort "💀 Failed to update $FILE_NAME. Aborting."
-}
-
-assert_all_cargo_tomls_inherit_version () {
-  ERROR=0
-  # Get all files named Cargo.toml excluding the `integration-tests` folder and
-  # the root Cargo.toml.
-  CARGO_TOMLS=$(
-    find . -name Cargo.toml | \
-    grep -v integration-tests | \
-    grep -v '\./Cargo.toml'
-  )
-  for CARGO_TOML in $CARGO_TOMLS
-  do
-    # Good files have a line that looks like `version.workspace = true`. Bad
-    # files don't.
-    VERSION_LINE=$(grep '^version' $CARGO_TOML)
-    if [[ $VERSION_LINE != "version.workspace = true" ]]; then
-      echo "⚠️  $CARGO_TOML does not inherit the crate version from the root workspace."
-      ERROR=1
-    fi
-  done
-
-  if [[ $ERROR == 1 ]]; then
-    echo "💀 All crates must inherit the workspace's crate version."
-    echo "   <https://doc.rust-lang.org/cargo/reference/workspaces.html#the-package-table>"
-    abort "   Aborting."
-  fi
-}
-
-get_toml_version () {
-  echo $(grep '^version =' Cargo.toml | cut -d '"' -f2)
-}
-
-main () {
-  CURRENT_VERSION=$(get_toml_version)
-  assert_all_cargo_tomls_inherit_version
-
-  # Increment by CLI argument (major, minor, patch)
-  MAJOR=$(echo $CURRENT_VERSION | cut -d. -f1)
-  MINOR=$(echo $CURRENT_VERSION | cut -d. -f2)
-  PATCH=$(echo $CURRENT_VERSION | cut -d. -f3)
-
-  case $1 in
-    "major")
-      let "++MAJOR"
-      MINOR=0
-      PATCH=0
-      ;;
-    "minor")
-      # Preincrement to avoid early exit with set -e:
-      # https://stackoverflow.com/questions/7247279/bash-set-e-and-i-0let-i-do-not-agree
-      let "++MINOR"
-      PATCH=0
-      ;;
-    "patch")
-      let "++PATCH"
-      ;;
-    *)
-      abort "💀 Bad CLI usage! Version argument should be one of: major, minor or patch"
-      ;;
-  esac
-
-  echo " - Current version: \"$CURRENT_VERSION\""
-  NEW_VERSION="${MAJOR}.${MINOR}.${PATCH}"
-  echo " - New version: \"$NEW_VERSION\""
-
-  echo "⏳ Updating Cargo.toml..."
-
-  # Works both on GNU and BSD sed (for macOS users)
-  # See:
-  # - https://unix.stackexchange.com/questions/401905/bsd-sed-vs-gnu-sed-and-i
-  # - https://stackoverflow.com/a/22084103/5148606
-  sed -i.backup "s/^version = \"${CURRENT_VERSION}\"/version = \"${NEW_VERSION}\"/g" Cargo.toml
-  rm Cargo.toml.backup
-
-  if [[ $(git diff Cargo.toml) ]]; then
-    echo "✅ Cargo.toml successfully updated."
-  else
-    abort_failed_to_update Cargo.toml
-  fi
-
-  echo "⏳ Updating Cargo.lock..."
-  cargo check --tests
-  if [[ $(git diff Cargo.lock) ]]; then
-    echo "✅ Cargo.lock successfully updated."
-  else
-    abort_failed_to_update Cargo.lock
-  fi
-
-  echo "⏳ Committing changes..."
-  git add Cargo.lock Cargo.toml
-  git commit -m "Release v${NEW_VERSION}"
-
-  echo "🎉 Done!"
-}
-
-main "$@"
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 41e2efb80c6..3c1e4b9058c 100644
--- a/server/http/Cargo.toml
+++ b/server/http/Cargo.toml
@@ -4,13 +4,10 @@ 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" }
 
 [dev-dependencies]
-graph-mock = { path = "../../mock" }
+graph-core = { path = "../../core" }
diff --git a/server/http/assets/index.html b/server/http/assets/index.html
index 7b049eaa2b7..015c8ac7408 100644
--- a/server/http/assets/index.html
+++ b/server/http/assets/index.html
@@ -3,87049 +3,39 @@
   <head>
     <meta charset="utf-8" />
     <title>The GraphiQL</title>
-    <style>
-      .graphiql-container,
-      .graphiql-container button,
-      .graphiql-container input {
-        color: #141823;
-        font-family: system, -apple-system, San Francisco,
-          ".SFNSDisplay-Regular", Segoe UI, Segoe, Segoe WP, Helvetica Neue,
-          helvetica, Lucida Grande, arial, sans-serif;
-        font-size: 14px;
-      }
-      .graphiql-container {
-        display: flex;
-        flex-direction: row;
-        height: 100%;
-        margin: 0;
-        overflow: hidden;
-        width: 100%;
-      }
-      .graphiql-container .editorWrap {
-        display: flex;
-        flex-direction: column;
-        flex: 1;
-        overflow-x: hidden;
-      }
-      .graphiql-container .title {
-        font-size: 18px;
-      }
-      .graphiql-container .title em {
-        font-family: georgia;
-        font-size: 19px;
-      }
-      .graphiql-container .topBarWrap {
-        display: flex;
-        flex-direction: row;
-      }
-      .graphiql-container .topBar {
-        align-items: center;
-        background: linear-gradient(#f7f7f7, #e2e2e2);
-        border-bottom: 1px solid #d0d0d0;
-        cursor: default;
-        display: flex;
-        flex-direction: row;
-        flex: 1;
-        height: 34px;
-        overflow-y: visible;
-        padding: 7px 14px 6px;
-        user-select: none;
-      }
-      .graphiql-container .toolbar {
-        overflow-x: visible;
-        display: flex;
-      }
-      .graphiql-container .docExplorerShow,
-      .graphiql-container .historyShow {
-        background: linear-gradient(#f7f7f7, #e2e2e2);
-        border-radius: 0;
-        border-bottom: 1px solid #d0d0d0;
-        border-right: none;
-        border-top: none;
-        color: #3b5998;
-        cursor: pointer;
-        font-size: 14px;
-        margin: 0;
-        padding: 2px 20px 0 18px;
-      }
-      .graphiql-container .docExplorerShow {
-        border-left: 1px solid rgba(0, 0, 0, 0.2);
-      }
-      .graphiql-container .historyShow {
-        border-right: 1px solid rgba(0, 0, 0, 0.2);
-        border-left: 0;
-      }
-      .graphiql-container .docExplorerShow:before {
-        border-left: 2px solid #3b5998;
-        border-top: 2px solid #3b5998;
-        content: "";
-        display: inline-block;
-        height: 9px;
-        margin: 0 3px -1px 0;
-        position: relative;
-        transform: rotate(-45deg);
-        width: 9px;
-      }
-      .graphiql-container .editorBar {
-        display: flex;
-        flex-direction: row;
-        flex: 1;
-        max-height: 100%;
-      }
-      .graphiql-container .queryWrap {
-        display: flex;
-        flex-direction: column;
-        flex: 1;
-      }
-      .graphiql-container .resultWrap {
-        border-left: solid 1px #e0e0e0;
-        display: flex;
-        flex-direction: column;
-        flex: 1;
-        flex-basis: 1em;
-        position: relative;
-      }
-      .graphiql-container .docExplorerWrap,
-      .graphiql-container .historyPaneWrap {
-        background: white;
-        box-shadow: 0 0 8px #00000026;
-        position: relative;
-        z-index: 3;
-      }
-      .graphiql-container .historyPaneWrap {
-        min-width: 230px;
-        z-index: 5;
-      }
-      .graphiql-container .docExplorerResizer {
-        cursor: col-resize;
-        height: 100%;
-        left: -5px;
-        position: absolute;
-        top: 0;
-        width: 10px;
-        z-index: 10;
-      }
-      .graphiql-container .docExplorerHide {
-        cursor: pointer;
-        font-size: 18px;
-        margin: -7px -8px -6px 0;
-        padding: 18px 16px 15px 12px;
-        background: 0;
-        border: 0;
-        line-height: 14px;
-      }
-      .graphiql-container div .query-editor {
-        flex: 1;
-        position: relative;
-      }
-      .graphiql-container .secondary-editor {
-        display: flex;
-        flex-direction: column;
-        height: 30px;
-        position: relative;
-      }
-      .graphiql-container .secondary-editor-title {
-        background: #eeeeee;
-        border-bottom: 1px solid #d6d6d6;
-        border-top: 1px solid #e0e0e0;
-        color: #777;
-        font-variant: small-caps;
-        font-weight: 700;
-        letter-spacing: 1px;
-        line-height: 14px;
-        padding: 6px 0 8px 43px;
-        text-transform: lowercase;
-        user-select: none;
-      }
-      .graphiql-container .codemirrorWrap,
-      .graphiql-container .result-window {
-        flex: 1;
-        height: 100%;
-        position: relative;
-      }
-      .graphiql-container .footer {
-        background: #f6f7f8;
-        border-left: 1px solid #e0e0e0;
-        border-top: 1px solid #e0e0e0;
-        margin-left: 12px;
-        position: relative;
-      }
-      .graphiql-container .footer:before {
-        background: #eeeeee;
-        bottom: 0;
-        content: " ";
-        left: -13px;
-        position: absolute;
-        top: -1px;
-        width: 12px;
-      }
-      .result-window .CodeMirror.cm-s-graphiql {
-        background: #f6f7f8;
-      }
-      .graphiql-container .result-window .CodeMirror-gutters {
-        background-color: #eee;
-        border-color: #e0e0e0;
-        cursor: col-resize;
-      }
-      .graphiql-container .result-window .CodeMirror-foldgutter,
-      .graphiql-container .result-window .CodeMirror-foldgutter-open:after,
-      .graphiql-container .result-window .CodeMirror-foldgutter-folded:after {
-        padding-left: 3px;
-      }
-      .graphiql-container .toolbar-button {
-        background: #fdfdfd;
-        background: linear-gradient(#f9f9f9, #ececec);
-        border: 0;
-        border-radius: 3px;
-        box-shadow: inset 0 0 0 1px #0003, 0 1px #ffffffb3, inset 0 1px #fff;
-        color: #555;
-        cursor: pointer;
-        display: inline-block;
-        margin: 0 5px;
-        padding: 3px 11px 5px;
-        text-decoration: none;
-        text-overflow: ellipsis;
-        white-space: nowrap;
-        max-width: 150px;
-      }
-      .graphiql-container .toolbar-button:active {
-        background: linear-gradient(#ececec, #d5d5d5);
-        box-shadow: 0 1px #ffffffb3, inset 0 0 0 1px #0000001a,
-          inset 0 1px 1px 1px #0000001f, inset 0 0 5px #0000001a;
-      }
-      .graphiql-container .toolbar-button.error {
-        background: linear-gradient(#fdf3f3, #e6d6d7);
-        color: #b00;
-      }
-      .graphiql-container .toolbar-button-group {
-        margin: 0 5px;
-        white-space: nowrap;
-      }
-      .graphiql-container .toolbar-button-group > * {
-        margin: 0;
-      }
-      .graphiql-container .toolbar-button-group > *:not(:last-child) {
-        border-top-right-radius: 0;
-        border-bottom-right-radius: 0;
-      }
-      .graphiql-container .toolbar-button-group > *:not(:first-child) {
-        border-top-left-radius: 0;
-        border-bottom-left-radius: 0;
-        margin-left: -1px;
-      }
-      .graphiql-container .execute-button-wrap {
-        height: 34px;
-        margin: 0 14px 0 28px;
-        position: relative;
-      }
-      .graphiql-container .execute-button {
-        background: linear-gradient(#fdfdfd, #d2d3d6);
-        border-radius: 17px;
-        border: 1px solid rgba(0, 0, 0, 0.25);
-        box-shadow: 0 1px #fff;
-        cursor: pointer;
-        fill: #444;
-        height: 34px;
-        margin: 0;
-        padding: 0;
-        width: 34px;
-      }
-      .graphiql-container .execute-button svg {
-        pointer-events: none;
-      }
-      .graphiql-container .execute-button:active {
-        background: linear-gradient(#e6e6e6, #c3c3c3);
-        box-shadow: 0 1px #fff, inset 0 0 2px #0003, inset 0 0 6px #0000001a;
-      }
-      .graphiql-container .toolbar-menu,
-      .graphiql-container .toolbar-select {
-        position: relative;
-      }
-      .graphiql-container .execute-options,
-      .graphiql-container .toolbar-menu-items,
-      .graphiql-container .toolbar-select-options {
-        background: #fff;
-        box-shadow: 0 0 0 1px #0000001a, 0 2px 4px #00000040;
-        margin: 0;
-        padding: 6px 0;
-        position: absolute;
-        z-index: 100;
-      }
-      .graphiql-container .execute-options {
-        min-width: 100px;
-        top: 37px;
-        left: -1px;
-      }
-      .graphiql-container .toolbar-menu-items {
-        left: 1px;
-        margin-top: -1px;
-        min-width: 110%;
-        top: 100%;
-        visibility: hidden;
-      }
-      .graphiql-container .toolbar-menu-items.open {
-        visibility: visible;
-      }
-      .graphiql-container .toolbar-select-options {
-        left: 0;
-        min-width: 100%;
-        top: -5px;
-        visibility: hidden;
-      }
-      .graphiql-container .toolbar-select-options.open {
-        visibility: visible;
-      }
-      .graphiql-container .execute-options > li,
-      .graphiql-container .toolbar-menu-items > li,
-      .graphiql-container .toolbar-select-options > li {
-        cursor: pointer;
-        display: block;
-        margin: none;
-        max-width: 300px;
-        overflow: hidden;
-        padding: 2px 20px 4px 11px;
-        white-space: nowrap;
-      }
-      .graphiql-container .execute-options > li.selected,
-      .graphiql-container .toolbar-menu-items > li.hover,
-      .graphiql-container .toolbar-menu-items > li:active,
-      .graphiql-container .toolbar-menu-items > li:hover,
-      .graphiql-container .toolbar-select-options > li.hover,
-      .graphiql-container .toolbar-select-options > li:active,
-      .graphiql-container .toolbar-select-options > li:hover,
-      .graphiql-container .history-contents > li:hover,
-      .graphiql-container .history-contents > li:active {
-        background: #e10098;
-        color: #fff;
-      }
-      .graphiql-container .toolbar-select-options > li > svg {
-        display: inline;
-        fill: #666;
-        margin: 0 -6px 0 6px;
-        pointer-events: none;
-        vertical-align: middle;
-      }
-      .graphiql-container .toolbar-select-options > li.hover > svg,
-      .graphiql-container .toolbar-select-options > li:active > svg,
-      .graphiql-container .toolbar-select-options > li:hover > svg {
-        fill: #fff;
-      }
-      .graphiql-container .CodeMirror-scroll {
-        overflow-scrolling: touch;
-      }
-      .graphiql-container .CodeMirror {
-        color: #141823;
-        font-family: Consolas, Inconsolata, Droid Sans Mono, Monaco, monospace;
-        font-size: 13px;
-        height: 100%;
-        left: 0;
-        position: absolute;
-        top: 0;
-        width: 100%;
-      }
-      .graphiql-container .CodeMirror-lines {
-        padding: 20px 0;
-      }
-      .CodeMirror-hint-information .content {
-        box-orient: vertical;
-        color: #141823;
-        display: flex;
-        font-family: system, -apple-system, San Francisco,
-          ".SFNSDisplay-Regular", Segoe UI, Segoe, Segoe WP, Helvetica Neue,
-          helvetica, Lucida Grande, arial, sans-serif;
-        font-size: 13px;
-        line-clamp: 3;
-        line-height: 16px;
-        max-height: 48px;
-        overflow: hidden;
-        text-overflow: -o-ellipsis-lastline;
-      }
-      .CodeMirror-hint-information .content p:first-child {
-        margin-top: 0;
-      }
-      .CodeMirror-hint-information .content p:last-child {
-        margin-bottom: 0;
-      }
-      .CodeMirror-hint-information .infoType {
-        color: #ca9800;
-        cursor: pointer;
-        display: inline;
-        margin-right: 0.5em;
-      }
-      .autoInsertedLeaf.cm-property {
-        animation-duration: 6s;
-        animation-name: insertionFade;
-        border-bottom: 2px solid rgba(255, 255, 255, 0);
-        border-radius: 2px;
-        margin: -2px -4px -1px;
-        padding: 2px 4px 1px;
-      }
-      @keyframes insertionFade {
-        0%,
-        to {
-          background: rgba(255, 255, 255, 0);
-          border-color: #fff0;
-        }
-        15%,
-        85% {
-          background: #fbffc9;
-          border-color: #f0f3c0;
-        }
-      }
-      div.CodeMirror-lint-tooltip {
-        background-color: #fff;
-        border-radius: 2px;
-        border: 0;
-        color: #141823;
-        box-shadow: 0 1px 3px #00000073;
-        font-size: 13px;
-        line-height: 16px;
-        max-width: 430px;
-        opacity: 0;
-        padding: 8px 10px;
-        transition: opacity 0.15s;
-        white-space: pre-wrap;
-      }
-      div.CodeMirror-lint-tooltip > * {
-        padding-left: 23px;
-      }
-      div.CodeMirror-lint-tooltip > * + * {
-        margin-top: 12px;
-      }
-      .graphiql-container .variable-editor-title-text {
-        cursor: pointer;
-        display: inline-block;
-        color: gray;
-      }
-      .graphiql-container .variable-editor-title-text.active {
-        color: #000;
-      }
-      .graphiql-container .tabs {
-        height: 42px;
-        background-image: linear-gradient(#f7f7f7, #e2e2e2);
-        display: flex;
-        align-items: center;
-      }
-      .graphiql-container .tab {
-        position: relative;
-        cursor: pointer;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        padding-top: 0;
-        padding-right: 6px;
-        padding-left: 14px;
-        height: 100%;
-        color: #0009;
-        border-left: 1px solid lightgray;
-        border-top-style: none;
-        border-bottom-style: none;
-        border-right-style: none;
-      }
-      .graphiql-container .tab:first-child:nth-last-child(2) {
-        padding-right: 14px;
-      }
-      .graphiql-container .tab:hover {
-        background-image: linear-gradient(
-          rgba(245, 245, 245, 0.7),
-          rgba(215, 215, 215, 1)
-        );
-        color: #000c;
-      }
-      .graphiql-container .tab.active {
-        background-image: linear-gradient(
-          rgba(233, 233, 233, 0.7),
-          rgba(205, 205, 205, 1)
-        );
-        color: #000;
-      }
-      .graphiql-container .tab .close {
-        display: inline-block;
-        cursor: pointer;
-        border: none;
-        background: transparent;
-        margin-left: 6px;
-        padding: 3px 6px;
-        border-radius: 4px;
-      }
-      .graphiql-container .tab:hover .close,
-      .graphiql-container .tab.active .close {
-        opacity: 1;
-      }
-      .graphiql-container .tab .close:before {
-        content: "\2715";
-        display: inline-block;
-        font-weight: 700;
-        font-size: 12px;
-        color: #000000b3;
-        height: 14px;
-      }
-      .graphiql-container .tab .close:hover {
-        background: rgba(0, 0, 0, 0.08);
-      }
-      .graphiql-container .tab .close:active {
-        background: rgba(0, 0, 0, 0.12);
-      }
-      .graphiql-container .tab-add {
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        border: none;
-        background: transparent;
-        line-height: 1;
-        font-size: 26px;
-        padding: 0 8px 3px;
-        height: 30px;
-        border-radius: 4px;
-        color: #00000080;
-        margin-left: 6px;
-        cursor: pointer;
-      }
-      .graphiql-container .tab-add:hover {
-        background: rgba(0, 0, 0, 0.06);
-      }
-      .graphiql-container .tab-add:active {
-        background: rgba(0, 0, 0, 0.1);
-      }
-      .graphiql-container .CodeMirror-foldmarker {
-        border-radius: 4px;
-        background: #08f;
-        background: linear-gradient(#43a8ff, #0f83e8);
-        box-shadow: 0 1px 1px #0003, inset 0 0 0 1px #0000001a;
-        color: #fff;
-        font-family: arial;
-        font-size: 12px;
-        line-height: 0;
-        margin: 0 3px;
-        padding: 0 4px 1px;
-        text-shadow: 0 -1px rgba(0, 0, 0, 0.1);
-      }
-      .graphiql-container div.CodeMirror span.CodeMirror-matchingbracket {
-        color: #555;
-        text-decoration: underline;
-      }
-      .graphiql-container div.CodeMirror span.CodeMirror-nonmatchingbracket {
-        color: red;
-      }
-      .cm-comment {
-        color: #666;
-      }
-      .cm-punctuation {
-        color: #555;
-      }
-      .cm-keyword {
-        color: #b11a04;
-      }
-      .cm-def {
-        color: #d2054e;
-      }
-      .cm-property {
-        color: #1f61a0;
-      }
-      .cm-qualifier {
-        color: #1c92a9;
-      }
-      .cm-attribute {
-        color: #8b2bb9;
-      }
-      .cm-number {
-        color: #2882f9;
-      }
-      .cm-string {
-        color: #d64292;
-      }
-      .cm-builtin {
-        color: #d47509;
-      }
-      .cm-string-2 {
-        color: #0b7fc7;
-      }
-      .cm-variable {
-        color: #397d13;
-      }
-      .cm-meta {
-        color: #b33086;
-      }
-      .cm-atom {
-        color: #ca9800;
-      }
-      .CodeMirror {
-        color: #000;
-        font-family: monospace;
-        height: 300px;
-      }
-      .CodeMirror-lines {
-        padding: 4px 0;
-      }
-      .CodeMirror pre {
-        padding: 0 4px;
-      }
-      .CodeMirror-scrollbar-filler,
-      .CodeMirror-gutter-filler {
-        background-color: #fff;
-      }
-      .CodeMirror-gutters {
-        border-right: 1px solid #ddd;
-        background-color: #f7f7f7;
-        white-space: nowrap;
-      }
-      .CodeMirror-linenumber {
-        color: #666;
-        min-width: 20px;
-        padding: 0 3px 0 5px;
-        text-align: right;
-        white-space: nowrap;
-      }
-      .CodeMirror-guttermarker {
-        color: #000;
-      }
-      .CodeMirror-guttermarker-subtle {
-        color: #666;
-      }
-      .CodeMirror .CodeMirror-cursor {
-        border-left: 1px solid black;
-      }
-      .CodeMirror div.CodeMirror-secondarycursor {
-        border-left: 1px solid silver;
-      }
-      .CodeMirror.cm-fat-cursor div.CodeMirror-cursor {
-        background: #7e7;
-        border: 0;
-        width: auto;
-      }
-      .CodeMirror.cm-fat-cursor div.CodeMirror-cursors {
-        z-index: 1;
-      }
-      .cm-animate-fat-cursor {
-        animation: blink 1.06s steps(1) infinite;
-        border: 0;
-        width: auto;
-      }
-      @keyframes blink {
-        0% {
-          background: #7e7;
-        }
-        50% {
-          background: none;
-        }
-        to {
-          background: #7e7;
-        }
-      }
-      .cm-tab {
-        display: inline-block;
-        text-decoration: inherit;
-      }
-      .CodeMirror-ruler {
-        border-left: 1px solid #ccc;
-        position: absolute;
-      }
-      .cm-s-default .cm-keyword {
-        color: #708;
-      }
-      .cm-s-default .cm-atom {
-        color: #219;
-      }
-      .cm-s-default .cm-number {
-        color: #164;
-      }
-      .cm-s-default .cm-def {
-        color: #00f;
-      }
-      .cm-s-default .cm-variable-2 {
-        color: #05a;
-      }
-      .cm-s-default .cm-variable-3 {
-        color: #085;
-      }
-      .cm-s-default .cm-comment {
-        color: #a50;
-      }
-      .cm-s-default .cm-string {
-        color: #a11;
-      }
-      .cm-s-default .cm-string-2 {
-        color: #f50;
-      }
-      .cm-s-default .cm-meta,
-      .cm-s-default .cm-qualifier {
-        color: #555;
-      }
-      .cm-s-default .cm-builtin {
-        color: #30a;
-      }
-      .cm-s-default .cm-bracket {
-        color: #666;
-      }
-      .cm-s-default .cm-tag {
-        color: #170;
-      }
-      .cm-s-default .cm-attribute {
-        color: #00c;
-      }
-      .cm-s-default .cm-header {
-        color: #00f;
-      }
-      .cm-s-default .cm-quote {
-        color: #090;
-      }
-      .cm-s-default .cm-hr {
-        color: #666;
-      }
-      .cm-s-default .cm-link {
-        color: #00c;
-      }
-      .cm-negative {
-        color: #d44;
-      }
-      .cm-positive {
-        color: #292;
-      }
-      .cm-header,
-      .cm-strong {
-        font-weight: 700;
-      }
-      .cm-em {
-        font-style: italic;
-      }
-      .cm-link {
-        text-decoration: underline;
-      }
-      .cm-strikethrough {
-        text-decoration: line-through;
-      }
-      .cm-s-default .cm-error,
-      .cm-invalidchar {
-        color: red;
-      }
-      .CodeMirror-composing {
-        border-bottom: 2px solid;
-      }
-      div.CodeMirror span.CodeMirror-matchingbracket {
-        color: #0f0;
-      }
-      div.CodeMirror span.CodeMirror-nonmatchingbracket {
-        color: #f22;
-      }
-      .CodeMirror-matchingtag {
-        background: rgba(255, 150, 0, 0.3);
-      }
-      .CodeMirror-activeline-background {
-        background: #e8f2ff;
-      }
-      .CodeMirror {
-        background: white;
-        overflow: hidden;
-        position: relative;
-      }
-      .CodeMirror-scroll {
-        height: 100%;
-        margin-bottom: -30px;
-        margin-right: -30px;
-        outline: none;
-        overflow: scroll !important;
-        padding-bottom: 30px;
-        position: relative;
-      }
-      .CodeMirror-sizer {
-        border-right: 30px solid transparent;
-        position: relative;
-      }
-      .CodeMirror-vscrollbar,
-      .CodeMirror-hscrollbar,
-      .CodeMirror-scrollbar-filler,
-      .CodeMirror-gutter-filler {
-        display: none;
-        position: absolute;
-        z-index: 6;
-      }
-      .CodeMirror-vscrollbar {
-        overflow-x: hidden;
-        overflow-y: scroll;
-        right: 0;
-        top: 0;
-      }
-      .CodeMirror-hscrollbar {
-        bottom: 0;
-        left: 0;
-        overflow-x: scroll;
-        overflow-y: hidden;
-      }
-      .CodeMirror-scrollbar-filler {
-        right: 0;
-        bottom: 0;
-      }
-      .CodeMirror-gutter-filler {
-        left: 0;
-        bottom: 0;
-      }
-      .CodeMirror-gutters {
-        min-height: 100%;
-        position: absolute;
-        left: 0;
-        top: 0;
-        z-index: 3;
-      }
-      .CodeMirror-gutter {
-        display: inline-block;
-        height: 100%;
-        margin-bottom: -30px;
-        vertical-align: top;
-        white-space: normal;
-      }
-      .CodeMirror-gutter-wrapper {
-        background: none !important;
-        border: none !important;
-        position: absolute;
-        z-index: 4;
-      }
-      .CodeMirror-gutter-background {
-        position: absolute;
-        top: 0;
-        bottom: 0;
-        z-index: 4;
-      }
-      .CodeMirror-gutter-elt {
-        cursor: default;
-        position: absolute;
-        z-index: 4;
-      }
-      .CodeMirror-gutter-wrapper {
-        user-select: none;
-      }
-      .CodeMirror-lines {
-        cursor: text;
-        min-height: 1px;
-      }
-      .CodeMirror pre {
-        -webkit-tap-highlight-color: transparent;
-        background: transparent;
-        border-radius: 0;
-        border-width: 0;
-        color: inherit;
-        font-family: inherit;
-        font-size: inherit;
-        font-variant-ligatures: none;
-        line-height: inherit;
-        margin: 0;
-        overflow: visible;
-        position: relative;
-        white-space: pre;
-        word-wrap: normal;
-        z-index: 2;
-      }
-      .CodeMirror-wrap pre {
-        word-wrap: break-word;
-        white-space: pre-wrap;
-        word-break: normal;
-      }
-      .CodeMirror-linebackground {
-        position: absolute;
-        left: 0;
-        right: 0;
-        top: 0;
-        bottom: 0;
-        z-index: 0;
-      }
-      .CodeMirror-linewidget {
-        overflow: auto;
-        position: relative;
-        z-index: 2;
-      }
-      .CodeMirror-code {
-        outline: none;
-      }
-      .CodeMirror-scroll,
-      .CodeMirror-sizer,
-      .CodeMirror-gutter,
-      .CodeMirror-gutters,
-      .CodeMirror-linenumber {
-        box-sizing: content-box;
-      }
-      .CodeMirror-measure {
-        height: 0;
-        overflow: hidden;
-        position: absolute;
-        visibility: hidden;
-        width: 100%;
-      }
-      .CodeMirror-cursor {
-        position: absolute;
-      }
-      .CodeMirror-measure pre {
-        position: static;
-      }
-      div.CodeMirror-cursors {
-        position: relative;
-        visibility: hidden;
-        z-index: 3;
-      }
-      div.CodeMirror-dragcursors,
-      .CodeMirror-focused div.CodeMirror-cursors {
-        visibility: visible;
-      }
-      .CodeMirror-selected {
-        background: #d9d9d9;
-      }
-      .CodeMirror-focused .CodeMirror-selected {
-        background: #d7d4f0;
-      }
-      .CodeMirror-crosshair {
-        cursor: crosshair;
-      }
-      .CodeMirror-line::selection,
-      .CodeMirror-line > span::selection,
-      .CodeMirror-line > span > span::selection {
-        background: #d7d4f0;
-      }
-      .CodeMirror-line::-moz-selection,
-      .CodeMirror-line > span::-moz-selection,
-      .CodeMirror-line > span > span::-moz-selection {
-        background: #d7d4f0;
-      }
-      .cm-searching {
-        background: #ffa;
-        background: rgba(255, 255, 0, 0.4);
-      }
-      .cm-force-border {
-        padding-right: 0.1px;
-      }
-      @media print {
-        .CodeMirror div.CodeMirror-cursors {
-          visibility: hidden;
-        }
-      }
-      .cm-tab-wrap-hack:after {
-        content: "";
-      }
-      span.CodeMirror-selectedtext {
-        background: none;
-      }
-      .CodeMirror-dialog {
-        background: inherit;
-        color: inherit;
-        left: 0;
-        right: 0;
-        overflow: hidden;
-        padding: 0.1em 0.8em;
-        position: absolute;
-        z-index: 15;
-      }
-      .CodeMirror-dialog-top {
-        border-bottom: 1px solid #eee;
-        top: 0;
-      }
-      .CodeMirror-dialog-bottom {
-        border-top: 1px solid #eee;
-        bottom: 0;
-      }
-      .CodeMirror-dialog input {
-        background: transparent;
-        border: 1px solid #d3d6db;
-        color: inherit;
-        font-family: monospace;
-        outline: none;
-        width: 20em;
-      }
-      .CodeMirror-dialog button {
-        font-size: 70%;
-      }
-      .CodeMirror-foldmarker {
-        color: #00f;
-        cursor: pointer;
-        font-family: arial;
-        line-height: 0.3;
-        text-shadow: #b9f 1px 1px 2px, #b9f -1px -1px 2px, #b9f 1px -1px 2px,
-          #b9f -1px 1px 2px;
-      }
-      .CodeMirror-foldgutter {
-        width: 0.7em;
-      }
-      .CodeMirror-foldgutter-open,
-      .CodeMirror-foldgutter-folded {
-        cursor: pointer;
-      }
-      .CodeMirror-foldgutter-open:after {
-        content: "\25be";
-      }
-      .CodeMirror-foldgutter-folded:after {
-        content: "\25b8";
-      }
-      .CodeMirror-info {
-        background: white;
-        border-radius: 2px;
-        box-shadow: 0 1px 3px #00000073;
-        box-sizing: border-box;
-        color: #555;
-        font-family: system, -apple-system, San Francisco,
-          ".SFNSDisplay-Regular", Segoe UI, Segoe, Segoe WP, Helvetica Neue,
-          helvetica, Lucida Grande, arial, sans-serif;
-        font-size: 13px;
-        line-height: 16px;
-        margin: 8px -8px;
-        max-width: 400px;
-        opacity: 0;
-        overflow: hidden;
-        padding: 8px;
-        position: fixed;
-        transition: opacity 0.15s;
-        z-index: 50;
-      }
-      .CodeMirror-info :first-child {
-        margin-top: 0;
-      }
-      .CodeMirror-info :last-child {
-        margin-bottom: 0;
-      }
-      .CodeMirror-info p {
-        margin: 1em 0;
-      }
-      .CodeMirror-info .info-description {
-        color: #777;
-        line-height: 16px;
-        margin-top: 1em;
-        max-height: 80px;
-        overflow: hidden;
-      }
-      .CodeMirror-info .info-deprecation {
-        background: #fffae8;
-        box-shadow: inset 0 1px 1px -1px #bfb063;
-        color: #867f70;
-        line-height: 16px;
-        margin: 8px -8px -8px;
-        max-height: 80px;
-        overflow: hidden;
-        padding: 8px;
-      }
-      .CodeMirror-info .info-deprecation-label {
-        color: #c79b2e;
-        cursor: default;
-        display: block;
-        font-size: 9px;
-        font-weight: 700;
-        letter-spacing: 1px;
-        line-height: 1;
-        padding-bottom: 5px;
-        text-transform: uppercase;
-        user-select: none;
-      }
-      .CodeMirror-info .info-deprecation-label + * {
-        margin-top: 0;
-      }
-      .CodeMirror-info a {
-        text-decoration: none;
-      }
-      .CodeMirror-info a:hover {
-        text-decoration: underline;
-      }
-      .CodeMirror-info .type-name {
-        color: #ca9800;
-      }
-      .CodeMirror-info .field-name {
-        color: #1f61a0;
-      }
-      .CodeMirror-info .enum-value {
-        color: #0b7fc7;
-      }
-      .CodeMirror-info .arg-name {
-        color: #8b2bb9;
-      }
-      .CodeMirror-info .directive-name {
-        color: #b33086;
-      }
-      .CodeMirror-jump-token {
-        text-decoration: underline;
-        cursor: pointer;
-      }
-      .CodeMirror-lint-markers {
-        width: 16px;
-      }
-      .CodeMirror-lint-tooltip {
-        background-color: infobackground;
-        border-radius: 4px;
-        border: 1px solid black;
-        color: infotext;
-        font-family: monospace;
-        font-size: 10pt;
-        max-width: 600px;
-        opacity: 0;
-        overflow: hidden;
-        padding: 2px 5px;
-        position: fixed;
-        transition: opacity 0.4s;
-        white-space: pre-wrap;
-        z-index: 100;
-      }
-      .CodeMirror-lint-mark-error,
-      .CodeMirror-lint-mark-warning {
-        background-position: left bottom;
-        background-repeat: repeat-x;
-      }
-      .CodeMirror-lint-mark-error {
-        background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJDw4cOCW1/KIAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAHElEQVQI12NggIL/DAz/GdA5/xkY/qPKMDAwAADLZwf5rvm+LQAAAABJRU5ErkJggg==);
-      }
-      .CodeMirror-lint-mark-warning {
-        background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAQAAAADCAYAAAC09K7GAAAAAXNSR0IArs4c6QAAAAZiS0dEAP8A/wD/oL2nkwAAAAlwSFlzAAALEwAACxMBAJqcGAAAAAd0SU1FB9sJFhQXEbhTg7YAAAAZdEVYdENvbW1lbnQAQ3JlYXRlZCB3aXRoIEdJTVBXgQ4XAAAAMklEQVQI12NkgIIvJ3QXMjAwdDN+OaEbysDA4MPAwNDNwMCwiOHLCd1zX07o6kBVGQEAKBANtobskNMAAAAASUVORK5CYII=);
-      }
-      .CodeMirror-lint-marker-error,
-      .CodeMirror-lint-marker-warning {
-        background-position: center center;
-        background-repeat: no-repeat;
-        cursor: pointer;
-        display: inline-block;
-        height: 16px;
-        position: relative;
-        vertical-align: middle;
-        width: 16px;
-      }
-      .CodeMirror-lint-message-error,
-      .CodeMirror-lint-message-warning {
-        background-position: top left;
-        background-repeat: no-repeat;
-        padding-left: 18px;
-      }
-      .CodeMirror-lint-marker-error,
-      .CodeMirror-lint-message-error {
-        background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAHlBMVEW7AAC7AACxAAC7AAC7AAAAAAC4AAC5AAD///+7AAAUdclpAAAABnRSTlMXnORSiwCK0ZKSAAAATUlEQVR42mWPOQ7AQAgDuQLx/z8csYRmPRIFIwRGnosRrpamvkKi0FTIiMASR3hhKW+hAN6/tIWhu9PDWiTGNEkTtIOucA5Oyr9ckPgAWm0GPBog6v4AAAAASUVORK5CYII=);
-      }
-      .CodeMirror-lint-marker-warning,
-      .CodeMirror-lint-message-warning {
-        background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAANlBMVEX/uwDvrwD/uwD/uwD/uwD/uwD/uwD/uwD/uwD6twD/uwAAAADurwD2tQD7uAD+ugAAAAD/uwDhmeTRAAAADHRSTlMJ8mN1EYcbmiixgACm7WbuAAAAVklEQVR42n3PUQqAIBBFUU1LLc3u/jdbOJoW1P08DA9Gba8+YWJ6gNJoNYIBzAA2chBth5kLmG9YUoG0NHAUwFXwO9LuBQL1giCQb8gC9Oro2vp5rncCIY8L8uEx5ZkAAAAASUVORK5CYII=);
-      }
-      .CodeMirror-lint-marker-multiple {
-        background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAcAAAAHCAMAAADzjKfhAAAACVBMVEUAAAAAAAC/v7914kyHAAAAAXRSTlMAQObYZgAAACNJREFUeNo1ioEJAAAIwmz/H90iFFSGJgFMe3gaLZ0od+9/AQZ0ADosbYraAAAAAElFTkSuQmCC);
-        background-position: right bottom;
-        background-repeat: no-repeat;
-        width: 100%;
-        height: 100%;
-      }
-      .graphiql-container .spinner-container {
-        height: 36px;
-        left: 50%;
-        position: absolute;
-        top: 50%;
-        transform: translate(-50%, -50%);
-        width: 36px;
-        z-index: 10;
-      }
-      .graphiql-container .spinner {
-        animation: rotation 0.6s infinite linear;
-        border-bottom: 6px solid rgba(150, 150, 150, 0.15);
-        border-left: 6px solid rgba(150, 150, 150, 0.15);
-        border-radius: 100%;
-        border-right: 6px solid rgba(150, 150, 150, 0.15);
-        border-top: 6px solid rgba(150, 150, 150, 0.8);
-        display: inline-block;
-        height: 24px;
-        position: absolute;
-        vertical-align: middle;
-        width: 24px;
-      }
-      @keyframes rotation {
-        0% {
-          transform: rotate(0);
-        }
-        to {
-          transform: rotate(359deg);
-        }
-      }
-      .CodeMirror-hints {
-        background: white;
-        box-shadow: 0 1px 3px #00000073;
-        font-family: Consolas, Inconsolata, Droid Sans Mono, Monaco, monospace;
-        font-size: 13px;
-        list-style: none;
-        margin: 0;
-        max-height: 14.5em;
-        overflow: hidden;
-        overflow-y: auto;
-        padding: 0;
-        position: absolute;
-        z-index: 10;
-      }
-      .CodeMirror-hint {
-        border-top: solid 1px #f7f7f7;
-        color: #141823;
-        cursor: pointer;
-        margin: 0;
-        max-width: 300px;
-        overflow: hidden;
-        padding: 2px 6px;
-        white-space: pre;
-      }
-      li.CodeMirror-hint-active {
-        background-color: #08f;
-        border-top-color: #fff;
-        color: #fff;
-      }
-      .CodeMirror-hint-information {
-        border-top: solid 1px #c0c0c0;
-        max-width: 300px;
-        padding: 4px 6px;
-        position: relative;
-        z-index: 1;
-      }
-      .CodeMirror-hint-information:first-child {
-        border-bottom: solid 1px #c0c0c0;
-        border-top: none;
-        margin-bottom: -1px;
-      }
-      .CodeMirror-hint-deprecation {
-        background: #fffae8;
-        box-shadow: inset 0 1px 1px -1px #bfb063;
-        color: #867f70;
-        font-family: system, -apple-system, San Francisco,
-          ".SFNSDisplay-Regular", Segoe UI, Segoe, Segoe WP, Helvetica Neue,
-          helvetica, Lucida Grande, arial, sans-serif;
-        font-size: 13px;
-        line-height: 16px;
-        margin-top: 4px;
-        max-height: 80px;
-        overflow: hidden;
-        padding: 6px;
-      }
-      .CodeMirror-hint-deprecation .deprecation-label {
-        color: #c79b2e;
-        cursor: default;
-        display: block;
-        font-size: 9px;
-        font-weight: 700;
-        letter-spacing: 1px;
-        line-height: 1;
-        padding-bottom: 5px;
-        text-transform: uppercase;
-        user-select: none;
-      }
-      .CodeMirror-hint-deprecation .deprecation-label + * {
-        margin-top: 0;
-      }
-      .CodeMirror-hint-deprecation :last-child {
-        margin-bottom: 0;
-      }
-      .graphiql-container .doc-explorer {
-        background: white;
-      }
-      .graphiql-container .doc-explorer-title-bar,
-      .graphiql-container .history-title-bar {
-        cursor: default;
-        display: flex;
-        height: 34px;
-        line-height: 14px;
-        padding: 8px 8px 5px;
-        position: relative;
-        user-select: none;
-      }
-      .graphiql-container .doc-explorer-title,
-      .graphiql-container .history-title {
-        flex: 1;
-        font-weight: 700;
-        overflow-x: hidden;
-        padding: 10px 0 10px 10px;
-        text-align: center;
-        text-overflow: ellipsis;
-        user-select: text;
-        white-space: nowrap;
-      }
-      .graphiql-container .doc-explorer-back {
-        color: #3b5998;
-        cursor: pointer;
-        margin: -7px 0 -6px -8px;
-        overflow-x: hidden;
-        padding: 17px 12px 16px 16px;
-        text-overflow: ellipsis;
-        white-space: nowrap;
-        background: 0;
-        border: 0;
-        line-height: 14px;
-      }
-      .doc-explorer-narrow .doc-explorer-back {
-        width: 0;
-      }
-      .graphiql-container .doc-explorer-back:before {
-        border-left: 2px solid #3b5998;
-        border-top: 2px solid #3b5998;
-        content: "";
-        display: inline-block;
-        height: 9px;
-        margin: 0 3px -1px 0;
-        position: relative;
-        transform: rotate(-45deg);
-        width: 9px;
-      }
-      .graphiql-container .doc-explorer-rhs {
-        position: relative;
-      }
-      .graphiql-container .doc-explorer-contents,
-      .graphiql-container .history-contents {
-        background-color: #fff;
-        border-top: 1px solid #d6d6d6;
-        bottom: 0;
-        left: 0;
-        overflow-y: auto;
-        padding: 20px 15px;
-        position: absolute;
-        right: 0;
-        top: 47px;
-      }
-      .graphiql-container .doc-explorer-contents {
-        min-width: 300px;
-      }
-      .graphiql-container .doc-type-description p:first-child,
-      .graphiql-container .doc-type-description blockquote:first-child {
-        margin-top: 0;
-      }
-      .graphiql-container .doc-explorer-contents a {
-        cursor: pointer;
-        text-decoration: none;
-      }
-      .graphiql-container .doc-explorer-contents a:hover {
-        text-decoration: underline;
-      }
-      .graphiql-container .doc-value-description > :first-child {
-        margin-top: 4px;
-      }
-      .graphiql-container .doc-value-description > :last-child {
-        margin-bottom: 4px;
-      }
-      .graphiql-container .doc-type-description code,
-      .graphiql-container .doc-type-description pre,
-      .graphiql-container .doc-category code,
-      .graphiql-container .doc-category pre {
-        --saf-0: rgba(var(--sk_foreground_low, 29, 28, 29), 0.13);
-        font-size: 12px;
-        line-height: 1.50001;
-        font-variant-ligatures: none;
-        white-space: pre;
-        white-space: pre-wrap;
-        word-wrap: break-word;
-        word-break: normal;
-        -webkit-tab-size: 4;
-        -moz-tab-size: 4;
-        tab-size: 4;
-      }
-      .graphiql-container .doc-type-description code,
-      .graphiql-container .doc-category code {
-        padding: 2px 3px 1px;
-        border: 1px solid var(--saf-0);
-        border-radius: 3px;
-        background-color: rgba(var(--sk_foreground_min, 29, 28, 29), 0.04);
-        color: #e01e5a;
-        background-color: #fff;
-      }
-      .graphiql-container .doc-category {
-        margin: 20px 0;
-      }
-      .graphiql-container .doc-category-title {
-        border-bottom: 1px solid #e0e0e0;
-        color: #777;
-        cursor: default;
-        font-size: 14px;
-        font-variant: small-caps;
-        font-weight: 700;
-        letter-spacing: 1px;
-        margin: 0 -15px 10px 0;
-        padding: 10px 0;
-        user-select: none;
-      }
-      .graphiql-container .doc-category-item {
-        margin: 12px 0;
-        color: #555;
-      }
-      .graphiql-container .keyword {
-        color: #b11a04;
-      }
-      .graphiql-container .type-name {
-        color: #ca9800;
-      }
-      .graphiql-container .field-name {
-        color: #1f61a0;
-      }
-      .graphiql-container .field-short-description {
-        color: #666;
-        margin-left: 5px;
-        overflow: hidden;
-        text-overflow: ellipsis;
-      }
-      .graphiql-container .enum-value {
-        color: #0b7fc7;
-      }
-      .graphiql-container .arg-name {
-        color: #8b2bb9;
-      }
-      .graphiql-container .arg {
-        display: block;
-        margin-left: 1em;
-      }
-      .graphiql-container .arg:first-child:last-child,
-      .graphiql-container .arg:first-child:nth-last-child(2),
-      .graphiql-container .arg:first-child:nth-last-child(2) ~ .arg {
-        display: inherit;
-        margin: inherit;
-      }
-      .graphiql-container .arg:first-child:nth-last-child(2):after {
-        content: ", ";
-      }
-      .graphiql-container .arg-default-value {
-        color: #43a047;
-      }
-      .graphiql-container .doc-deprecation {
-        background: #fffae8;
-        box-shadow: inset 0 0 1px #bfb063;
-        color: #867f70;
-        line-height: 16px;
-        margin: 8px -8px;
-        max-height: 80px;
-        overflow: hidden;
-        padding: 8px;
-        border-radius: 3px;
-      }
-      .graphiql-container .doc-deprecation:before {
-        content: "Deprecated:";
-        color: #c79b2e;
-        cursor: default;
-        display: block;
-        font-size: 9px;
-        font-weight: 700;
-        letter-spacing: 1px;
-        line-height: 1;
-        padding-bottom: 5px;
-        text-transform: uppercase;
-        user-select: none;
-      }
-      .graphiql-container .doc-deprecation > :first-child {
-        margin-top: 0;
-      }
-      .graphiql-container .doc-deprecation > :last-child {
-        margin-bottom: 0;
-      }
-      .graphiql-container .show-btn {
-        -webkit-appearance: initial;
-        display: block;
-        border-radius: 3px;
-        border: solid 1px #ccc;
-        text-align: center;
-        padding: 8px 12px 10px;
-        width: 100%;
-        box-sizing: border-box;
-        background: #fbfcfc;
-        color: #555;
-        cursor: pointer;
-      }
-      .graphiql-container .search-box {
-        border-bottom: 1px solid #d3d6db;
-        display: flex;
-        align-items: center;
-        font-size: 14px;
-        margin: -15px -15px 12px 0;
-        position: relative;
-      }
-      .graphiql-container .search-box-icon {
-        cursor: pointer;
-        display: block;
-        font-size: 24px;
-        transform: rotate(-45deg);
-        user-select: none;
-      }
-      .graphiql-container .search-box .search-box-clear {
-        background-color: #d0d0d0;
-        border-radius: 12px;
-        color: #fff;
-        cursor: pointer;
-        font-size: 11px;
-        padding: 1px 5px 2px;
-        position: absolute;
-        right: 3px;
-        user-select: none;
-        border: 0;
-      }
-      .graphiql-container .search-box .search-box-clear:hover {
-        background-color: #b9b9b9;
-      }
-      .graphiql-container .search-box > input {
-        border: none;
-        box-sizing: border-box;
-        font-size: 14px;
-        outline: none;
-        padding: 6px 24px 8px 20px;
-        width: 100%;
-      }
-      .graphiql-container .error-container {
-        font-weight: 700;
-        left: 0;
-        letter-spacing: 1px;
-        opacity: 0.5;
-        position: absolute;
-        right: 0;
-        text-align: center;
-        text-transform: uppercase;
-        top: 50%;
-        transform: translateY(-50%);
-      }
-      .graphiql-container .history-contents {
-        font-family: Consolas, Inconsolata, Droid Sans Mono, Monaco, monospace;
-      }
-      .graphiql-container .history-contents {
-        margin: 0;
-        padding: 0;
-      }
-      .graphiql-container .history-contents li {
-        align-items: center;
-        display: flex;
-        font-size: 12px;
-        overflow: hidden;
-        text-overflow: ellipsis;
-        white-space: nowrap;
-        margin: 0;
-        padding: 8px;
-        border-bottom: 1px solid #e0e0e0;
-      }
-      .graphiql-container .history-contents li button:not(.history-label) {
-        display: none;
-        margin-left: 10px;
-      }
-      .graphiql-container .history-contents li:hover button:not(.history-label),
-      .graphiql-container
-        .history-contents
-        li:focus-within
-        button:not(.history-label) {
-        display: inline-block;
-      }
-      .graphiql-container .history-contents input,
-      .graphiql-container .history-contents button {
-        padding: 0;
-        background: 0;
-        border: 0;
-        font-size: inherit;
-        font-family: inherit;
-        line-height: 14px;
-        color: inherit;
-      }
-      .graphiql-container .history-contents input {
-        flex-grow: 1;
-      }
-      .graphiql-container .history-contents input::placeholder {
-        color: inherit;
-      }
-      .graphiql-container .history-contents button {
-        cursor: pointer;
-        text-align: left;
-      }
-      .graphiql-container .history-contents .history-label {
-        flex-grow: 1;
-        overflow: hidden;
-        text-overflow: ellipsis;
-      }
-      body,
-      html {
-        margin: 0;
-      }
-      .graphiql-container {
-        height: 100vh;
-        width: 100vw;
-      }
-      .graphiql-explorer-node {
-        margin-left: 3px;
-      }
-      .graphiql-explorer-root .graphiql-operation-title-bar {
-        display: flex;
-        align-items: center;
-      }
-      .graphiql-explorer-root .graphiql-operation-title-bar input {
-        min-width: 11ch;
-      }
-      .graphiql-container .docExplorerShowReverse {
-        border-right: 1px solid rgba(0, 0, 0, 0.2) !important;
-      }
-      .docExplorerShowReverse:before {
-        display: none !important;
-      }
-      .docExplorerShowReverse:after {
-        border-left: 2px solid #3b5998;
-        border-top: 2px solid #3b5998;
-        content: "";
-        display: inline-block;
-        height: 9px;
-        margin: 0 0 -1px 3px;
-        position: relative;
-        transform: rotate(135deg);
-        width: 9px;
-      }
-      .graphiql-explorer-root input {
-        background-color: #282d34 !important;
-        padding-left: 5px;
-      }
-      .graphiql-explorer-actions select {
-        background-color: #282d34 !important;
-        color: #fff;
-        margin-left: 5px;
-      }
-      .graphiql-explorer-root div:first-child {
-        overflow: auto !important;
-      }
-      .graphiql-operation-title-bar {
-        background-color: transparent;
-      }
-      .CodeMirror {
-        background: #282d34 !important;
-      }
-      .graphiql-container .doc-explorer-contents,
-      .graphiql-container .history-contents {
-        background-color: #21262b;
-        border-top: 1px solid #181a1f;
-      }
-      .graphiql-container .doc-explorer-contents .graphiql-explorer-node svg {
-        margin-right: 5px !important;
-      }
-      .graphiql-container .doc-explorer-contents .graphiql-explorer-node path {
-        fill: #e0dddd !important;
-      }
-      .graphiql-container .toolbar-button {
-        background: #1c2125 !important;
-        box-shadow: none !important;
-        color: #fff !important;
-        border: 1px solid #181a1f !important;
-      }
-      .graphiql-container .toolbar-button:hover {
-        color: #c7c7c7 !important;
-      }
-      .graphiql-container .result-window .CodeMirror-gutters {
-        background: #282d33;
-        border: none !important;
-      }
-      .graphiql-container .resultWrap {
-        border-left: solid 1px #181a1f;
-      }
-      .graphiql-container .variable-editor-title {
-        background: #21262b;
-        border-bottom: 1px solid #181a1f;
-        border-top: 1px solid #181a1f;
-        color: #cacdd3;
-      }
-      .graphiql-container .topBar {
-        background: #21262b;
-        border-color: #181a1f;
-      }
-      .graphiql-container .docExplorerHide {
-        color: #fff;
-      }
-      .graphiql-container .docExplorerHide:hover {
-        color: #c7c7c7;
-      }
-      .graphiql-container .doc-explorer-title,
-      .graphiql-container .history-title,
-      .doc-explorer-back {
-        color: #cacdd3 !important;
-      }
-      .graphiql-container .doc-explorer {
-        background: #21262b;
-      }
-      .graphiql-container .docExplorerWrap,
-      .graphiql-container .historyPaneWrap {
-        box-shadow: none;
-      }
-      .graphiql-container .docExplorerShow {
-        border-left: none;
-      }
-      .graphiql-container .docExplorerShow,
-      .graphiql-container .historyShow {
-        background: #21262b;
-        border-bottom: 1px solid #181a1e;
-        color: #cacdd3;
-      }
-      .graphiql-container .docExplorerShow:before,
-      .graphiql-container .doc-explorer-back:before {
-        border-color: #cacdd3;
-      }
-      .graphiql-container .search-box {
-        margin: auto auto 10px;
-        border: none;
-      }
-      .graphiql-container .search-box input {
-        background: #1e2127;
-        padding-left: 28px;
-      }
-      .graphiql-container .search-box .search-box-clear,
-      .graphiql-container .search-box .search-box-clear:hover {
-        background: #1d2126;
-      }
-      .graphiql-container .search-box:before {
-        color: #c1c4ca;
-        font-size: 21px;
-        left: 8px;
-      }
-      .search-box-icon {
-        position: absolute;
-        padding-left: 5px;
-      }
-      .graphiql-container,
-      .graphiql-container button,
-      .graphiql-container input {
-        color: #9299a7;
-      }
-      .CodeMirror-gutters {
-        border: none !important;
-        background-color: #282d33;
-      }
-      .graphiql-container .execute-button {
-        background: #21262b;
-        border: 1px solid rgb(91, 98, 107);
-        box-shadow: none !important;
-        fill: #c9ccd2;
-      }
-      .graphiql-container .execute-button:hover {
-        fill: #999ba0;
-      }
-      .graphiql-container .history-contents p {
-        border: none;
-      }
-      .graphiql-container .historyPaneWrap {
-        background: #21262b;
-      }
-      .graphiql-container .execute-options > li.selected,
-      .graphiql-container .toolbar-menu-items > li.hover,
-      .graphiql-container .toolbar-menu-items > li:active,
-      .graphiql-container .toolbar-menu-items > li:hover,
-      .graphiql-container .toolbar-select-options > li.hover,
-      .graphiql-container .toolbar-select-options > li:active,
-      .graphiql-container .toolbar-select-options > li:hover,
-      .graphiql-container .history-contents > p:hover,
-      .graphiql-container .history-contents > p:active {
-        background: #383c41;
-      }
-      .graphiql-container .doc-category-title {
-        border-bottom: 1px solid #181a1f;
-        color: #cacdd3;
-      }
-      .graphiql-container .field-name {
-        color: #0083c7;
-      }
-      .graphiql-container .type-name {
-        color: #ff6d5d;
-      }
-      .graphiql-container .keyword {
-        color: #9ea5b0;
-      }
-      .graphiql-container .arg-name {
-        color: #0083c7;
-      }
-      .graphiql-container .doc-category-item {
-        color: #ff9f4c;
-      }
-      .graphiql-container .variable-editor-title-text.active {
-        color: #fff;
-      }
-      .cm-property {
-        color: #0083c7;
-      }
-      .cm-number {
-        color: #97b1aa;
-      }
-      .cm-string {
-        color: #00917d;
-      }
-      .cm-builtin {
-        color: #da8aff;
-      }
-      .cm-variable {
-        color: #f9f871;
-      }
-      .cm-attribute {
-        color: #00b8ff;
-      }
-      .cm-def {
-        color: #9f51d9;
-      }
-      .cm-punctuation {
-        color: #c7c7c7 !important;
-      }
-      .doc-type-description code {
-        color: #cc3932;
-        background-color: #383c41 !important;
-      }
-      .cm-keyword {
-        color: #ff6d5d;
-      }
-      .cm-atom {
-        color: #ff9f4c;
-      }
-      a {
-        color: #7b9ad4;
-      }
-      .CodeMirror .CodeMirror-cursor {
-        border-left: 1px solid white;
-      }
-      .CodeMirror-lint-tooltip {
-        background: #1a1e22 !important;
-        color: red;
-      }
-      .CodeMirror-hints {
-        background: #21262a;
-        box-shadow: 0 16px 13px -10px #0000004d;
-      }
-      .CodeMirror-hint {
-        border-top: solid 1px #212629;
-        color: #a45300;
-      }
-      .CodeMirror-hint-information {
-        border-top: solid 1px #181a1e;
-      }
-      li.CodeMirror-hint-active {
-        background-color: #262c2f;
-        border-top-color: #212629;
-        color: #d17825;
-      }
-      .CodeMirror-hint-information .content {
-        color: #a4abb7;
-      }
-      .graphiql-container .tabs {
-        background: #21262b;
-      }
-      .graphiql-container .tabs .tab,
-      .graphiql-container .tab-add,
-      .graphiql-container .tab .close:before {
-        background: #1c2125;
-        color: #ffffffb3;
-      }
-      .graphiql-container .tab-add:hover,
-      .graphiql-container .tabs .tab:hover {
-        color: #ffffffe6;
-      }
-      .graphiql-container .tabs .tab.active,
-      .graphiql-container .tab.active .close:before {
-        color: #fff;
-      }
-      .graphiql-container .tabs .tab {
-        border-color: #9299a74d;
-      }
-      .graphiql-container .tabs .tab:first-child {
-        border: none;
-      }
-    </style>
+    <link
+      rel="stylesheet"
+      href="https://cdn.jsdelivr.net/npm/@graphql-yoga/graphiql@4.2.0/dist/style.css"
+      crossorigin
+    />
+    <link
+      rel="icon"
+      type="image/png"
+      href="https://storage.googleapis.com/graph-web/favicon.png"
+      crossorigin="anonymous"
+    />
   </head>
   <body id="body" class="no-focus-outline">
     <noscript>You need to enable JavaScript to run this app.</noscript>
     <div id="root"></div>
-    <script>
-      // Polyfills until we can change DataLoader
-      if (globalThis.window?.setImmediate == null) {
-        //@ts-ignore
-        globalThis.window.setImmediate = setTimeout;
-        globalThis.global = globalThis;
-      }
-    </script>
-    <!-- Pull in the GraphiQL subscriptions fetcher -->
-    <script src="//unpkg.com/subscriptions-transport-ws@0.8.2/browser/client.js"></script>
-    <script src="//unpkg.com/graphiql-subscriptions-fetcher@0.0.2/browser/client.js"></script>
-    <script type="module">
-      var __defProp = Object.defineProperty;
-      var __defProps = Object.defineProperties;
-      var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-      var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-      var __hasOwnProp = Object.prototype.hasOwnProperty;
-      var __propIsEnum = Object.prototype.propertyIsEnumerable;
-      var __defNormalProp = (obj, key, value) =>
-        key in obj
-          ? __defProp(obj, key, {
-              enumerable: true,
-              configurable: true,
-              writable: true,
-              value,
-            })
-          : (obj[key] = value);
-      var __spreadValues = (a, b) => {
-        for (var prop2 in b || (b = {}))
-          if (__hasOwnProp.call(b, prop2)) __defNormalProp(a, prop2, b[prop2]);
-        if (__getOwnPropSymbols)
-          for (var prop2 of __getOwnPropSymbols(b)) {
-            if (__propIsEnum.call(b, prop2))
-              __defNormalProp(a, prop2, b[prop2]);
-          }
-        return a;
-      };
-      var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-      function _mergeNamespaces(n2, m) {
-        m.forEach(function (e) {
-          e &&
-            typeof e !== "string" &&
-            !Array.isArray(e) &&
-            Object.keys(e).forEach(function (k) {
-              if (k !== "default" && !(k in n2)) {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(
-                  n2,
-                  k,
-                  d.get
-                    ? d
-                    : {
-                        enumerable: true,
-                        get: function () {
-                          return e[k];
-                        },
-                      }
-                );
-              }
-            });
-        });
-        return Object.freeze(n2);
-      }
-      var commonjsGlobal =
-        typeof globalThis !== "undefined"
-          ? globalThis
-          : typeof window !== "undefined"
-          ? window
-          : typeof global !== "undefined"
-          ? global
-          : typeof self !== "undefined"
-          ? self
-          : {};
-      function getDefaultExportFromCjs(x2) {
-        return x2 &&
-          x2.__esModule &&
-          Object.prototype.hasOwnProperty.call(x2, "default")
-          ? x2["default"]
-          : x2;
-      }
-      function getAugmentedNamespace(n2) {
-        if (n2.__esModule) return n2;
-        var a = Object.defineProperty({}, "__esModule", { value: true });
-        Object.keys(n2).forEach(function (k) {
-          var d = Object.getOwnPropertyDescriptor(n2, k);
-          Object.defineProperty(
-            a,
-            k,
-            d.get
-              ? d
-              : {
-                  enumerable: true,
-                  get: function () {
-                    return n2[k];
-                  },
-                }
-          );
-        });
-        return a;
-      }
-      var react = { exports: {} };
-      var react_production_min = {};
-      /**
-       * @license React
-       * react.production.min.js
-       *
-       * Copyright (c) Facebook, Inc. and its affiliates.
-       *
-       * This source code is licensed under the MIT license found in the
-       * LICENSE file in the root directory of this source tree.
-       */
-      var l = Symbol.for("react.element"),
-        n = Symbol.for("react.portal"),
-        p$2 = Symbol.for("react.fragment"),
-        q$1 = Symbol.for("react.strict_mode"),
-        r = Symbol.for("react.profiler"),
-        t$1 = Symbol.for("react.provider"),
-        u = Symbol.for("react.context"),
-        v = Symbol.for("react.forward_ref"),
-        w = Symbol.for("react.suspense"),
-        x = Symbol.for("react.memo"),
-        y = Symbol.for("react.lazy"),
-        z$1 = Symbol.iterator;
-      function A$1(a) {
-        if (a === null || typeof a !== "object") return null;
-        a = (z$1 && a[z$1]) || a["@@iterator"];
-        return typeof a === "function" ? a : null;
-      }
-      var B = {
-          isMounted: function () {
-            return false;
-          },
-          enqueueForceUpdate: function () {},
-          enqueueReplaceState: function () {},
-          enqueueSetState: function () {},
-        },
-        C = Object.assign,
-        D$1 = {};
-      function E$1(a, b, e) {
-        this.props = a;
-        this.context = b;
-        this.refs = D$1;
-        this.updater = e || B;
-      }
-      E$1.prototype.isReactComponent = {};
-      E$1.prototype.setState = function (a, b) {
-        if (typeof a !== "object" && typeof a !== "function" && a != null)
-          throw Error(
-            "setState(...): takes an object of state variables to update or a function which returns an object of state variables."
-          );
-        this.updater.enqueueSetState(this, a, b, "setState");
-      };
-      E$1.prototype.forceUpdate = function (a) {
-        this.updater.enqueueForceUpdate(this, a, "forceUpdate");
-      };
-      function F$1() {}
-      F$1.prototype = E$1.prototype;
-      function G$1(a, b, e) {
-        this.props = a;
-        this.context = b;
-        this.refs = D$1;
-        this.updater = e || B;
-      }
-      var H$1 = (G$1.prototype = new F$1());
-      H$1.constructor = G$1;
-      C(H$1, E$1.prototype);
-      H$1.isPureReactComponent = true;
-      var I$1 = Array.isArray,
-        J$1 = Object.prototype.hasOwnProperty,
-        K$1 = { current: null },
-        L = { key: true, ref: true, __self: true, __source: true };
-      function M$1(a, b, e) {
-        var d,
-          c = {},
-          k = null,
-          h = null;
-        if (b != null)
-          for (d in (b.ref !== void 0 && (h = b.ref),
-          b.key !== void 0 && (k = "" + b.key),
-          b))
-            J$1.call(b, d) && !L.hasOwnProperty(d) && (c[d] = b[d]);
-        var g = arguments.length - 2;
-        if (g === 1) c.children = e;
-        else if (1 < g) {
-          for (var f = Array(g), m = 0; m < g; m++) f[m] = arguments[m + 2];
-          c.children = f;
-        }
-        if (a && a.defaultProps)
-          for (d in ((g = a.defaultProps), g)) c[d] === void 0 && (c[d] = g[d]);
-        return {
-          $$typeof: l,
-          type: a,
-          key: k,
-          ref: h,
-          props: c,
-          _owner: K$1.current,
-        };
-      }
-      function N$1(a, b) {
-        return {
-          $$typeof: l,
-          type: a.type,
-          key: b,
-          ref: a.ref,
-          props: a.props,
-          _owner: a._owner,
-        };
-      }
-      function O(a) {
-        return typeof a === "object" && a !== null && a.$$typeof === l;
-      }
-      function escape(a) {
-        var b = { "=": "=0", ":": "=2" };
-        return (
-          "$" +
-          a.replace(/[=:]/g, function (a2) {
-            return b[a2];
-          })
-        );
-      }
-      var P$1 = /\/+/g;
-      function Q$1(a, b) {
-        return typeof a === "object" && a !== null && a.key != null
-          ? escape("" + a.key)
-          : b.toString(36);
-      }
-      function R$1(a, b, e, d, c) {
-        var k = typeof a;
-        if (k === "undefined" || k === "boolean") a = null;
-        var h = false;
-        if (a === null) h = true;
-        else
-          switch (k) {
-            case "string":
-            case "number":
-              h = true;
-              break;
-            case "object":
-              switch (a.$$typeof) {
-                case l:
-                case n:
-                  h = true;
-              }
-          }
-        if (h)
-          return (
-            (h = a),
-            (c = c(h)),
-            (a = d === "" ? "." + Q$1(h, 0) : d),
-            I$1(c)
-              ? ((e = ""),
-                a != null && (e = a.replace(P$1, "$&/") + "/"),
-                R$1(c, b, e, "", function (a2) {
-                  return a2;
-                }))
-              : c != null &&
-                (O(c) &&
-                  (c = N$1(
-                    c,
-                    e +
-                      (!c.key || (h && h.key === c.key)
-                        ? ""
-                        : ("" + c.key).replace(P$1, "$&/") + "/") +
-                      a
-                  )),
-                b.push(c)),
-            1
-          );
-        h = 0;
-        d = d === "" ? "." : d + ":";
-        if (I$1(a))
-          for (var g = 0; g < a.length; g++) {
-            k = a[g];
-            var f = d + Q$1(k, g);
-            h += R$1(k, b, e, f, c);
-          }
-        else if (((f = A$1(a)), typeof f === "function"))
-          for (a = f.call(a), g = 0; !(k = a.next()).done; )
-            (k = k.value), (f = d + Q$1(k, g++)), (h += R$1(k, b, e, f, c));
-        else if (k === "object")
-          throw (
-            ((b = String(a)),
-            Error(
-              "Objects are not valid as a React child (found: " +
-                (b === "[object Object]"
-                  ? "object with keys {" + Object.keys(a).join(", ") + "}"
-                  : b) +
-                "). If you meant to render a collection of children, use an array instead."
-            ))
-          );
-        return h;
-      }
-      function S$1(a, b, e) {
-        if (a == null) return a;
-        var d = [],
-          c = 0;
-        R$1(a, d, "", "", function (a2) {
-          return b.call(e, a2, c++);
-        });
-        return d;
-      }
-      function T(a) {
-        if (a._status === -1) {
-          var b = a._result;
-          b = b();
-          b.then(
-            function (b2) {
-              if (a._status === 0 || a._status === -1)
-                (a._status = 1), (a._result = b2);
-            },
-            function (b2) {
-              if (a._status === 0 || a._status === -1)
-                (a._status = 2), (a._result = b2);
-            }
-          );
-          a._status === -1 && ((a._status = 0), (a._result = b));
-        }
-        if (a._status === 1) return a._result.default;
-        throw a._result;
-      }
-      var U$1 = { current: null },
-        V$1 = { transition: null },
-        W$1 = {
-          ReactCurrentDispatcher: U$1,
-          ReactCurrentBatchConfig: V$1,
-          ReactCurrentOwner: K$1,
-        };
-      react_production_min.Children = {
-        map: S$1,
-        forEach: function (a, b, e) {
-          S$1(
-            a,
-            function () {
-              b.apply(this, arguments);
-            },
-            e
-          );
-        },
-        count: function (a) {
-          var b = 0;
-          S$1(a, function () {
-            b++;
-          });
-          return b;
-        },
-        toArray: function (a) {
-          return (
-            S$1(a, function (a2) {
-              return a2;
-            }) || []
-          );
-        },
-        only: function (a) {
-          if (!O(a))
-            throw Error(
-              "React.Children.only expected to receive a single React element child."
-            );
-          return a;
-        },
-      };
-      react_production_min.Component = E$1;
-      react_production_min.Fragment = p$2;
-      react_production_min.Profiler = r;
-      react_production_min.PureComponent = G$1;
-      react_production_min.StrictMode = q$1;
-      react_production_min.Suspense = w;
-      react_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED =
-        W$1;
-      react_production_min.cloneElement = function (a, b, e) {
-        if (a === null || a === void 0)
-          throw Error(
-            "React.cloneElement(...): The argument must be a React element, but you passed " +
-              a +
-              "."
-          );
-        var d = C({}, a.props),
-          c = a.key,
-          k = a.ref,
-          h = a._owner;
-        if (b != null) {
-          b.ref !== void 0 && ((k = b.ref), (h = K$1.current));
-          b.key !== void 0 && (c = "" + b.key);
-          if (a.type && a.type.defaultProps) var g = a.type.defaultProps;
-          for (f in b)
-            J$1.call(b, f) &&
-              !L.hasOwnProperty(f) &&
-              (d[f] = b[f] === void 0 && g !== void 0 ? g[f] : b[f]);
-        }
-        var f = arguments.length - 2;
-        if (f === 1) d.children = e;
-        else if (1 < f) {
-          g = Array(f);
-          for (var m = 0; m < f; m++) g[m] = arguments[m + 2];
-          d.children = g;
-        }
-        return {
-          $$typeof: l,
-          type: a.type,
-          key: c,
-          ref: k,
-          props: d,
-          _owner: h,
-        };
-      };
-      react_production_min.createContext = function (a) {
-        a = {
-          $$typeof: u,
-          _currentValue: a,
-          _currentValue2: a,
-          _threadCount: 0,
-          Provider: null,
-          Consumer: null,
-          _defaultValue: null,
-          _globalName: null,
-        };
-        a.Provider = { $$typeof: t$1, _context: a };
-        return (a.Consumer = a);
-      };
-      react_production_min.createElement = M$1;
-      react_production_min.createFactory = function (a) {
-        var b = M$1.bind(null, a);
-        b.type = a;
-        return b;
-      };
-      react_production_min.createRef = function () {
-        return { current: null };
-      };
-      react_production_min.forwardRef = function (a) {
-        return { $$typeof: v, render: a };
-      };
-      react_production_min.isValidElement = O;
-      react_production_min.lazy = function (a) {
-        return { $$typeof: y, _payload: { _status: -1, _result: a }, _init: T };
-      };
-      react_production_min.memo = function (a, b) {
-        return { $$typeof: x, type: a, compare: b === void 0 ? null : b };
-      };
-      react_production_min.startTransition = function (a) {
-        var b = V$1.transition;
-        V$1.transition = {};
-        try {
-          a();
-        } finally {
-          V$1.transition = b;
-        }
-      };
-      react_production_min.unstable_act = function () {
-        throw Error("act(...) is not supported in production builds of React.");
-      };
-      react_production_min.useCallback = function (a, b) {
-        return U$1.current.useCallback(a, b);
-      };
-      react_production_min.useContext = function (a) {
-        return U$1.current.useContext(a);
-      };
-      react_production_min.useDebugValue = function () {};
-      react_production_min.useDeferredValue = function (a) {
-        return U$1.current.useDeferredValue(a);
-      };
-      react_production_min.useEffect = function (a, b) {
-        return U$1.current.useEffect(a, b);
-      };
-      react_production_min.useId = function () {
-        return U$1.current.useId();
-      };
-      react_production_min.useImperativeHandle = function (a, b, e) {
-        return U$1.current.useImperativeHandle(a, b, e);
-      };
-      react_production_min.useInsertionEffect = function (a, b) {
-        return U$1.current.useInsertionEffect(a, b);
-      };
-      react_production_min.useLayoutEffect = function (a, b) {
-        return U$1.current.useLayoutEffect(a, b);
-      };
-      react_production_min.useMemo = function (a, b) {
-        return U$1.current.useMemo(a, b);
-      };
-      react_production_min.useReducer = function (a, b, e) {
-        return U$1.current.useReducer(a, b, e);
-      };
-      react_production_min.useRef = function (a) {
-        return U$1.current.useRef(a);
-      };
-      react_production_min.useState = function (a) {
-        return U$1.current.useState(a);
-      };
-      react_production_min.useSyncExternalStore = function (a, b, e) {
-        return U$1.current.useSyncExternalStore(a, b, e);
-      };
-      react_production_min.useTransition = function () {
-        return U$1.current.useTransition();
-      };
-      react_production_min.version = "18.0.0-fc46dba67-20220329";
-      {
-        react.exports = react_production_min;
-      }
-      var React$1 = react.exports;
-      var reactDom = { exports: {} };
-      var reactDom_production_min = {};
-      var scheduler = { exports: {} };
-      var scheduler_production_min = {};
-      /**
-       * @license React
-       * scheduler.production.min.js
-       *
-       * Copyright (c) Facebook, Inc. and its affiliates.
-       *
-       * This source code is licensed under the MIT license found in the
-       * LICENSE file in the root directory of this source tree.
-       */
-      (function (exports) {
-        function f(a, b) {
-          var c = a.length;
-          a.push(b);
-          a: for (; 0 < c; ) {
-            var d = (c - 1) >>> 1,
-              e = a[d];
-            if (0 < g(e, b)) (a[d] = b), (a[c] = e), (c = d);
-            else break a;
-          }
-        }
-        function h(a) {
-          return a.length === 0 ? null : a[0];
-        }
-        function k(a) {
-          if (a.length === 0) return null;
-          var b = a[0],
-            c = a.pop();
-          if (c !== b) {
-            a[0] = c;
-            a: for (var d = 0, e = a.length, w2 = e >>> 1; d < w2; ) {
-              var m = 2 * (d + 1) - 1,
-                C2 = a[m],
-                n2 = m + 1,
-                x2 = a[n2];
-              if (0 > g(C2, c))
-                n2 < e && 0 > g(x2, C2)
-                  ? ((a[d] = x2), (a[n2] = c), (d = n2))
-                  : ((a[d] = C2), (a[m] = c), (d = m));
-              else if (n2 < e && 0 > g(x2, c))
-                (a[d] = x2), (a[n2] = c), (d = n2);
-              else break a;
-            }
-          }
-          return b;
-        }
-        function g(a, b) {
-          var c = a.sortIndex - b.sortIndex;
-          return c !== 0 ? c : a.id - b.id;
-        }
-        if (
-          typeof performance === "object" &&
-          typeof performance.now === "function"
-        ) {
-          var l2 = performance;
-          exports.unstable_now = function () {
-            return l2.now();
-          };
-        } else {
-          var p2 = Date,
-            q2 = p2.now();
-          exports.unstable_now = function () {
-            return p2.now() - q2;
-          };
-        }
-        var r2 = [],
-          t2 = [],
-          u2 = 1,
-          v2 = null,
-          y2 = 3,
-          z2 = false,
-          A2 = false,
-          B2 = false,
-          D2 = typeof setTimeout === "function" ? setTimeout : null,
-          E2 = typeof clearTimeout === "function" ? clearTimeout : null,
-          F2 = typeof setImmediate !== "undefined" ? setImmediate : null;
-        typeof navigator !== "undefined" &&
-          navigator.scheduling !== void 0 &&
-          navigator.scheduling.isInputPending !== void 0 &&
-          navigator.scheduling.isInputPending.bind(navigator.scheduling);
-        function G2(a) {
-          for (var b = h(t2); b !== null; ) {
-            if (b.callback === null) k(t2);
-            else if (b.startTime <= a)
-              k(t2), (b.sortIndex = b.expirationTime), f(r2, b);
-            else break;
-            b = h(t2);
-          }
-        }
-        function H2(a) {
-          B2 = false;
-          G2(a);
-          if (!A2)
-            if (h(r2) !== null) (A2 = true), I2(J2);
-            else {
-              var b = h(t2);
-              b !== null && K2(H2, b.startTime - a);
-            }
-        }
-        function J2(a, b) {
-          A2 = false;
-          B2 && ((B2 = false), E2(L2), (L2 = -1));
-          z2 = true;
-          var c = y2;
-          try {
-            G2(b);
-            for (
-              v2 = h(r2);
-              v2 !== null && (!(v2.expirationTime > b) || (a && !M2()));
-
-            ) {
-              var d = v2.callback;
-              if (typeof d === "function") {
-                v2.callback = null;
-                y2 = v2.priorityLevel;
-                var e = d(v2.expirationTime <= b);
-                b = exports.unstable_now();
-                typeof e === "function"
-                  ? (v2.callback = e)
-                  : v2 === h(r2) && k(r2);
-                G2(b);
-              } else k(r2);
-              v2 = h(r2);
-            }
-            if (v2 !== null) var w2 = true;
-            else {
-              var m = h(t2);
-              m !== null && K2(H2, m.startTime - b);
-              w2 = false;
-            }
-            return w2;
-          } finally {
-            (v2 = null), (y2 = c), (z2 = false);
-          }
-        }
-        var N2 = false,
-          O2 = null,
-          L2 = -1,
-          P2 = 5,
-          Q2 = -1;
-        function M2() {
-          return exports.unstable_now() - Q2 < P2 ? false : true;
-        }
-        function R2() {
-          if (O2 !== null) {
-            var a = exports.unstable_now();
-            Q2 = a;
-            var b = true;
-            try {
-              b = O2(true, a);
-            } finally {
-              b ? S2() : ((N2 = false), (O2 = null));
-            }
-          } else N2 = false;
-        }
-        var S2;
-        if (typeof F2 === "function")
-          S2 = function () {
-            F2(R2);
-          };
-        else if (typeof MessageChannel !== "undefined") {
-          var T2 = new MessageChannel(),
-            U2 = T2.port2;
-          T2.port1.onmessage = R2;
-          S2 = function () {
-            U2.postMessage(null);
-          };
-        } else
-          S2 = function () {
-            D2(R2, 0);
-          };
-        function I2(a) {
-          O2 = a;
-          N2 || ((N2 = true), S2());
-        }
-        function K2(a, b) {
-          L2 = D2(function () {
-            a(exports.unstable_now());
-          }, b);
-        }
-        exports.unstable_IdlePriority = 5;
-        exports.unstable_ImmediatePriority = 1;
-        exports.unstable_LowPriority = 4;
-        exports.unstable_NormalPriority = 3;
-        exports.unstable_Profiling = null;
-        exports.unstable_UserBlockingPriority = 2;
-        exports.unstable_cancelCallback = function (a) {
-          a.callback = null;
-        };
-        exports.unstable_continueExecution = function () {
-          A2 || z2 || ((A2 = true), I2(J2));
-        };
-        exports.unstable_forceFrameRate = function (a) {
-          0 > a || 125 < a
-            ? console.error(
-                "forceFrameRate takes a positive int between 0 and 125, forcing frame rates higher than 125 fps is not supported"
-              )
-            : (P2 = 0 < a ? Math.floor(1e3 / a) : 5);
-        };
-        exports.unstable_getCurrentPriorityLevel = function () {
-          return y2;
-        };
-        exports.unstable_getFirstCallbackNode = function () {
-          return h(r2);
-        };
-        exports.unstable_next = function (a) {
-          switch (y2) {
-            case 1:
-            case 2:
-            case 3:
-              var b = 3;
-              break;
-            default:
-              b = y2;
-          }
-          var c = y2;
-          y2 = b;
-          try {
-            return a();
-          } finally {
-            y2 = c;
-          }
-        };
-        exports.unstable_pauseExecution = function () {};
-        exports.unstable_requestPaint = function () {};
-        exports.unstable_runWithPriority = function (a, b) {
-          switch (a) {
-            case 1:
-            case 2:
-            case 3:
-            case 4:
-            case 5:
-              break;
-            default:
-              a = 3;
-          }
-          var c = y2;
-          y2 = a;
-          try {
-            return b();
-          } finally {
-            y2 = c;
-          }
-        };
-        exports.unstable_scheduleCallback = function (a, b, c) {
-          var d = exports.unstable_now();
-          typeof c === "object" && c !== null
-            ? ((c = c.delay), (c = typeof c === "number" && 0 < c ? d + c : d))
-            : (c = d);
-          switch (a) {
-            case 1:
-              var e = -1;
-              break;
-            case 2:
-              e = 250;
-              break;
-            case 5:
-              e = 1073741823;
-              break;
-            case 4:
-              e = 1e4;
-              break;
-            default:
-              e = 5e3;
-          }
-          e = c + e;
-          a = {
-            id: u2++,
-            callback: b,
-            priorityLevel: a,
-            startTime: c,
-            expirationTime: e,
-            sortIndex: -1,
-          };
-          c > d
-            ? ((a.sortIndex = c),
-              f(t2, a),
-              h(r2) === null &&
-                a === h(t2) &&
-                (B2 ? (E2(L2), (L2 = -1)) : (B2 = true), K2(H2, c - d)))
-            : ((a.sortIndex = e), f(r2, a), A2 || z2 || ((A2 = true), I2(J2)));
-          return a;
-        };
-        exports.unstable_shouldYield = M2;
-        exports.unstable_wrapCallback = function (a) {
-          var b = y2;
-          return function () {
-            var c = y2;
-            y2 = b;
-            try {
-              return a.apply(this, arguments);
-            } finally {
-              y2 = c;
-            }
-          };
-        };
-      })(scheduler_production_min);
-      {
-        scheduler.exports = scheduler_production_min;
-      }
-      /**
-       * @license React
-       * react-dom.production.min.js
-       *
-       * Copyright (c) Facebook, Inc. and its affiliates.
-       *
-       * This source code is licensed under the MIT license found in the
-       * LICENSE file in the root directory of this source tree.
-       */
-      var aa = react.exports,
-        ba = scheduler.exports;
-      function p$1(a) {
-        for (
-          var b = "https://reactjs.org/docs/error-decoder.html?invariant=" + a,
-            c = 1;
-          c < arguments.length;
-          c++
-        )
-          b += "&args[]=" + encodeURIComponent(arguments[c]);
-        return (
-          "Minified React error #" +
-          a +
-          "; visit " +
-          b +
-          " for the full message or use the non-minified dev environment for full errors and additional helpful warnings."
-        );
-      }
-      var ca = /* @__PURE__ */ new Set(),
-        da = {};
-      function ea(a, b) {
-        fa(a, b);
-        fa(a + "Capture", b);
-      }
-      function fa(a, b) {
-        da[a] = b;
-        for (a = 0; a < b.length; a++) ca.add(b[a]);
-      }
-      var ha = !(
-          typeof window === "undefined" ||
-          typeof window.document === "undefined" ||
-          typeof window.document.createElement === "undefined"
-        ),
-        ia = Object.prototype.hasOwnProperty,
-        ja =
-          /^[:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD][:A-Z_a-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\-.0-9\u00B7\u0300-\u036F\u203F-\u2040]*$/,
-        ka = {},
-        la = {};
-      function ma(a) {
-        if (ia.call(la, a)) return true;
-        if (ia.call(ka, a)) return false;
-        if (ja.test(a)) return (la[a] = true);
-        ka[a] = true;
-        return false;
-      }
-      function na(a, b, c, d) {
-        if (c !== null && c.type === 0) return false;
-        switch (typeof b) {
-          case "function":
-          case "symbol":
-            return true;
-          case "boolean":
-            if (d) return false;
-            if (c !== null) return !c.acceptsBooleans;
-            a = a.toLowerCase().slice(0, 5);
-            return a !== "data-" && a !== "aria-";
-          default:
-            return false;
-        }
-      }
-      function oa(a, b, c, d) {
-        if (b === null || typeof b === "undefined" || na(a, b, c, d))
-          return true;
-        if (d) return false;
-        if (c !== null)
-          switch (c.type) {
-            case 3:
-              return !b;
-            case 4:
-              return b === false;
-            case 5:
-              return isNaN(b);
-            case 6:
-              return isNaN(b) || 1 > b;
-          }
-        return false;
-      }
-      function q(a, b, c, d, e, f, g) {
-        this.acceptsBooleans = b === 2 || b === 3 || b === 4;
-        this.attributeName = d;
-        this.attributeNamespace = e;
-        this.mustUseProperty = c;
-        this.propertyName = a;
-        this.type = b;
-        this.sanitizeURL = f;
-        this.removeEmptyString = g;
-      }
-      var z = {};
-      "children dangerouslySetInnerHTML defaultValue defaultChecked innerHTML suppressContentEditableWarning suppressHydrationWarning style"
-        .split(" ")
-        .forEach(function (a) {
-          z[a] = new q(a, 0, false, a, null, false, false);
-        });
-      [
-        ["acceptCharset", "accept-charset"],
-        ["className", "class"],
-        ["htmlFor", "for"],
-        ["httpEquiv", "http-equiv"],
-      ].forEach(function (a) {
-        var b = a[0];
-        z[b] = new q(b, 1, false, a[1], null, false, false);
-      });
-      ["contentEditable", "draggable", "spellCheck", "value"].forEach(function (
-        a
-      ) {
-        z[a] = new q(a, 2, false, a.toLowerCase(), null, false, false);
-      });
-      [
-        "autoReverse",
-        "externalResourcesRequired",
-        "focusable",
-        "preserveAlpha",
-      ].forEach(function (a) {
-        z[a] = new q(a, 2, false, a, null, false, false);
-      });
-      "allowFullScreen async autoFocus autoPlay controls default defer disabled disablePictureInPicture disableRemotePlayback formNoValidate hidden loop noModule noValidate open playsInline readOnly required reversed scoped seamless itemScope"
-        .split(" ")
-        .forEach(function (a) {
-          z[a] = new q(a, 3, false, a.toLowerCase(), null, false, false);
-        });
-      ["checked", "multiple", "muted", "selected"].forEach(function (a) {
-        z[a] = new q(a, 3, true, a, null, false, false);
-      });
-      ["capture", "download"].forEach(function (a) {
-        z[a] = new q(a, 4, false, a, null, false, false);
-      });
-      ["cols", "rows", "size", "span"].forEach(function (a) {
-        z[a] = new q(a, 6, false, a, null, false, false);
-      });
-      ["rowSpan", "start"].forEach(function (a) {
-        z[a] = new q(a, 5, false, a.toLowerCase(), null, false, false);
-      });
-      var pa = /[\-:]([a-z])/g;
-      function qa(a) {
-        return a[1].toUpperCase();
-      }
-      "accent-height alignment-baseline arabic-form baseline-shift cap-height clip-path clip-rule color-interpolation color-interpolation-filters color-profile color-rendering dominant-baseline enable-background fill-opacity fill-rule flood-color flood-opacity font-family font-size font-size-adjust font-stretch font-style font-variant font-weight glyph-name glyph-orientation-horizontal glyph-orientation-vertical horiz-adv-x horiz-origin-x image-rendering letter-spacing lighting-color marker-end marker-mid marker-start overline-position overline-thickness paint-order panose-1 pointer-events rendering-intent shape-rendering stop-color stop-opacity strikethrough-position strikethrough-thickness stroke-dasharray stroke-dashoffset stroke-linecap stroke-linejoin stroke-miterlimit stroke-opacity stroke-width text-anchor text-decoration text-rendering underline-position underline-thickness unicode-bidi unicode-range units-per-em v-alphabetic v-hanging v-ideographic v-mathematical vector-effect vert-adv-y vert-origin-x vert-origin-y word-spacing writing-mode xmlns:xlink x-height"
-        .split(" ")
-        .forEach(function (a) {
-          var b = a.replace(pa, qa);
-          z[b] = new q(b, 1, false, a, null, false, false);
-        });
-      "xlink:actuate xlink:arcrole xlink:role xlink:show xlink:title xlink:type"
-        .split(" ")
-        .forEach(function (a) {
-          var b = a.replace(pa, qa);
-          z[b] = new q(
-            b,
-            1,
-            false,
-            a,
-            "http://www.w3.org/1999/xlink",
-            false,
-            false
-          );
-        });
-      ["xml:base", "xml:lang", "xml:space"].forEach(function (a) {
-        var b = a.replace(pa, qa);
-        z[b] = new q(
-          b,
-          1,
-          false,
-          a,
-          "http://www.w3.org/XML/1998/namespace",
-          false,
-          false
-        );
-      });
-      ["tabIndex", "crossOrigin"].forEach(function (a) {
-        z[a] = new q(a, 1, false, a.toLowerCase(), null, false, false);
-      });
-      z.xlinkHref = new q(
-        "xlinkHref",
-        1,
-        false,
-        "xlink:href",
-        "http://www.w3.org/1999/xlink",
-        true,
-        false
-      );
-      ["src", "href", "action", "formAction"].forEach(function (a) {
-        z[a] = new q(a, 1, false, a.toLowerCase(), null, true, true);
-      });
-      function ra(a, b, c, d) {
-        var e = z.hasOwnProperty(b) ? z[b] : null;
-        if (
-          e !== null
-            ? e.type !== 0
-            : d ||
-              !(2 < b.length) ||
-              (b[0] !== "o" && b[0] !== "O") ||
-              (b[1] !== "n" && b[1] !== "N")
-        )
-          oa(b, c, e, d) && (c = null),
-            d || e === null
-              ? ma(b) &&
-                (c === null ? a.removeAttribute(b) : a.setAttribute(b, "" + c))
-              : e.mustUseProperty
-              ? (a[e.propertyName] =
-                  c === null ? (e.type === 3 ? false : "") : c)
-              : ((b = e.attributeName),
-                (d = e.attributeNamespace),
-                c === null
-                  ? a.removeAttribute(b)
-                  : ((e = e.type),
-                    (c = e === 3 || (e === 4 && c === true) ? "" : "" + c),
-                    d ? a.setAttributeNS(d, b, c) : a.setAttribute(b, c)));
-      }
-      var sa = aa.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
-        ta = Symbol.for("react.element"),
-        ua = Symbol.for("react.portal"),
-        va = Symbol.for("react.fragment"),
-        wa = Symbol.for("react.strict_mode"),
-        xa = Symbol.for("react.profiler"),
-        ya = Symbol.for("react.provider"),
-        Aa = Symbol.for("react.context"),
-        Ba = Symbol.for("react.forward_ref"),
-        Ca = Symbol.for("react.suspense"),
-        Da = Symbol.for("react.suspense_list"),
-        Ea = Symbol.for("react.memo"),
-        Fa = Symbol.for("react.lazy");
-      var Ga = Symbol.for("react.offscreen");
-      var Ha = Symbol.iterator;
-      function Ia(a) {
-        if (a === null || typeof a !== "object") return null;
-        a = (Ha && a[Ha]) || a["@@iterator"];
-        return typeof a === "function" ? a : null;
-      }
-      var A = Object.assign,
-        Ja;
-      function Ka(a) {
-        if (Ja === void 0)
-          try {
-            throw Error();
-          } catch (c) {
-            var b = c.stack.trim().match(/\n( *(at )?)/);
-            Ja = (b && b[1]) || "";
-          }
-        return "\n" + Ja + a;
-      }
-      var La = false;
-      function Ma(a, b) {
-        if (!a || La) return "";
-        La = true;
-        var c = Error.prepareStackTrace;
-        Error.prepareStackTrace = void 0;
-        try {
-          if (b)
-            if (
-              ((b = function () {
-                throw Error();
-              }),
-              Object.defineProperty(b.prototype, "props", {
-                set: function () {
-                  throw Error();
-                },
-              }),
-              typeof Reflect === "object" && Reflect.construct)
-            ) {
-              try {
-                Reflect.construct(b, []);
-              } catch (l2) {
-                var d = l2;
-              }
-              Reflect.construct(a, [], b);
-            } else {
-              try {
-                b.call();
-              } catch (l2) {
-                d = l2;
-              }
-              a.call(b.prototype);
-            }
-          else {
-            try {
-              throw Error();
-            } catch (l2) {
-              d = l2;
-            }
-            a();
-          }
-        } catch (l2) {
-          if (l2 && d && typeof l2.stack === "string") {
-            for (
-              var e = l2.stack.split("\n"),
-                f = d.stack.split("\n"),
-                g = e.length - 1,
-                h = f.length - 1;
-              1 <= g && 0 <= h && e[g] !== f[h];
-
-            )
-              h--;
-            for (; 1 <= g && 0 <= h; g--, h--)
-              if (e[g] !== f[h]) {
-                if (g !== 1 || h !== 1) {
-                  do
-                    if ((g--, h--, 0 > h || e[g] !== f[h])) {
-                      var k = "\n" + e[g].replace(" at new ", " at ");
-                      a.displayName &&
-                        k.includes("<anonymous>") &&
-                        (k = k.replace("<anonymous>", a.displayName));
-                      return k;
-                    }
-                  while (1 <= g && 0 <= h);
-                }
-                break;
-              }
-          }
-        } finally {
-          (La = false), (Error.prepareStackTrace = c);
-        }
-        return (a = a ? a.displayName || a.name : "") ? Ka(a) : "";
-      }
-      function Na(a) {
-        switch (a.tag) {
-          case 5:
-            return Ka(a.type);
-          case 16:
-            return Ka("Lazy");
-          case 13:
-            return Ka("Suspense");
-          case 19:
-            return Ka("SuspenseList");
-          case 0:
-          case 2:
-          case 15:
-            return (a = Ma(a.type, false)), a;
-          case 11:
-            return (a = Ma(a.type.render, false)), a;
-          case 1:
-            return (a = Ma(a.type, true)), a;
-          default:
-            return "";
-        }
-      }
-      function Oa(a) {
-        if (a == null) return null;
-        if (typeof a === "function") return a.displayName || a.name || null;
-        if (typeof a === "string") return a;
-        switch (a) {
-          case va:
-            return "Fragment";
-          case ua:
-            return "Portal";
-          case xa:
-            return "Profiler";
-          case wa:
-            return "StrictMode";
-          case Ca:
-            return "Suspense";
-          case Da:
-            return "SuspenseList";
-        }
-        if (typeof a === "object")
-          switch (a.$$typeof) {
-            case Aa:
-              return (a.displayName || "Context") + ".Consumer";
-            case ya:
-              return (a._context.displayName || "Context") + ".Provider";
-            case Ba:
-              var b = a.render;
-              a = a.displayName;
-              a ||
-                ((a = b.displayName || b.name || ""),
-                (a = a !== "" ? "ForwardRef(" + a + ")" : "ForwardRef"));
-              return a;
-            case Ea:
-              return (
-                (b = a.displayName || null),
-                b !== null ? b : Oa(a.type) || "Memo"
-              );
-            case Fa:
-              b = a._payload;
-              a = a._init;
-              try {
-                return Oa(a(b));
-              } catch (c) {}
-          }
-        return null;
-      }
-      function Pa(a) {
-        var b = a.type;
-        switch (a.tag) {
-          case 24:
-            return "Cache";
-          case 9:
-            return (b.displayName || "Context") + ".Consumer";
-          case 10:
-            return (b._context.displayName || "Context") + ".Provider";
-          case 18:
-            return "DehydratedFragment";
-          case 11:
-            return (
-              (a = b.render),
-              (a = a.displayName || a.name || ""),
-              b.displayName ||
-                (a !== "" ? "ForwardRef(" + a + ")" : "ForwardRef")
-            );
-          case 7:
-            return "Fragment";
-          case 5:
-            return b;
-          case 4:
-            return "Portal";
-          case 3:
-            return "Root";
-          case 6:
-            return "Text";
-          case 16:
-            return Oa(b);
-          case 8:
-            return b === wa ? "StrictMode" : "Mode";
-          case 22:
-            return "Offscreen";
-          case 12:
-            return "Profiler";
-          case 21:
-            return "Scope";
-          case 13:
-            return "Suspense";
-          case 19:
-            return "SuspenseList";
-          case 25:
-            return "TracingMarker";
-          case 1:
-          case 0:
-          case 17:
-          case 2:
-          case 14:
-          case 15:
-            if (typeof b === "function") return b.displayName || b.name || null;
-            if (typeof b === "string") return b;
-        }
-        return null;
-      }
-      function Qa(a) {
-        switch (typeof a) {
-          case "boolean":
-          case "number":
-          case "string":
-          case "undefined":
-            return a;
-          case "object":
-            return a;
-          default:
-            return "";
-        }
-      }
-      function Ra(a) {
-        var b = a.type;
-        return (
-          (a = a.nodeName) &&
-          a.toLowerCase() === "input" &&
-          (b === "checkbox" || b === "radio")
-        );
-      }
-      function Sa(a) {
-        var b = Ra(a) ? "checked" : "value",
-          c = Object.getOwnPropertyDescriptor(a.constructor.prototype, b),
-          d = "" + a[b];
-        if (
-          !a.hasOwnProperty(b) &&
-          typeof c !== "undefined" &&
-          typeof c.get === "function" &&
-          typeof c.set === "function"
-        ) {
-          var e = c.get,
-            f = c.set;
-          Object.defineProperty(a, b, {
-            configurable: true,
-            get: function () {
-              return e.call(this);
-            },
-            set: function (a2) {
-              d = "" + a2;
-              f.call(this, a2);
-            },
-          });
-          Object.defineProperty(a, b, { enumerable: c.enumerable });
-          return {
-            getValue: function () {
-              return d;
-            },
-            setValue: function (a2) {
-              d = "" + a2;
-            },
-            stopTracking: function () {
-              a._valueTracker = null;
-              delete a[b];
-            },
-          };
-        }
-      }
-      function Ta(a) {
-        a._valueTracker || (a._valueTracker = Sa(a));
-      }
-      function Ua(a) {
-        if (!a) return false;
-        var b = a._valueTracker;
-        if (!b) return true;
-        var c = b.getValue();
-        var d = "";
-        a && (d = Ra(a) ? (a.checked ? "true" : "false") : a.value);
-        a = d;
-        return a !== c ? (b.setValue(a), true) : false;
-      }
-      function Va(a) {
-        a = a || (typeof document !== "undefined" ? document : void 0);
-        if (typeof a === "undefined") return null;
-        try {
-          return a.activeElement || a.body;
-        } catch (b) {
-          return a.body;
-        }
-      }
-      function Wa(a, b) {
-        var c = b.checked;
-        return A({}, b, {
-          defaultChecked: void 0,
-          defaultValue: void 0,
-          value: void 0,
-          checked: c != null ? c : a._wrapperState.initialChecked,
-        });
-      }
-      function Xa(a, b) {
-        var c = b.defaultValue == null ? "" : b.defaultValue,
-          d = b.checked != null ? b.checked : b.defaultChecked;
-        c = Qa(b.value != null ? b.value : c);
-        a._wrapperState = {
-          initialChecked: d,
-          initialValue: c,
-          controlled:
-            b.type === "checkbox" || b.type === "radio"
-              ? b.checked != null
-              : b.value != null,
-        };
-      }
-      function Ya(a, b) {
-        b = b.checked;
-        b != null && ra(a, "checked", b, false);
-      }
-      function Za(a, b) {
-        Ya(a, b);
-        var c = Qa(b.value),
-          d = b.type;
-        if (c != null)
-          if (d === "number") {
-            if ((c === 0 && a.value === "") || a.value != c) a.value = "" + c;
-          } else a.value !== "" + c && (a.value = "" + c);
-        else if (d === "submit" || d === "reset") {
-          a.removeAttribute("value");
-          return;
-        }
-        b.hasOwnProperty("value")
-          ? $a(a, b.type, c)
-          : b.hasOwnProperty("defaultValue") &&
-            $a(a, b.type, Qa(b.defaultValue));
-        b.checked == null &&
-          b.defaultChecked != null &&
-          (a.defaultChecked = !!b.defaultChecked);
-      }
-      function ab(a, b, c) {
-        if (b.hasOwnProperty("value") || b.hasOwnProperty("defaultValue")) {
-          var d = b.type;
-          if (
-            !(
-              (d !== "submit" && d !== "reset") ||
-              (b.value !== void 0 && b.value !== null)
-            )
-          )
-            return;
-          b = "" + a._wrapperState.initialValue;
-          c || b === a.value || (a.value = b);
-          a.defaultValue = b;
-        }
-        c = a.name;
-        c !== "" && (a.name = "");
-        a.defaultChecked = !!a._wrapperState.initialChecked;
-        c !== "" && (a.name = c);
-      }
-      function $a(a, b, c) {
-        if (b !== "number" || Va(a.ownerDocument) !== a)
-          c == null
-            ? (a.defaultValue = "" + a._wrapperState.initialValue)
-            : a.defaultValue !== "" + c && (a.defaultValue = "" + c);
-      }
-      var bb = Array.isArray;
-      function cb(a, b, c, d) {
-        a = a.options;
-        if (b) {
-          b = {};
-          for (var e = 0; e < c.length; e++) b["$" + c[e]] = true;
-          for (c = 0; c < a.length; c++)
-            (e = b.hasOwnProperty("$" + a[c].value)),
-              a[c].selected !== e && (a[c].selected = e),
-              e && d && (a[c].defaultSelected = true);
-        } else {
-          c = "" + Qa(c);
-          b = null;
-          for (e = 0; e < a.length; e++) {
-            if (a[e].value === c) {
-              a[e].selected = true;
-              d && (a[e].defaultSelected = true);
-              return;
-            }
-            b !== null || a[e].disabled || (b = a[e]);
-          }
-          b !== null && (b.selected = true);
-        }
-      }
-      function db(a, b) {
-        if (b.dangerouslySetInnerHTML != null) throw Error(p$1(91));
-        return A({}, b, {
-          value: void 0,
-          defaultValue: void 0,
-          children: "" + a._wrapperState.initialValue,
-        });
-      }
-      function eb(a, b) {
-        var c = b.value;
-        if (c == null) {
-          c = b.children;
-          b = b.defaultValue;
-          if (c != null) {
-            if (b != null) throw Error(p$1(92));
-            if (bb(c)) {
-              if (1 < c.length) throw Error(p$1(93));
-              c = c[0];
-            }
-            b = c;
-          }
-          b == null && (b = "");
-          c = b;
-        }
-        a._wrapperState = { initialValue: Qa(c) };
-      }
-      function fb(a, b) {
-        var c = Qa(b.value),
-          d = Qa(b.defaultValue);
-        c != null &&
-          ((c = "" + c),
-          c !== a.value && (a.value = c),
-          b.defaultValue == null &&
-            a.defaultValue !== c &&
-            (a.defaultValue = c));
-        d != null && (a.defaultValue = "" + d);
-      }
-      function gb(a) {
-        var b = a.textContent;
-        b === a._wrapperState.initialValue &&
-          b !== "" &&
-          b !== null &&
-          (a.value = b);
-      }
-      function hb(a) {
-        switch (a) {
-          case "svg":
-            return "http://www.w3.org/2000/svg";
-          case "math":
-            return "http://www.w3.org/1998/Math/MathML";
-          default:
-            return "http://www.w3.org/1999/xhtml";
-        }
-      }
-      function ib(a, b) {
-        return a == null || a === "http://www.w3.org/1999/xhtml"
-          ? hb(b)
-          : a === "http://www.w3.org/2000/svg" && b === "foreignObject"
-          ? "http://www.w3.org/1999/xhtml"
-          : a;
-      }
-      var jb,
-        kb = (function (a) {
-          return typeof MSApp !== "undefined" && MSApp.execUnsafeLocalFunction
-            ? function (b, c, d, e) {
-                MSApp.execUnsafeLocalFunction(function () {
-                  return a(b, c, d, e);
-                });
-              }
-            : a;
-        })(function (a, b) {
-          if (
-            a.namespaceURI !== "http://www.w3.org/2000/svg" ||
-            "innerHTML" in a
-          )
-            a.innerHTML = b;
-          else {
-            jb = jb || document.createElement("div");
-            jb.innerHTML = "<svg>" + b.valueOf().toString() + "</svg>";
-            for (b = jb.firstChild; a.firstChild; ) a.removeChild(a.firstChild);
-            for (; b.firstChild; ) a.appendChild(b.firstChild);
-          }
-        });
-      function lb(a, b) {
-        if (b) {
-          var c = a.firstChild;
-          if (c && c === a.lastChild && c.nodeType === 3) {
-            c.nodeValue = b;
-            return;
-          }
-        }
-        a.textContent = b;
-      }
-      var mb = {
-          animationIterationCount: true,
-          aspectRatio: true,
-          borderImageOutset: true,
-          borderImageSlice: true,
-          borderImageWidth: true,
-          boxFlex: true,
-          boxFlexGroup: true,
-          boxOrdinalGroup: true,
-          columnCount: true,
-          columns: true,
-          flex: true,
-          flexGrow: true,
-          flexPositive: true,
-          flexShrink: true,
-          flexNegative: true,
-          flexOrder: true,
-          gridArea: true,
-          gridRow: true,
-          gridRowEnd: true,
-          gridRowSpan: true,
-          gridRowStart: true,
-          gridColumn: true,
-          gridColumnEnd: true,
-          gridColumnSpan: true,
-          gridColumnStart: true,
-          fontWeight: true,
-          lineClamp: true,
-          lineHeight: true,
-          opacity: true,
-          order: true,
-          orphans: true,
-          tabSize: true,
-          widows: true,
-          zIndex: true,
-          zoom: true,
-          fillOpacity: true,
-          floodOpacity: true,
-          stopOpacity: true,
-          strokeDasharray: true,
-          strokeDashoffset: true,
-          strokeMiterlimit: true,
-          strokeOpacity: true,
-          strokeWidth: true,
-        },
-        nb = ["Webkit", "ms", "Moz", "O"];
-      Object.keys(mb).forEach(function (a) {
-        nb.forEach(function (b) {
-          b = b + a.charAt(0).toUpperCase() + a.substring(1);
-          mb[b] = mb[a];
-        });
-      });
-      function ob(a, b, c) {
-        return b == null || typeof b === "boolean" || b === ""
-          ? ""
-          : c ||
-            typeof b !== "number" ||
-            b === 0 ||
-            (mb.hasOwnProperty(a) && mb[a])
-          ? ("" + b).trim()
-          : b + "px";
-      }
-      function pb(a, b) {
-        a = a.style;
-        for (var c in b)
-          if (b.hasOwnProperty(c)) {
-            var d = c.indexOf("--") === 0,
-              e = ob(c, b[c], d);
-            c === "float" && (c = "cssFloat");
-            d ? a.setProperty(c, e) : (a[c] = e);
-          }
-      }
-      var qb = A(
-        { menuitem: true },
-        {
-          area: true,
-          base: true,
-          br: true,
-          col: true,
-          embed: true,
-          hr: true,
-          img: true,
-          input: true,
-          keygen: true,
-          link: true,
-          meta: true,
-          param: true,
-          source: true,
-          track: true,
-          wbr: true,
-        }
-      );
-      function rb(a, b) {
-        if (b) {
-          if (
-            qb[a] &&
-            (b.children != null || b.dangerouslySetInnerHTML != null)
-          )
-            throw Error(p$1(137, a));
-          if (b.dangerouslySetInnerHTML != null) {
-            if (b.children != null) throw Error(p$1(60));
-            if (
-              typeof b.dangerouslySetInnerHTML !== "object" ||
-              !("__html" in b.dangerouslySetInnerHTML)
-            )
-              throw Error(p$1(61));
-          }
-          if (b.style != null && typeof b.style !== "object")
-            throw Error(p$1(62));
-        }
-      }
-      function sb(a, b) {
-        if (a.indexOf("-") === -1) return typeof b.is === "string";
-        switch (a) {
-          case "annotation-xml":
-          case "color-profile":
-          case "font-face":
-          case "font-face-src":
-          case "font-face-uri":
-          case "font-face-format":
-          case "font-face-name":
-          case "missing-glyph":
-            return false;
-          default:
-            return true;
-        }
-      }
-      var tb = null;
-      function ub(a) {
-        a = a.target || a.srcElement || window;
-        a.correspondingUseElement && (a = a.correspondingUseElement);
-        return a.nodeType === 3 ? a.parentNode : a;
-      }
-      var vb = null,
-        wb = null,
-        xb = null;
-      function yb(a) {
-        if ((a = zb(a))) {
-          if (typeof vb !== "function") throw Error(p$1(280));
-          var b = a.stateNode;
-          b && ((b = Ab(b)), vb(a.stateNode, a.type, b));
-        }
-      }
-      function Bb(a) {
-        wb ? (xb ? xb.push(a) : (xb = [a])) : (wb = a);
-      }
-      function Cb() {
-        if (wb) {
-          var a = wb,
-            b = xb;
-          xb = wb = null;
-          yb(a);
-          if (b) for (a = 0; a < b.length; a++) yb(b[a]);
-        }
-      }
-      function Db(a, b) {
-        return a(b);
-      }
-      function Eb() {}
-      var Fb = false;
-      function Gb(a, b, c) {
-        if (Fb) return a(b, c);
-        Fb = true;
-        try {
-          return Db(a, b, c);
-        } finally {
-          if (((Fb = false), wb !== null || xb !== null)) Eb(), Cb();
-        }
-      }
-      function Hb(a, b) {
-        var c = a.stateNode;
-        if (c === null) return null;
-        var d = Ab(c);
-        if (d === null) return null;
-        c = d[b];
-        a: switch (b) {
-          case "onClick":
-          case "onClickCapture":
-          case "onDoubleClick":
-          case "onDoubleClickCapture":
-          case "onMouseDown":
-          case "onMouseDownCapture":
-          case "onMouseMove":
-          case "onMouseMoveCapture":
-          case "onMouseUp":
-          case "onMouseUpCapture":
-          case "onMouseEnter":
-            (d = !d.disabled) ||
-              ((a = a.type),
-              (d = !(
-                a === "button" ||
-                a === "input" ||
-                a === "select" ||
-                a === "textarea"
-              )));
-            a = !d;
-            break a;
-          default:
-            a = false;
-        }
-        if (a) return null;
-        if (c && typeof c !== "function") throw Error(p$1(231, b, typeof c));
-        return c;
-      }
-      var Ib = false;
-      if (ha)
-        try {
-          var Jb = {};
-          Object.defineProperty(Jb, "passive", {
-            get: function () {
-              Ib = true;
-            },
-          });
-          window.addEventListener("test", Jb, Jb);
-          window.removeEventListener("test", Jb, Jb);
-        } catch (a) {
-          Ib = false;
-        }
-      function Kb(a, b, c, d, e, f, g, h, k) {
-        var l2 = Array.prototype.slice.call(arguments, 3);
-        try {
-          b.apply(c, l2);
-        } catch (m) {
-          this.onError(m);
-        }
-      }
-      var Lb = false,
-        Mb = null,
-        Nb = false,
-        Ob = null,
-        Pb = {
-          onError: function (a) {
-            Lb = true;
-            Mb = a;
-          },
-        };
-      function Qb(a, b, c, d, e, f, g, h, k) {
-        Lb = false;
-        Mb = null;
-        Kb.apply(Pb, arguments);
-      }
-      function Rb(a, b, c, d, e, f, g, h, k) {
-        Qb.apply(this, arguments);
-        if (Lb) {
-          if (Lb) {
-            var l2 = Mb;
-            Lb = false;
-            Mb = null;
-          } else throw Error(p$1(198));
-          Nb || ((Nb = true), (Ob = l2));
-        }
-      }
-      function Sb(a) {
-        var b = a,
-          c = a;
-        if (a.alternate) for (; b.return; ) b = b.return;
-        else {
-          a = b;
-          do (b = a), (b.flags & 4098) !== 0 && (c = b.return), (a = b.return);
-          while (a);
-        }
-        return b.tag === 3 ? c : null;
-      }
-      function Tb(a) {
-        if (a.tag === 13) {
-          var b = a.memoizedState;
-          b === null &&
-            ((a = a.alternate), a !== null && (b = a.memoizedState));
-          if (b !== null) return b.dehydrated;
-        }
-        return null;
-      }
-      function Ub(a) {
-        if (Sb(a) !== a) throw Error(p$1(188));
-      }
-      function Vb(a) {
-        var b = a.alternate;
-        if (!b) {
-          b = Sb(a);
-          if (b === null) throw Error(p$1(188));
-          return b !== a ? null : a;
-        }
-        for (var c = a, d = b; ; ) {
-          var e = c.return;
-          if (e === null) break;
-          var f = e.alternate;
-          if (f === null) {
-            d = e.return;
-            if (d !== null) {
-              c = d;
-              continue;
-            }
-            break;
-          }
-          if (e.child === f.child) {
-            for (f = e.child; f; ) {
-              if (f === c) return Ub(e), a;
-              if (f === d) return Ub(e), b;
-              f = f.sibling;
-            }
-            throw Error(p$1(188));
-          }
-          if (c.return !== d.return) (c = e), (d = f);
-          else {
-            for (var g = false, h = e.child; h; ) {
-              if (h === c) {
-                g = true;
-                c = e;
-                d = f;
-                break;
-              }
-              if (h === d) {
-                g = true;
-                d = e;
-                c = f;
-                break;
-              }
-              h = h.sibling;
-            }
-            if (!g) {
-              for (h = f.child; h; ) {
-                if (h === c) {
-                  g = true;
-                  c = f;
-                  d = e;
-                  break;
-                }
-                if (h === d) {
-                  g = true;
-                  d = f;
-                  c = e;
-                  break;
-                }
-                h = h.sibling;
-              }
-              if (!g) throw Error(p$1(189));
-            }
-          }
-          if (c.alternate !== d) throw Error(p$1(190));
-        }
-        if (c.tag !== 3) throw Error(p$1(188));
-        return c.stateNode.current === c ? a : b;
-      }
-      function Wb(a) {
-        a = Vb(a);
-        return a !== null ? Xb(a) : null;
-      }
-      function Xb(a) {
-        if (a.tag === 5 || a.tag === 6) return a;
-        for (a = a.child; a !== null; ) {
-          var b = Xb(a);
-          if (b !== null) return b;
-          a = a.sibling;
-        }
-        return null;
-      }
-      var Yb = ba.unstable_scheduleCallback,
-        Zb = ba.unstable_cancelCallback,
-        $b = ba.unstable_shouldYield,
-        ac$1 = ba.unstable_requestPaint,
-        D = ba.unstable_now,
-        bc = ba.unstable_getCurrentPriorityLevel,
-        cc = ba.unstable_ImmediatePriority,
-        dc = ba.unstable_UserBlockingPriority,
-        ec = ba.unstable_NormalPriority,
-        fc = ba.unstable_LowPriority,
-        gc = ba.unstable_IdlePriority,
-        hc = null,
-        ic$1 = null;
-      function jc(a) {
-        if (ic$1 && typeof ic$1.onCommitFiberRoot === "function")
-          try {
-            ic$1.onCommitFiberRoot(
-              hc,
-              a,
-              void 0,
-              (a.current.flags & 128) === 128
-            );
-          } catch (b) {}
-      }
-      var lc = Math.clz32 ? Math.clz32 : kc,
-        mc = Math.log,
-        nc = Math.LN2;
-      function kc(a) {
-        a >>>= 0;
-        return a === 0 ? 32 : (31 - ((mc(a) / nc) | 0)) | 0;
-      }
-      var oc = 64,
-        pc = 4194304;
-      function qc(a) {
-        switch (a & -a) {
-          case 1:
-            return 1;
-          case 2:
-            return 2;
-          case 4:
-            return 4;
-          case 8:
-            return 8;
-          case 16:
-            return 16;
-          case 32:
-            return 32;
-          case 64:
-          case 128:
-          case 256:
-          case 512:
-          case 1024:
-          case 2048:
-          case 4096:
-          case 8192:
-          case 16384:
-          case 32768:
-          case 65536:
-          case 131072:
-          case 262144:
-          case 524288:
-          case 1048576:
-          case 2097152:
-            return a & 4194240;
-          case 4194304:
-          case 8388608:
-          case 16777216:
-          case 33554432:
-          case 67108864:
-            return a & 130023424;
-          case 134217728:
-            return 134217728;
-          case 268435456:
-            return 268435456;
-          case 536870912:
-            return 536870912;
-          case 1073741824:
-            return 1073741824;
-          default:
-            return a;
-        }
-      }
-      function rc(a, b) {
-        var c = a.pendingLanes;
-        if (c === 0) return 0;
-        var d = 0,
-          e = a.suspendedLanes,
-          f = a.pingedLanes,
-          g = c & 268435455;
-        if (g !== 0) {
-          var h = g & ~e;
-          h !== 0 ? (d = qc(h)) : ((f &= g), f !== 0 && (d = qc(f)));
-        } else (g = c & ~e), g !== 0 ? (d = qc(g)) : f !== 0 && (d = qc(f));
-        if (d === 0) return 0;
-        if (
-          b !== 0 &&
-          b !== d &&
-          (b & e) === 0 &&
-          ((e = d & -d),
-          (f = b & -b),
-          e >= f || (e === 16 && (f & 4194240) !== 0))
-        )
-          return b;
-        (d & 4) !== 0 && (d |= c & 16);
-        b = a.entangledLanes;
-        if (b !== 0)
-          for (a = a.entanglements, b &= d; 0 < b; )
-            (c = 31 - lc(b)), (e = 1 << c), (d |= a[c]), (b &= ~e);
-        return d;
-      }
-      function sc$1(a, b) {
-        switch (a) {
-          case 1:
-          case 2:
-          case 4:
-            return b + 250;
-          case 8:
-          case 16:
-          case 32:
-          case 64:
-          case 128:
-          case 256:
-          case 512:
-          case 1024:
-          case 2048:
-          case 4096:
-          case 8192:
-          case 16384:
-          case 32768:
-          case 65536:
-          case 131072:
-          case 262144:
-          case 524288:
-          case 1048576:
-          case 2097152:
-            return b + 5e3;
-          case 4194304:
-          case 8388608:
-          case 16777216:
-          case 33554432:
-          case 67108864:
-            return -1;
-          case 134217728:
-          case 268435456:
-          case 536870912:
-          case 1073741824:
-            return -1;
-          default:
-            return -1;
-        }
-      }
-      function tc(a, b) {
-        for (
-          var c = a.suspendedLanes,
-            d = a.pingedLanes,
-            e = a.expirationTimes,
-            f = a.pendingLanes;
-          0 < f;
-
-        ) {
-          var g = 31 - lc(f),
-            h = 1 << g,
-            k = e[g];
-          if (k === -1) {
-            if ((h & c) === 0 || (h & d) !== 0) e[g] = sc$1(h, b);
-          } else k <= b && (a.expiredLanes |= h);
-          f &= ~h;
-        }
-      }
-      function uc(a) {
-        a = a.pendingLanes & -1073741825;
-        return a !== 0 ? a : a & 1073741824 ? 1073741824 : 0;
-      }
-      function vc(a) {
-        for (var b = [], c = 0; 31 > c; c++) b.push(a);
-        return b;
-      }
-      function wc(a, b, c) {
-        a.pendingLanes |= b;
-        b !== 536870912 && ((a.suspendedLanes = 0), (a.pingedLanes = 0));
-        a = a.eventTimes;
-        b = 31 - lc(b);
-        a[b] = c;
-      }
-      function xc(a, b) {
-        var c = a.pendingLanes & ~b;
-        a.pendingLanes = b;
-        a.suspendedLanes = 0;
-        a.pingedLanes = 0;
-        a.expiredLanes &= b;
-        a.mutableReadLanes &= b;
-        a.entangledLanes &= b;
-        b = a.entanglements;
-        var d = a.eventTimes;
-        for (a = a.expirationTimes; 0 < c; ) {
-          var e = 31 - lc(c),
-            f = 1 << e;
-          b[e] = 0;
-          d[e] = -1;
-          a[e] = -1;
-          c &= ~f;
-        }
-      }
-      function yc(a, b) {
-        var c = (a.entangledLanes |= b);
-        for (a = a.entanglements; c; ) {
-          var d = 31 - lc(c),
-            e = 1 << d;
-          (e & b) | (a[d] & b) && (a[d] |= b);
-          c &= ~e;
-        }
-      }
-      var E = 0;
-      function zc(a) {
-        a &= -a;
-        return 1 < a
-          ? 4 < a
-            ? (a & 268435455) !== 0
-              ? 16
-              : 536870912
-            : 4
-          : 1;
-      }
-      var Ac,
-        Bc,
-        Cc,
-        Dc,
-        Ec,
-        Fc = false,
-        Gc = [],
-        Hc = null,
-        Ic = null,
-        Jc = null,
-        Kc = /* @__PURE__ */ new Map(),
-        Lc = /* @__PURE__ */ new Map(),
-        Mc = [],
-        Nc =
-          "mousedown mouseup touchcancel touchend touchstart auxclick dblclick pointercancel pointerdown pointerup dragend dragstart drop compositionend compositionstart keydown keypress keyup input textInput copy cut paste click change contextmenu reset submit".split(
-            " "
-          );
-      function Oc(a, b) {
-        switch (a) {
-          case "focusin":
-          case "focusout":
-            Hc = null;
-            break;
-          case "dragenter":
-          case "dragleave":
-            Ic = null;
-            break;
-          case "mouseover":
-          case "mouseout":
-            Jc = null;
-            break;
-          case "pointerover":
-          case "pointerout":
-            Kc.delete(b.pointerId);
-            break;
-          case "gotpointercapture":
-          case "lostpointercapture":
-            Lc.delete(b.pointerId);
-        }
-      }
-      function Pc(a, b, c, d, e, f) {
-        if (a === null || a.nativeEvent !== f)
-          return (
-            (a = {
-              blockedOn: b,
-              domEventName: c,
-              eventSystemFlags: d,
-              nativeEvent: f,
-              targetContainers: [e],
-            }),
-            b !== null && ((b = zb(b)), b !== null && Bc(b)),
-            a
-          );
-        a.eventSystemFlags |= d;
-        b = a.targetContainers;
-        e !== null && b.indexOf(e) === -1 && b.push(e);
-        return a;
-      }
-      function Qc(a, b, c, d, e) {
-        switch (b) {
-          case "focusin":
-            return (Hc = Pc(Hc, a, b, c, d, e)), true;
-          case "dragenter":
-            return (Ic = Pc(Ic, a, b, c, d, e)), true;
-          case "mouseover":
-            return (Jc = Pc(Jc, a, b, c, d, e)), true;
-          case "pointerover":
-            var f = e.pointerId;
-            Kc.set(f, Pc(Kc.get(f) || null, a, b, c, d, e));
-            return true;
-          case "gotpointercapture":
-            return (
-              (f = e.pointerId),
-              Lc.set(f, Pc(Lc.get(f) || null, a, b, c, d, e)),
-              true
-            );
-        }
-        return false;
-      }
-      function Rc(a) {
-        var b = Sc$1(a.target);
-        if (b !== null) {
-          var c = Sb(b);
-          if (c !== null) {
-            if (((b = c.tag), b === 13)) {
-              if (((b = Tb(c)), b !== null)) {
-                a.blockedOn = b;
-                Ec(a.priority, function () {
-                  Cc(c);
-                });
-                return;
-              }
-            } else if (
-              b === 3 &&
-              c.stateNode.current.memoizedState.isDehydrated
-            ) {
-              a.blockedOn = c.tag === 3 ? c.stateNode.containerInfo : null;
-              return;
-            }
-          }
-        }
-        a.blockedOn = null;
-      }
-      function Tc(a) {
-        if (a.blockedOn !== null) return false;
-        for (var b = a.targetContainers; 0 < b.length; ) {
-          var c = Uc(a.domEventName, a.eventSystemFlags, b[0], a.nativeEvent);
-          if (c === null) {
-            c = a.nativeEvent;
-            var d = new c.constructor(c.type, c);
-            tb = d;
-            c.target.dispatchEvent(d);
-            tb = null;
-          } else
-            return (b = zb(c)), b !== null && Bc(b), (a.blockedOn = c), false;
-          b.shift();
-        }
-        return true;
-      }
-      function Vc(a, b, c) {
-        Tc(a) && c.delete(b);
-      }
-      function Wc() {
-        Fc = false;
-        Hc !== null && Tc(Hc) && (Hc = null);
-        Ic !== null && Tc(Ic) && (Ic = null);
-        Jc !== null && Tc(Jc) && (Jc = null);
-        Kc.forEach(Vc);
-        Lc.forEach(Vc);
-      }
-      function Xc(a, b) {
-        a.blockedOn === b &&
-          ((a.blockedOn = null),
-          Fc ||
-            ((Fc = true),
-            ba.unstable_scheduleCallback(ba.unstable_NormalPriority, Wc)));
-      }
-      function Yc(a) {
-        function b(b2) {
-          return Xc(b2, a);
-        }
-        if (0 < Gc.length) {
-          Xc(Gc[0], a);
-          for (var c = 1; c < Gc.length; c++) {
-            var d = Gc[c];
-            d.blockedOn === a && (d.blockedOn = null);
-          }
-        }
-        Hc !== null && Xc(Hc, a);
-        Ic !== null && Xc(Ic, a);
-        Jc !== null && Xc(Jc, a);
-        Kc.forEach(b);
-        Lc.forEach(b);
-        for (c = 0; c < Mc.length; c++)
-          (d = Mc[c]), d.blockedOn === a && (d.blockedOn = null);
-        for (; 0 < Mc.length && ((c = Mc[0]), c.blockedOn === null); )
-          Rc(c), c.blockedOn === null && Mc.shift();
-      }
-      var Zc = sa.ReactCurrentBatchConfig;
-      function $c(a, b, c, d) {
-        var e = E,
-          f = Zc.transition;
-        Zc.transition = null;
-        try {
-          (E = 1), ad(a, b, c, d);
-        } finally {
-          (E = e), (Zc.transition = f);
-        }
-      }
-      function bd(a, b, c, d) {
-        var e = E,
-          f = Zc.transition;
-        Zc.transition = null;
-        try {
-          (E = 4), ad(a, b, c, d);
-        } finally {
-          (E = e), (Zc.transition = f);
-        }
-      }
-      function ad(a, b, c, d) {
-        var e = Uc(a, b, c, d);
-        if (e === null) cd(a, b, d, dd$1, c), Oc(a, d);
-        else if (Qc(e, a, b, c, d)) d.stopPropagation();
-        else if ((Oc(a, d), b & 4 && -1 < Nc.indexOf(a))) {
-          for (; e !== null; ) {
-            var f = zb(e);
-            f !== null && Ac(f);
-            f = Uc(a, b, c, d);
-            f === null && cd(a, b, d, dd$1, c);
-            if (f === e) break;
-            e = f;
-          }
-          e !== null && d.stopPropagation();
-        } else cd(a, b, d, null, c);
-      }
-      var dd$1 = null;
-      function Uc(a, b, c, d) {
-        dd$1 = null;
-        a = ub(d);
-        a = Sc$1(a);
-        if (a !== null)
-          if (((b = Sb(a)), b === null)) a = null;
-          else if (((c = b.tag), c === 13)) {
-            a = Tb(b);
-            if (a !== null) return a;
-            a = null;
-          } else if (c === 3) {
-            if (b.stateNode.current.memoizedState.isDehydrated)
-              return b.tag === 3 ? b.stateNode.containerInfo : null;
-            a = null;
-          } else b !== a && (a = null);
-        dd$1 = a;
-        return null;
-      }
-      function ed(a) {
-        switch (a) {
-          case "cancel":
-          case "click":
-          case "close":
-          case "contextmenu":
-          case "copy":
-          case "cut":
-          case "auxclick":
-          case "dblclick":
-          case "dragend":
-          case "dragstart":
-          case "drop":
-          case "focusin":
-          case "focusout":
-          case "input":
-          case "invalid":
-          case "keydown":
-          case "keypress":
-          case "keyup":
-          case "mousedown":
-          case "mouseup":
-          case "paste":
-          case "pause":
-          case "play":
-          case "pointercancel":
-          case "pointerdown":
-          case "pointerup":
-          case "ratechange":
-          case "reset":
-          case "resize":
-          case "seeked":
-          case "submit":
-          case "touchcancel":
-          case "touchend":
-          case "touchstart":
-          case "volumechange":
-          case "change":
-          case "selectionchange":
-          case "textInput":
-          case "compositionstart":
-          case "compositionend":
-          case "compositionupdate":
-          case "beforeblur":
-          case "afterblur":
-          case "beforeinput":
-          case "blur":
-          case "fullscreenchange":
-          case "focus":
-          case "hashchange":
-          case "popstate":
-          case "select":
-          case "selectstart":
-            return 1;
-          case "drag":
-          case "dragenter":
-          case "dragexit":
-          case "dragleave":
-          case "dragover":
-          case "mousemove":
-          case "mouseout":
-          case "mouseover":
-          case "pointermove":
-          case "pointerout":
-          case "pointerover":
-          case "scroll":
-          case "toggle":
-          case "touchmove":
-          case "wheel":
-          case "mouseenter":
-          case "mouseleave":
-          case "pointerenter":
-          case "pointerleave":
-            return 4;
-          case "message":
-            switch (bc()) {
-              case cc:
-                return 1;
-              case dc:
-                return 4;
-              case ec:
-              case fc:
-                return 16;
-              case gc:
-                return 536870912;
-              default:
-                return 16;
-            }
-          default:
-            return 16;
-        }
-      }
-      var fd = null,
-        gd = null,
-        hd = null;
-      function id() {
-        if (hd) return hd;
-        var a,
-          b = gd,
-          c = b.length,
-          d,
-          e = "value" in fd ? fd.value : fd.textContent,
-          f = e.length;
-        for (a = 0; a < c && b[a] === e[a]; a++);
-        var g = c - a;
-        for (d = 1; d <= g && b[c - d] === e[f - d]; d++);
-        return (hd = e.slice(a, 1 < d ? 1 - d : void 0));
-      }
-      function jd(a) {
-        var b = a.keyCode;
-        "charCode" in a
-          ? ((a = a.charCode), a === 0 && b === 13 && (a = 13))
-          : (a = b);
-        a === 10 && (a = 13);
-        return 32 <= a || a === 13 ? a : 0;
-      }
-      function kd() {
-        return true;
-      }
-      function ld() {
-        return false;
-      }
-      function md$3(a) {
-        function b(b2, d, e, f, g) {
-          this._reactName = b2;
-          this._targetInst = e;
-          this.type = d;
-          this.nativeEvent = f;
-          this.target = g;
-          this.currentTarget = null;
-          for (var c in a)
-            a.hasOwnProperty(c) && ((b2 = a[c]), (this[c] = b2 ? b2(f) : f[c]));
-          this.isDefaultPrevented = (
-            f.defaultPrevented != null
-              ? f.defaultPrevented
-              : f.returnValue === false
-          )
-            ? kd
-            : ld;
-          this.isPropagationStopped = ld;
-          return this;
-        }
-        A(b.prototype, {
-          preventDefault: function () {
-            this.defaultPrevented = true;
-            var a2 = this.nativeEvent;
-            a2 &&
-              (a2.preventDefault
-                ? a2.preventDefault()
-                : typeof a2.returnValue !== "unknown" &&
-                  (a2.returnValue = false),
-              (this.isDefaultPrevented = kd));
-          },
-          stopPropagation: function () {
-            var a2 = this.nativeEvent;
-            a2 &&
-              (a2.stopPropagation
-                ? a2.stopPropagation()
-                : typeof a2.cancelBubble !== "unknown" &&
-                  (a2.cancelBubble = true),
-              (this.isPropagationStopped = kd));
-          },
-          persist: function () {},
-          isPersistent: kd,
-        });
-        return b;
-      }
-      var nd = {
-          eventPhase: 0,
-          bubbles: 0,
-          cancelable: 0,
-          timeStamp: function (a) {
-            return a.timeStamp || Date.now();
-          },
-          defaultPrevented: 0,
-          isTrusted: 0,
-        },
-        od = md$3(nd),
-        pd = A({}, nd, { view: 0, detail: 0 }),
-        qd = md$3(pd),
-        rd,
-        sd,
-        td,
-        vd = A({}, pd, {
-          screenX: 0,
-          screenY: 0,
-          clientX: 0,
-          clientY: 0,
-          pageX: 0,
-          pageY: 0,
-          ctrlKey: 0,
-          shiftKey: 0,
-          altKey: 0,
-          metaKey: 0,
-          getModifierState: ud,
-          button: 0,
-          buttons: 0,
-          relatedTarget: function (a) {
-            return a.relatedTarget === void 0
-              ? a.fromElement === a.srcElement
-                ? a.toElement
-                : a.fromElement
-              : a.relatedTarget;
-          },
-          movementX: function (a) {
-            if ("movementX" in a) return a.movementX;
-            a !== td &&
-              (td && a.type === "mousemove"
-                ? ((rd = a.screenX - td.screenX), (sd = a.screenY - td.screenY))
-                : (sd = rd = 0),
-              (td = a));
-            return rd;
-          },
-          movementY: function (a) {
-            return "movementY" in a ? a.movementY : sd;
-          },
-        }),
-        wd = md$3(vd),
-        xd = A({}, vd, { dataTransfer: 0 }),
-        yd = md$3(xd),
-        zd = A({}, pd, { relatedTarget: 0 }),
-        Ad = md$3(zd),
-        Bd = A({}, nd, { animationName: 0, elapsedTime: 0, pseudoElement: 0 }),
-        Cd = md$3(Bd),
-        Dd = A({}, nd, {
-          clipboardData: function (a) {
-            return "clipboardData" in a
-              ? a.clipboardData
-              : window.clipboardData;
-          },
-        }),
-        Ed = md$3(Dd),
-        Fd = A({}, nd, { data: 0 }),
-        Gd = md$3(Fd),
-        Hd = {
-          Esc: "Escape",
-          Spacebar: " ",
-          Left: "ArrowLeft",
-          Up: "ArrowUp",
-          Right: "ArrowRight",
-          Down: "ArrowDown",
-          Del: "Delete",
-          Win: "OS",
-          Menu: "ContextMenu",
-          Apps: "ContextMenu",
-          Scroll: "ScrollLock",
-          MozPrintableKey: "Unidentified",
-        },
-        Id = {
-          8: "Backspace",
-          9: "Tab",
-          12: "Clear",
-          13: "Enter",
-          16: "Shift",
-          17: "Control",
-          18: "Alt",
-          19: "Pause",
-          20: "CapsLock",
-          27: "Escape",
-          32: " ",
-          33: "PageUp",
-          34: "PageDown",
-          35: "End",
-          36: "Home",
-          37: "ArrowLeft",
-          38: "ArrowUp",
-          39: "ArrowRight",
-          40: "ArrowDown",
-          45: "Insert",
-          46: "Delete",
-          112: "F1",
-          113: "F2",
-          114: "F3",
-          115: "F4",
-          116: "F5",
-          117: "F6",
-          118: "F7",
-          119: "F8",
-          120: "F9",
-          121: "F10",
-          122: "F11",
-          123: "F12",
-          144: "NumLock",
-          145: "ScrollLock",
-          224: "Meta",
-        },
-        Jd = {
-          Alt: "altKey",
-          Control: "ctrlKey",
-          Meta: "metaKey",
-          Shift: "shiftKey",
-        };
-      function Kd(a) {
-        var b = this.nativeEvent;
-        return b.getModifierState
-          ? b.getModifierState(a)
-          : (a = Jd[a])
-          ? !!b[a]
-          : false;
-      }
-      function ud() {
-        return Kd;
-      }
-      var Ld = A({}, pd, {
-          key: function (a) {
-            if (a.key) {
-              var b = Hd[a.key] || a.key;
-              if (b !== "Unidentified") return b;
-            }
-            return a.type === "keypress"
-              ? ((a = jd(a)), a === 13 ? "Enter" : String.fromCharCode(a))
-              : a.type === "keydown" || a.type === "keyup"
-              ? Id[a.keyCode] || "Unidentified"
-              : "";
-          },
-          code: 0,
-          location: 0,
-          ctrlKey: 0,
-          shiftKey: 0,
-          altKey: 0,
-          metaKey: 0,
-          repeat: 0,
-          locale: 0,
-          getModifierState: ud,
-          charCode: function (a) {
-            return a.type === "keypress" ? jd(a) : 0;
-          },
-          keyCode: function (a) {
-            return a.type === "keydown" || a.type === "keyup" ? a.keyCode : 0;
-          },
-          which: function (a) {
-            return a.type === "keypress"
-              ? jd(a)
-              : a.type === "keydown" || a.type === "keyup"
-              ? a.keyCode
-              : 0;
-          },
-        }),
-        Md = md$3(Ld),
-        Nd = A({}, vd, {
-          pointerId: 0,
-          width: 0,
-          height: 0,
-          pressure: 0,
-          tangentialPressure: 0,
-          tiltX: 0,
-          tiltY: 0,
-          twist: 0,
-          pointerType: 0,
-          isPrimary: 0,
-        }),
-        Od = md$3(Nd),
-        Pd = A({}, pd, {
-          touches: 0,
-          targetTouches: 0,
-          changedTouches: 0,
-          altKey: 0,
-          metaKey: 0,
-          ctrlKey: 0,
-          shiftKey: 0,
-          getModifierState: ud,
-        }),
-        Qd = md$3(Pd),
-        Rd = A({}, nd, { propertyName: 0, elapsedTime: 0, pseudoElement: 0 }),
-        Sd = md$3(Rd),
-        Td = A({}, vd, {
-          deltaX: function (a) {
-            return "deltaX" in a
-              ? a.deltaX
-              : "wheelDeltaX" in a
-              ? -a.wheelDeltaX
-              : 0;
-          },
-          deltaY: function (a) {
-            return "deltaY" in a
-              ? a.deltaY
-              : "wheelDeltaY" in a
-              ? -a.wheelDeltaY
-              : "wheelDelta" in a
-              ? -a.wheelDelta
-              : 0;
-          },
-          deltaZ: 0,
-          deltaMode: 0,
-        }),
-        Ud = md$3(Td),
-        Vd = [9, 13, 27, 32],
-        Wd = ha && "CompositionEvent" in window,
-        Xd = null;
-      ha && "documentMode" in document && (Xd = document.documentMode);
-      var Yd = ha && "TextEvent" in window && !Xd,
-        Zd = ha && (!Wd || (Xd && 8 < Xd && 11 >= Xd)),
-        $d = String.fromCharCode(32),
-        ae = false;
-      function be(a, b) {
-        switch (a) {
-          case "keyup":
-            return Vd.indexOf(b.keyCode) !== -1;
-          case "keydown":
-            return b.keyCode !== 229;
-          case "keypress":
-          case "mousedown":
-          case "focusout":
-            return true;
-          default:
-            return false;
-        }
-      }
-      function ce(a) {
-        a = a.detail;
-        return typeof a === "object" && "data" in a ? a.data : null;
-      }
-      var de = false;
-      function ee$1(a, b) {
-        switch (a) {
-          case "compositionend":
-            return ce(b);
-          case "keypress":
-            if (b.which !== 32) return null;
-            ae = true;
-            return $d;
-          case "textInput":
-            return (a = b.data), a === $d && ae ? null : a;
-          default:
-            return null;
-        }
-      }
-      function fe(a, b) {
-        if (de)
-          return a === "compositionend" || (!Wd && be(a, b))
-            ? ((a = id()), (hd = gd = fd = null), (de = false), a)
-            : null;
-        switch (a) {
-          case "paste":
-            return null;
-          case "keypress":
-            if (
-              !(b.ctrlKey || b.altKey || b.metaKey) ||
-              (b.ctrlKey && b.altKey)
-            ) {
-              if (b.char && 1 < b.char.length) return b.char;
-              if (b.which) return String.fromCharCode(b.which);
-            }
-            return null;
-          case "compositionend":
-            return Zd && b.locale !== "ko" ? null : b.data;
-          default:
-            return null;
-        }
-      }
-      var ge$1 = {
-        color: true,
-        date: true,
-        datetime: true,
-        "datetime-local": true,
-        email: true,
-        month: true,
-        number: true,
-        password: true,
-        range: true,
-        search: true,
-        tel: true,
-        text: true,
-        time: true,
-        url: true,
-        week: true,
-      };
-      function he(a) {
-        var b = a && a.nodeName && a.nodeName.toLowerCase();
-        return b === "input" ? !!ge$1[a.type] : b === "textarea" ? true : false;
-      }
-      function ie(a, b, c, d) {
-        Bb(d);
-        b = je(b, "onChange");
-        0 < b.length &&
-          ((c = new od("onChange", "change", null, c, d)),
-          a.push({ event: c, listeners: b }));
-      }
-      var ke = null,
-        le$1 = null;
-      function me(a) {
-        ne$1(a, 0);
-      }
-      function oe(a) {
-        var b = pe(a);
-        if (Ua(b)) return a;
-      }
-      function qe(a, b) {
-        if (a === "change") return b;
-      }
-      var re$1 = false;
-      if (ha) {
-        var se;
-        if (ha) {
-          var te = "oninput" in document;
-          if (!te) {
-            var ue = document.createElement("div");
-            ue.setAttribute("oninput", "return;");
-            te = typeof ue.oninput === "function";
-          }
-          se = te;
-        } else se = false;
-        re$1 = se && (!document.documentMode || 9 < document.documentMode);
-      }
-      function ve() {
-        ke && (ke.detachEvent("onpropertychange", we), (le$1 = ke = null));
-      }
-      function we(a) {
-        if (a.propertyName === "value" && oe(le$1)) {
-          var b = [];
-          ie(b, le$1, a, ub(a));
-          Gb(me, b);
-        }
-      }
-      function xe(a, b, c) {
-        a === "focusin"
-          ? (ve(), (ke = b), (le$1 = c), ke.attachEvent("onpropertychange", we))
-          : a === "focusout" && ve();
-      }
-      function ye(a) {
-        if (a === "selectionchange" || a === "keyup" || a === "keydown")
-          return oe(le$1);
-      }
-      function ze(a, b) {
-        if (a === "click") return oe(b);
-      }
-      function Ae(a, b) {
-        if (a === "input" || a === "change") return oe(b);
-      }
-      function Be(a, b) {
-        return (
-          (a === b && (a !== 0 || 1 / a === 1 / b)) || (a !== a && b !== b)
-        );
-      }
-      var Ce = typeof Object.is === "function" ? Object.is : Be;
-      function De(a, b) {
-        if (Ce(a, b)) return true;
-        if (
-          typeof a !== "object" ||
-          a === null ||
-          typeof b !== "object" ||
-          b === null
-        )
-          return false;
-        var c = Object.keys(a),
-          d = Object.keys(b);
-        if (c.length !== d.length) return false;
-        for (d = 0; d < c.length; d++) {
-          var e = c[d];
-          if (!ia.call(b, e) || !Ce(a[e], b[e])) return false;
-        }
-        return true;
-      }
-      function Ee(a) {
-        for (; a && a.firstChild; ) a = a.firstChild;
-        return a;
-      }
-      function Fe(a, b) {
-        var c = Ee(a);
-        a = 0;
-        for (var d; c; ) {
-          if (c.nodeType === 3) {
-            d = a + c.textContent.length;
-            if (a <= b && d >= b) return { node: c, offset: b - a };
-            a = d;
-          }
-          a: {
-            for (; c; ) {
-              if (c.nextSibling) {
-                c = c.nextSibling;
-                break a;
-              }
-              c = c.parentNode;
-            }
-            c = void 0;
-          }
-          c = Ee(c);
-        }
-      }
-      function Ge(a, b) {
-        return a && b
-          ? a === b
-            ? true
-            : a && a.nodeType === 3
-            ? false
-            : b && b.nodeType === 3
-            ? Ge(a, b.parentNode)
-            : "contains" in a
-            ? a.contains(b)
-            : a.compareDocumentPosition
-            ? !!(a.compareDocumentPosition(b) & 16)
-            : false
-          : false;
-      }
-      function He() {
-        for (var a = window, b = Va(); b instanceof a.HTMLIFrameElement; ) {
-          try {
-            var c = typeof b.contentWindow.location.href === "string";
-          } catch (d) {
-            c = false;
-          }
-          if (c) a = b.contentWindow;
-          else break;
-          b = Va(a.document);
-        }
-        return b;
-      }
-      function Ie(a) {
-        var b = a && a.nodeName && a.nodeName.toLowerCase();
-        return (
-          b &&
-          ((b === "input" &&
-            (a.type === "text" ||
-              a.type === "search" ||
-              a.type === "tel" ||
-              a.type === "url" ||
-              a.type === "password")) ||
-            b === "textarea" ||
-            a.contentEditable === "true")
-        );
-      }
-      function Je(a) {
-        var b = He(),
-          c = a.focusedElem,
-          d = a.selectionRange;
-        if (
-          b !== c &&
-          c &&
-          c.ownerDocument &&
-          Ge(c.ownerDocument.documentElement, c)
-        ) {
-          if (d !== null && Ie(c)) {
-            if (
-              ((b = d.start),
-              (a = d.end),
-              a === void 0 && (a = b),
-              "selectionStart" in c)
-            )
-              (c.selectionStart = b),
-                (c.selectionEnd = Math.min(a, c.value.length));
-            else if (
-              ((a =
-                ((b = c.ownerDocument || document) && b.defaultView) || window),
-              a.getSelection)
-            ) {
-              a = a.getSelection();
-              var e = c.textContent.length,
-                f = Math.min(d.start, e);
-              d = d.end === void 0 ? f : Math.min(d.end, e);
-              !a.extend && f > d && ((e = d), (d = f), (f = e));
-              e = Fe(c, f);
-              var g = Fe(c, d);
-              e &&
-                g &&
-                (a.rangeCount !== 1 ||
-                  a.anchorNode !== e.node ||
-                  a.anchorOffset !== e.offset ||
-                  a.focusNode !== g.node ||
-                  a.focusOffset !== g.offset) &&
-                ((b = b.createRange()),
-                b.setStart(e.node, e.offset),
-                a.removeAllRanges(),
-                f > d
-                  ? (a.addRange(b), a.extend(g.node, g.offset))
-                  : (b.setEnd(g.node, g.offset), a.addRange(b)));
-            }
-          }
-          b = [];
-          for (a = c; (a = a.parentNode); )
-            a.nodeType === 1 &&
-              b.push({ element: a, left: a.scrollLeft, top: a.scrollTop });
-          typeof c.focus === "function" && c.focus();
-          for (c = 0; c < b.length; c++)
-            (a = b[c]),
-              (a.element.scrollLeft = a.left),
-              (a.element.scrollTop = a.top);
-        }
-      }
-      var Ke = ha && "documentMode" in document && 11 >= document.documentMode,
-        Le = null,
-        Me = null,
-        Ne = null,
-        Oe = false;
-      function Pe(a, b, c) {
-        var d =
-          c.window === c ? c.document : c.nodeType === 9 ? c : c.ownerDocument;
-        Oe ||
-          Le == null ||
-          Le !== Va(d) ||
-          ((d = Le),
-          "selectionStart" in d && Ie(d)
-            ? (d = { start: d.selectionStart, end: d.selectionEnd })
-            : ((d = (
-                (d.ownerDocument && d.ownerDocument.defaultView) ||
-                window
-              ).getSelection()),
-              (d = {
-                anchorNode: d.anchorNode,
-                anchorOffset: d.anchorOffset,
-                focusNode: d.focusNode,
-                focusOffset: d.focusOffset,
-              })),
-          (Ne && De(Ne, d)) ||
-            ((Ne = d),
-            (d = je(Me, "onSelect")),
-            0 < d.length &&
-              ((b = new od("onSelect", "select", null, b, c)),
-              a.push({ event: b, listeners: d }),
-              (b.target = Le))));
-      }
-      function Qe(a, b) {
-        var c = {};
-        c[a.toLowerCase()] = b.toLowerCase();
-        c["Webkit" + a] = "webkit" + b;
-        c["Moz" + a] = "moz" + b;
-        return c;
-      }
-      var Re$1 = {
-          animationend: Qe("Animation", "AnimationEnd"),
-          animationiteration: Qe("Animation", "AnimationIteration"),
-          animationstart: Qe("Animation", "AnimationStart"),
-          transitionend: Qe("Transition", "TransitionEnd"),
-        },
-        Se = {},
-        Te = {};
-      ha &&
-        ((Te = document.createElement("div").style),
-        "AnimationEvent" in window ||
-          (delete Re$1.animationend.animation,
-          delete Re$1.animationiteration.animation,
-          delete Re$1.animationstart.animation),
-        "TransitionEvent" in window || delete Re$1.transitionend.transition);
-      function Ue(a) {
-        if (Se[a]) return Se[a];
-        if (!Re$1[a]) return a;
-        var b = Re$1[a],
-          c;
-        for (c in b) if (b.hasOwnProperty(c) && c in Te) return (Se[a] = b[c]);
-        return a;
-      }
-      var Ve = Ue("animationend"),
-        We = Ue("animationiteration"),
-        Xe = Ue("animationstart"),
-        Ye = Ue("transitionend"),
-        Ze = /* @__PURE__ */ new Map(),
-        $e =
-          "abort auxClick cancel canPlay canPlayThrough click close contextMenu copy cut drag dragEnd dragEnter dragExit dragLeave dragOver dragStart drop durationChange emptied encrypted ended error gotPointerCapture input invalid keyDown keyPress keyUp load loadedData loadedMetadata loadStart lostPointerCapture mouseDown mouseMove mouseOut mouseOver mouseUp paste pause play playing pointerCancel pointerDown pointerMove pointerOut pointerOver pointerUp progress rateChange reset resize seeked seeking stalled submit suspend timeUpdate touchCancel touchEnd touchStart volumeChange scroll toggle touchMove waiting wheel".split(
-            " "
-          );
-      function af$1(a, b) {
-        Ze.set(a, b);
-        ea(b, [a]);
-      }
-      for (var bf = 0; bf < $e.length; bf++) {
-        var cf = $e[bf],
-          df = cf.toLowerCase(),
-          ef = cf[0].toUpperCase() + cf.slice(1);
-        af$1(df, "on" + ef);
-      }
-      af$1(Ve, "onAnimationEnd");
-      af$1(We, "onAnimationIteration");
-      af$1(Xe, "onAnimationStart");
-      af$1("dblclick", "onDoubleClick");
-      af$1("focusin", "onFocus");
-      af$1("focusout", "onBlur");
-      af$1(Ye, "onTransitionEnd");
-      fa("onMouseEnter", ["mouseout", "mouseover"]);
-      fa("onMouseLeave", ["mouseout", "mouseover"]);
-      fa("onPointerEnter", ["pointerout", "pointerover"]);
-      fa("onPointerLeave", ["pointerout", "pointerover"]);
-      ea(
-        "onChange",
-        "change click focusin focusout input keydown keyup selectionchange".split(
-          " "
-        )
-      );
-      ea(
-        "onSelect",
-        "focusout contextmenu dragend focusin keydown keyup mousedown mouseup selectionchange".split(
-          " "
-        )
-      );
-      ea("onBeforeInput", ["compositionend", "keypress", "textInput", "paste"]);
-      ea(
-        "onCompositionEnd",
-        "compositionend focusout keydown keypress keyup mousedown".split(" ")
-      );
-      ea(
-        "onCompositionStart",
-        "compositionstart focusout keydown keypress keyup mousedown".split(" ")
-      );
-      ea(
-        "onCompositionUpdate",
-        "compositionupdate focusout keydown keypress keyup mousedown".split(" ")
-      );
-      var ff =
-          "abort canplay canplaythrough durationchange emptied encrypted ended error loadeddata loadedmetadata loadstart pause play playing progress ratechange resize seeked seeking stalled suspend timeupdate volumechange waiting".split(
-            " "
-          ),
-        gf = new Set(
-          "cancel close invalid load scroll toggle".split(" ").concat(ff)
-        );
-      function hf(a, b, c) {
-        var d = a.type || "unknown-event";
-        a.currentTarget = c;
-        Rb(d, b, void 0, a);
-        a.currentTarget = null;
-      }
-      function ne$1(a, b) {
-        b = (b & 4) !== 0;
-        for (var c = 0; c < a.length; c++) {
-          var d = a[c],
-            e = d.event;
-          d = d.listeners;
-          a: {
-            var f = void 0;
-            if (b)
-              for (var g = d.length - 1; 0 <= g; g--) {
-                var h = d[g],
-                  k = h.instance,
-                  l2 = h.currentTarget;
-                h = h.listener;
-                if (k !== f && e.isPropagationStopped()) break a;
-                hf(e, h, l2);
-                f = k;
-              }
-            else
-              for (g = 0; g < d.length; g++) {
-                h = d[g];
-                k = h.instance;
-                l2 = h.currentTarget;
-                h = h.listener;
-                if (k !== f && e.isPropagationStopped()) break a;
-                hf(e, h, l2);
-                f = k;
-              }
-          }
-        }
-        if (Nb) throw ((a = Ob), (Nb = false), (Ob = null), a);
-      }
-      function F(a, b) {
-        var c = b[jf];
-        c === void 0 && (c = b[jf] = /* @__PURE__ */ new Set());
-        var d = a + "__bubble";
-        c.has(d) || (kf(b, a, 2, false), c.add(d));
-      }
-      function lf(a, b, c) {
-        var d = 0;
-        b && (d |= 4);
-        kf(c, a, d, b);
-      }
-      var mf = "_reactListening" + Math.random().toString(36).slice(2);
-      function nf(a) {
-        if (!a[mf]) {
-          a[mf] = true;
-          ca.forEach(function (b2) {
-            b2 !== "selectionchange" &&
-              (gf.has(b2) || lf(b2, false, a), lf(b2, true, a));
-          });
-          var b = a.nodeType === 9 ? a : a.ownerDocument;
-          b === null ||
-            b[mf] ||
-            ((b[mf] = true), lf("selectionchange", false, b));
-        }
-      }
-      function kf(a, b, c, d) {
-        switch (ed(b)) {
-          case 1:
-            var e = $c;
-            break;
-          case 4:
-            e = bd;
-            break;
-          default:
-            e = ad;
-        }
-        c = e.bind(null, b, c, a);
-        e = void 0;
-        !Ib ||
-          (b !== "touchstart" && b !== "touchmove" && b !== "wheel") ||
-          (e = true);
-        d
-          ? e !== void 0
-            ? a.addEventListener(b, c, { capture: true, passive: e })
-            : a.addEventListener(b, c, true)
-          : e !== void 0
-          ? a.addEventListener(b, c, { passive: e })
-          : a.addEventListener(b, c, false);
-      }
-      function cd(a, b, c, d, e) {
-        var f = d;
-        if ((b & 1) === 0 && (b & 2) === 0 && d !== null)
-          a: for (;;) {
-            if (d === null) return;
-            var g = d.tag;
-            if (g === 3 || g === 4) {
-              var h = d.stateNode.containerInfo;
-              if (h === e || (h.nodeType === 8 && h.parentNode === e)) break;
-              if (g === 4)
-                for (g = d.return; g !== null; ) {
-                  var k = g.tag;
-                  if (k === 3 || k === 4) {
-                    if (
-                      ((k = g.stateNode.containerInfo),
-                      k === e || (k.nodeType === 8 && k.parentNode === e))
-                    )
-                      return;
-                  }
-                  g = g.return;
-                }
-              for (; h !== null; ) {
-                g = Sc$1(h);
-                if (g === null) return;
-                k = g.tag;
-                if (k === 5 || k === 6) {
-                  d = f = g;
-                  continue a;
-                }
-                h = h.parentNode;
-              }
-            }
-            d = d.return;
-          }
-        Gb(function () {
-          var d2 = f,
-            e2 = ub(c),
-            g2 = [];
-          a: {
-            var h2 = Ze.get(a);
-            if (h2 !== void 0) {
-              var k2 = od,
-                n2 = a;
-              switch (a) {
-                case "keypress":
-                  if (jd(c) === 0) break a;
-                case "keydown":
-                case "keyup":
-                  k2 = Md;
-                  break;
-                case "focusin":
-                  n2 = "focus";
-                  k2 = Ad;
-                  break;
-                case "focusout":
-                  n2 = "blur";
-                  k2 = Ad;
-                  break;
-                case "beforeblur":
-                case "afterblur":
-                  k2 = Ad;
-                  break;
-                case "click":
-                  if (c.button === 2) break a;
-                case "auxclick":
-                case "dblclick":
-                case "mousedown":
-                case "mousemove":
-                case "mouseup":
-                case "mouseout":
-                case "mouseover":
-                case "contextmenu":
-                  k2 = wd;
-                  break;
-                case "drag":
-                case "dragend":
-                case "dragenter":
-                case "dragexit":
-                case "dragleave":
-                case "dragover":
-                case "dragstart":
-                case "drop":
-                  k2 = yd;
-                  break;
-                case "touchcancel":
-                case "touchend":
-                case "touchmove":
-                case "touchstart":
-                  k2 = Qd;
-                  break;
-                case Ve:
-                case We:
-                case Xe:
-                  k2 = Cd;
-                  break;
-                case Ye:
-                  k2 = Sd;
-                  break;
-                case "scroll":
-                  k2 = qd;
-                  break;
-                case "wheel":
-                  k2 = Ud;
-                  break;
-                case "copy":
-                case "cut":
-                case "paste":
-                  k2 = Ed;
-                  break;
-                case "gotpointercapture":
-                case "lostpointercapture":
-                case "pointercancel":
-                case "pointerdown":
-                case "pointermove":
-                case "pointerout":
-                case "pointerover":
-                case "pointerup":
-                  k2 = Od;
-              }
-              var v2 = (b & 4) !== 0,
-                C2 = !v2 && a === "scroll",
-                t2 = v2 ? (h2 !== null ? h2 + "Capture" : null) : h2;
-              v2 = [];
-              for (var r2 = d2, x2; r2 !== null; ) {
-                x2 = r2;
-                var B2 = x2.stateNode;
-                x2.tag === 5 &&
-                  B2 !== null &&
-                  ((x2 = B2),
-                  t2 !== null &&
-                    ((B2 = Hb(r2, t2)), B2 != null && v2.push(of(r2, B2, x2))));
-                if (C2) break;
-                r2 = r2.return;
-              }
-              0 < v2.length &&
-                ((h2 = new k2(h2, n2, null, c, e2)),
-                g2.push({ event: h2, listeners: v2 }));
-            }
-          }
-          if ((b & 7) === 0) {
-            a: {
-              h2 = a === "mouseover" || a === "pointerover";
-              k2 = a === "mouseout" || a === "pointerout";
-              if (
-                h2 &&
-                c !== tb &&
-                (n2 = c.relatedTarget || c.fromElement) &&
-                (Sc$1(n2) || n2[pf])
-              )
-                break a;
-              if (k2 || h2) {
-                h2 =
-                  e2.window === e2
-                    ? e2
-                    : (h2 = e2.ownerDocument)
-                    ? h2.defaultView || h2.parentWindow
-                    : window;
-                if (k2) {
-                  if (
-                    ((n2 = c.relatedTarget || c.toElement),
-                    (k2 = d2),
-                    (n2 = n2 ? Sc$1(n2) : null),
-                    n2 !== null &&
-                      ((C2 = Sb(n2)),
-                      n2 !== C2 || (n2.tag !== 5 && n2.tag !== 6)))
-                  )
-                    n2 = null;
-                } else (k2 = null), (n2 = d2);
-                if (k2 !== n2) {
-                  v2 = wd;
-                  B2 = "onMouseLeave";
-                  t2 = "onMouseEnter";
-                  r2 = "mouse";
-                  if (a === "pointerout" || a === "pointerover")
-                    (v2 = Od),
-                      (B2 = "onPointerLeave"),
-                      (t2 = "onPointerEnter"),
-                      (r2 = "pointer");
-                  C2 = k2 == null ? h2 : pe(k2);
-                  x2 = n2 == null ? h2 : pe(n2);
-                  h2 = new v2(B2, r2 + "leave", k2, c, e2);
-                  h2.target = C2;
-                  h2.relatedTarget = x2;
-                  B2 = null;
-                  Sc$1(e2) === d2 &&
-                    ((v2 = new v2(t2, r2 + "enter", n2, c, e2)),
-                    (v2.target = x2),
-                    (v2.relatedTarget = C2),
-                    (B2 = v2));
-                  C2 = B2;
-                  if (k2 && n2)
-                    b: {
-                      v2 = k2;
-                      t2 = n2;
-                      r2 = 0;
-                      for (x2 = v2; x2; x2 = qf(x2)) r2++;
-                      x2 = 0;
-                      for (B2 = t2; B2; B2 = qf(B2)) x2++;
-                      for (; 0 < r2 - x2; ) (v2 = qf(v2)), r2--;
-                      for (; 0 < x2 - r2; ) (t2 = qf(t2)), x2--;
-                      for (; r2--; ) {
-                        if (v2 === t2 || (t2 !== null && v2 === t2.alternate))
-                          break b;
-                        v2 = qf(v2);
-                        t2 = qf(t2);
-                      }
-                      v2 = null;
-                    }
-                  else v2 = null;
-                  k2 !== null && rf(g2, h2, k2, v2, false);
-                  n2 !== null && C2 !== null && rf(g2, C2, n2, v2, true);
-                }
-              }
-            }
-            a: {
-              h2 = d2 ? pe(d2) : window;
-              k2 = h2.nodeName && h2.nodeName.toLowerCase();
-              if (k2 === "select" || (k2 === "input" && h2.type === "file"))
-                var O2 = qe;
-              else if (he(h2))
-                if (re$1) O2 = Ae;
-                else {
-                  O2 = ye;
-                  var T2 = xe;
-                }
-              else
-                (k2 = h2.nodeName) &&
-                  k2.toLowerCase() === "input" &&
-                  (h2.type === "checkbox" || h2.type === "radio") &&
-                  (O2 = ze);
-              if (O2 && (O2 = O2(a, d2))) {
-                ie(g2, O2, c, e2);
-                break a;
-              }
-              T2 && T2(a, h2, d2);
-              a === "focusout" &&
-                (T2 = h2._wrapperState) &&
-                T2.controlled &&
-                h2.type === "number" &&
-                $a(h2, "number", h2.value);
-            }
-            T2 = d2 ? pe(d2) : window;
-            switch (a) {
-              case "focusin":
-                if (he(T2) || T2.contentEditable === "true")
-                  (Le = T2), (Me = d2), (Ne = null);
-                break;
-              case "focusout":
-                Ne = Me = Le = null;
-                break;
-              case "mousedown":
-                Oe = true;
-                break;
-              case "contextmenu":
-              case "mouseup":
-              case "dragend":
-                Oe = false;
-                Pe(g2, c, e2);
-                break;
-              case "selectionchange":
-                if (Ke) break;
-              case "keydown":
-              case "keyup":
-                Pe(g2, c, e2);
-            }
-            var za;
-            if (Wd)
-              b: {
-                switch (a) {
-                  case "compositionstart":
-                    var L2 = "onCompositionStart";
-                    break b;
-                  case "compositionend":
-                    L2 = "onCompositionEnd";
-                    break b;
-                  case "compositionupdate":
-                    L2 = "onCompositionUpdate";
-                    break b;
-                }
-                L2 = void 0;
-              }
-            else
-              de
-                ? be(a, c) && (L2 = "onCompositionEnd")
-                : a === "keydown" &&
-                  c.keyCode === 229 &&
-                  (L2 = "onCompositionStart");
-            L2 &&
-              (Zd &&
-                c.locale !== "ko" &&
-                (de || L2 !== "onCompositionStart"
-                  ? L2 === "onCompositionEnd" && de && (za = id())
-                  : ((fd = e2),
-                    (gd = "value" in fd ? fd.value : fd.textContent),
-                    (de = true))),
-              (T2 = je(d2, L2)),
-              0 < T2.length &&
-                ((L2 = new Gd(L2, a, null, c, e2)),
-                g2.push({ event: L2, listeners: T2 }),
-                za
-                  ? (L2.data = za)
-                  : ((za = ce(c)), za !== null && (L2.data = za))));
-            if ((za = Yd ? ee$1(a, c) : fe(a, c)))
-              (d2 = je(d2, "onBeforeInput")),
-                0 < d2.length &&
-                  ((e2 = new Gd("onBeforeInput", "beforeinput", null, c, e2)),
-                  g2.push({ event: e2, listeners: d2 }),
-                  (e2.data = za));
-          }
-          ne$1(g2, b);
-        });
-      }
-      function of(a, b, c) {
-        return { instance: a, listener: b, currentTarget: c };
-      }
-      function je(a, b) {
-        for (var c = b + "Capture", d = []; a !== null; ) {
-          var e = a,
-            f = e.stateNode;
-          e.tag === 5 &&
-            f !== null &&
-            ((e = f),
-            (f = Hb(a, c)),
-            f != null && d.unshift(of(a, f, e)),
-            (f = Hb(a, b)),
-            f != null && d.push(of(a, f, e)));
-          a = a.return;
-        }
-        return d;
-      }
-      function qf(a) {
-        if (a === null) return null;
-        do a = a.return;
-        while (a && a.tag !== 5);
-        return a ? a : null;
-      }
-      function rf(a, b, c, d, e) {
-        for (var f = b._reactName, g = []; c !== null && c !== d; ) {
-          var h = c,
-            k = h.alternate,
-            l2 = h.stateNode;
-          if (k !== null && k === d) break;
-          h.tag === 5 &&
-            l2 !== null &&
-            ((h = l2),
-            e
-              ? ((k = Hb(c, f)), k != null && g.unshift(of(c, k, h)))
-              : e || ((k = Hb(c, f)), k != null && g.push(of(c, k, h))));
-          c = c.return;
-        }
-        g.length !== 0 && a.push({ event: b, listeners: g });
-      }
-      var sf = /\r\n?/g,
-        tf = /\u0000|\uFFFD/g;
-      function uf(a) {
-        return (typeof a === "string" ? a : "" + a)
-          .replace(sf, "\n")
-          .replace(tf, "");
-      }
-      function vf(a, b, c) {
-        b = uf(b);
-        if (uf(a) !== b && c) throw Error(p$1(425));
-      }
-      function wf() {}
-      var xf = null;
-      function yf(a, b) {
-        return (
-          a === "textarea" ||
-          a === "noscript" ||
-          typeof b.children === "string" ||
-          typeof b.children === "number" ||
-          (typeof b.dangerouslySetInnerHTML === "object" &&
-            b.dangerouslySetInnerHTML !== null &&
-            b.dangerouslySetInnerHTML.__html != null)
-        );
-      }
-      var zf = typeof setTimeout === "function" ? setTimeout : void 0,
-        Af = typeof clearTimeout === "function" ? clearTimeout : void 0,
-        Bf = typeof Promise === "function" ? Promise : void 0,
-        Df =
-          typeof queueMicrotask === "function"
-            ? queueMicrotask
-            : typeof Bf !== "undefined"
-            ? function (a) {
-                return Bf.resolve(null).then(a).catch(Cf);
-              }
-            : zf;
-      function Cf(a) {
-        setTimeout(function () {
-          throw a;
-        });
-      }
-      function Ef(a, b) {
-        var c = b,
-          d = 0;
-        do {
-          var e = c.nextSibling;
-          a.removeChild(c);
-          if (e && e.nodeType === 8)
-            if (((c = e.data), c === "/$")) {
-              if (d === 0) {
-                a.removeChild(e);
-                Yc(b);
-                return;
-              }
-              d--;
-            } else (c !== "$" && c !== "$?" && c !== "$!") || d++;
-          c = e;
-        } while (c);
-        Yc(b);
-      }
-      function Ff(a) {
-        for (; a != null; a = a.nextSibling) {
-          var b = a.nodeType;
-          if (b === 1 || b === 3) break;
-          if (b === 8) {
-            b = a.data;
-            if (b === "$" || b === "$!" || b === "$?") break;
-            if (b === "/$") return null;
-          }
-        }
-        return a;
-      }
-      function Gf(a) {
-        a = a.previousSibling;
-        for (var b = 0; a; ) {
-          if (a.nodeType === 8) {
-            var c = a.data;
-            if (c === "$" || c === "$!" || c === "$?") {
-              if (b === 0) return a;
-              b--;
-            } else c === "/$" && b++;
-          }
-          a = a.previousSibling;
-        }
-        return null;
-      }
-      var Hf = Math.random().toString(36).slice(2),
-        If = "__reactFiber$" + Hf,
-        Jf = "__reactProps$" + Hf,
-        pf = "__reactContainer$" + Hf,
-        jf = "__reactEvents$" + Hf,
-        Kf = "__reactListeners$" + Hf,
-        Lf = "__reactHandles$" + Hf;
-      function Sc$1(a) {
-        var b = a[If];
-        if (b) return b;
-        for (var c = a.parentNode; c; ) {
-          if ((b = c[pf] || c[If])) {
-            c = b.alternate;
-            if (b.child !== null || (c !== null && c.child !== null))
-              for (a = Gf(a); a !== null; ) {
-                if ((c = a[If])) return c;
-                a = Gf(a);
-              }
-            return b;
-          }
-          a = c;
-          c = a.parentNode;
-        }
-        return null;
-      }
-      function zb(a) {
-        a = a[If] || a[pf];
-        return !a || (a.tag !== 5 && a.tag !== 6 && a.tag !== 13 && a.tag !== 3)
-          ? null
-          : a;
-      }
-      function pe(a) {
-        if (a.tag === 5 || a.tag === 6) return a.stateNode;
-        throw Error(p$1(33));
-      }
-      function Ab(a) {
-        return a[Jf] || null;
-      }
-      var Mf = [],
-        Nf = -1;
-      function Of(a) {
-        return { current: a };
-      }
-      function G(a) {
-        0 > Nf || ((a.current = Mf[Nf]), (Mf[Nf] = null), Nf--);
-      }
-      function H(a, b) {
-        Nf++;
-        Mf[Nf] = a.current;
-        a.current = b;
-      }
-      var Pf = {},
-        I = Of(Pf),
-        Qf = Of(false),
-        Rf = Pf;
-      function Sf(a, b) {
-        var c = a.type.contextTypes;
-        if (!c) return Pf;
-        var d = a.stateNode;
-        if (d && d.__reactInternalMemoizedUnmaskedChildContext === b)
-          return d.__reactInternalMemoizedMaskedChildContext;
-        var e = {},
-          f;
-        for (f in c) e[f] = b[f];
-        d &&
-          ((a = a.stateNode),
-          (a.__reactInternalMemoizedUnmaskedChildContext = b),
-          (a.__reactInternalMemoizedMaskedChildContext = e));
-        return e;
-      }
-      function Tf(a) {
-        a = a.childContextTypes;
-        return a !== null && a !== void 0;
-      }
-      function Uf() {
-        G(Qf);
-        G(I);
-      }
-      function Vf(a, b, c) {
-        if (I.current !== Pf) throw Error(p$1(168));
-        H(I, b);
-        H(Qf, c);
-      }
-      function Wf(a, b, c) {
-        var d = a.stateNode;
-        b = b.childContextTypes;
-        if (typeof d.getChildContext !== "function") return c;
-        d = d.getChildContext();
-        for (var e in d)
-          if (!(e in b)) throw Error(p$1(108, Pa(a) || "Unknown", e));
-        return A({}, c, d);
-      }
-      function Xf(a) {
-        a =
-          ((a = a.stateNode) && a.__reactInternalMemoizedMergedChildContext) ||
-          Pf;
-        Rf = I.current;
-        H(I, a);
-        H(Qf, Qf.current);
-        return true;
-      }
-      function Yf(a, b, c) {
-        var d = a.stateNode;
-        if (!d) throw Error(p$1(169));
-        c
-          ? ((a = Wf(a, b, Rf)),
-            (d.__reactInternalMemoizedMergedChildContext = a),
-            G(Qf),
-            G(I),
-            H(I, a))
-          : G(Qf);
-        H(Qf, c);
-      }
-      var Zf = null,
-        $f = false,
-        ag = false;
-      function bg(a) {
-        Zf === null ? (Zf = [a]) : Zf.push(a);
-      }
-      function cg(a) {
-        $f = true;
-        bg(a);
-      }
-      function dg() {
-        if (!ag && Zf !== null) {
-          ag = true;
-          var a = 0,
-            b = E;
-          try {
-            var c = Zf;
-            for (E = 1; a < c.length; a++) {
-              var d = c[a];
-              do d = d(true);
-              while (d !== null);
-            }
-            Zf = null;
-            $f = false;
-          } catch (e) {
-            throw (Zf !== null && (Zf = Zf.slice(a + 1)), Yb(cc, dg), e);
-          } finally {
-            (E = b), (ag = false);
-          }
-        }
-        return null;
-      }
-      var eg$1 = sa.ReactCurrentBatchConfig;
-      function fg(a, b) {
-        if (a && a.defaultProps) {
-          b = A({}, b);
-          a = a.defaultProps;
-          for (var c in a) b[c] === void 0 && (b[c] = a[c]);
-          return b;
-        }
-        return b;
-      }
-      var gg$1 = Of(null),
-        hg = null,
-        ig = null,
-        jg = null;
-      function kg() {
-        jg = ig = hg = null;
-      }
-      function lg$1(a) {
-        var b = gg$1.current;
-        G(gg$1);
-        a._currentValue = b;
-      }
-      function mg(a, b, c) {
-        for (; a !== null; ) {
-          var d = a.alternate;
-          (a.childLanes & b) !== b
-            ? ((a.childLanes |= b), d !== null && (d.childLanes |= b))
-            : d !== null && (d.childLanes & b) !== b && (d.childLanes |= b);
-          if (a === c) break;
-          a = a.return;
-        }
-      }
-      function ng(a, b) {
-        hg = a;
-        jg = ig = null;
-        a = a.dependencies;
-        a !== null &&
-          a.firstContext !== null &&
-          ((a.lanes & b) !== 0 && (og = true), (a.firstContext = null));
-      }
-      function pg(a) {
-        var b = a._currentValue;
-        if (jg !== a)
-          if (
-            ((a = { context: a, memoizedValue: b, next: null }), ig === null)
-          ) {
-            if (hg === null) throw Error(p$1(308));
-            ig = a;
-            hg.dependencies = { lanes: 0, firstContext: a };
-          } else ig = ig.next = a;
-        return b;
-      }
-      var qg = null,
-        rg = false;
-      function sg(a) {
-        a.updateQueue = {
-          baseState: a.memoizedState,
-          firstBaseUpdate: null,
-          lastBaseUpdate: null,
-          shared: { pending: null, interleaved: null, lanes: 0 },
-          effects: null,
-        };
-      }
-      function tg(a, b) {
-        a = a.updateQueue;
-        b.updateQueue === a &&
-          (b.updateQueue = {
-            baseState: a.baseState,
-            firstBaseUpdate: a.firstBaseUpdate,
-            lastBaseUpdate: a.lastBaseUpdate,
-            shared: a.shared,
-            effects: a.effects,
-          });
-      }
-      function ug(a, b) {
-        return {
-          eventTime: a,
-          lane: b,
-          tag: 0,
-          payload: null,
-          callback: null,
-          next: null,
-        };
-      }
-      function vg(a, b) {
-        var c = a.updateQueue;
-        c !== null &&
-          ((c = c.shared),
-          J !== null && (a.mode & 1) !== 0 && (K & 2) === 0
-            ? ((a = c.interleaved),
-              a === null
-                ? ((b.next = b), qg === null ? (qg = [c]) : qg.push(c))
-                : ((b.next = a.next), (a.next = b)),
-              (c.interleaved = b))
-            : ((a = c.pending),
-              a === null ? (b.next = b) : ((b.next = a.next), (a.next = b)),
-              (c.pending = b)));
-      }
-      function wg(a, b, c) {
-        b = b.updateQueue;
-        if (b !== null && ((b = b.shared), (c & 4194240) !== 0)) {
-          var d = b.lanes;
-          d &= a.pendingLanes;
-          c |= d;
-          b.lanes = c;
-          yc(a, c);
-        }
-      }
-      function xg(a, b) {
-        var c = a.updateQueue,
-          d = a.alternate;
-        if (d !== null && ((d = d.updateQueue), c === d)) {
-          var e = null,
-            f = null;
-          c = c.firstBaseUpdate;
-          if (c !== null) {
-            do {
-              var g = {
-                eventTime: c.eventTime,
-                lane: c.lane,
-                tag: c.tag,
-                payload: c.payload,
-                callback: c.callback,
-                next: null,
-              };
-              f === null ? (e = f = g) : (f = f.next = g);
-              c = c.next;
-            } while (c !== null);
-            f === null ? (e = f = b) : (f = f.next = b);
-          } else e = f = b;
-          c = {
-            baseState: d.baseState,
-            firstBaseUpdate: e,
-            lastBaseUpdate: f,
-            shared: d.shared,
-            effects: d.effects,
-          };
-          a.updateQueue = c;
-          return;
-        }
-        a = c.lastBaseUpdate;
-        a === null ? (c.firstBaseUpdate = b) : (a.next = b);
-        c.lastBaseUpdate = b;
-      }
-      function yg(a, b, c, d) {
-        var e = a.updateQueue;
-        rg = false;
-        var f = e.firstBaseUpdate,
-          g = e.lastBaseUpdate,
-          h = e.shared.pending;
-        if (h !== null) {
-          e.shared.pending = null;
-          var k = h,
-            l2 = k.next;
-          k.next = null;
-          g === null ? (f = l2) : (g.next = l2);
-          g = k;
-          var m = a.alternate;
-          m !== null &&
-            ((m = m.updateQueue),
-            (h = m.lastBaseUpdate),
-            h !== g &&
-              (h === null ? (m.firstBaseUpdate = l2) : (h.next = l2),
-              (m.lastBaseUpdate = k)));
-        }
-        if (f !== null) {
-          var w2 = e.baseState;
-          g = 0;
-          m = l2 = k = null;
-          h = f;
-          do {
-            var u2 = h.lane,
-              y2 = h.eventTime;
-            if ((d & u2) === u2) {
-              m !== null &&
-                (m = m.next =
-                  {
-                    eventTime: y2,
-                    lane: 0,
-                    tag: h.tag,
-                    payload: h.payload,
-                    callback: h.callback,
-                    next: null,
-                  });
-              a: {
-                var n2 = a,
-                  v2 = h;
-                u2 = b;
-                y2 = c;
-                switch (v2.tag) {
-                  case 1:
-                    n2 = v2.payload;
-                    if (typeof n2 === "function") {
-                      w2 = n2.call(y2, w2, u2);
-                      break a;
-                    }
-                    w2 = n2;
-                    break a;
-                  case 3:
-                    n2.flags = (n2.flags & -65537) | 128;
-                  case 0:
-                    n2 = v2.payload;
-                    u2 = typeof n2 === "function" ? n2.call(y2, w2, u2) : n2;
-                    if (u2 === null || u2 === void 0) break a;
-                    w2 = A({}, w2, u2);
-                    break a;
-                  case 2:
-                    rg = true;
-                }
-              }
-              h.callback !== null &&
-                h.lane !== 0 &&
-                ((a.flags |= 64),
-                (u2 = e.effects),
-                u2 === null ? (e.effects = [h]) : u2.push(h));
-            } else
-              (y2 = {
-                eventTime: y2,
-                lane: u2,
-                tag: h.tag,
-                payload: h.payload,
-                callback: h.callback,
-                next: null,
-              }),
-                m === null ? ((l2 = m = y2), (k = w2)) : (m = m.next = y2),
-                (g |= u2);
-            h = h.next;
-            if (h === null)
-              if (((h = e.shared.pending), h === null)) break;
-              else
-                (u2 = h),
-                  (h = u2.next),
-                  (u2.next = null),
-                  (e.lastBaseUpdate = u2),
-                  (e.shared.pending = null);
-          } while (1);
-          m === null && (k = w2);
-          e.baseState = k;
-          e.firstBaseUpdate = l2;
-          e.lastBaseUpdate = m;
-          b = e.shared.interleaved;
-          if (b !== null) {
-            e = b;
-            do (g |= e.lane), (e = e.next);
-            while (e !== b);
-          } else f === null && (e.shared.lanes = 0);
-          zg |= g;
-          a.lanes = g;
-          a.memoizedState = w2;
-        }
-      }
-      function Ag(a, b, c) {
-        a = b.effects;
-        b.effects = null;
-        if (a !== null)
-          for (b = 0; b < a.length; b++) {
-            var d = a[b],
-              e = d.callback;
-            if (e !== null) {
-              d.callback = null;
-              d = c;
-              if (typeof e !== "function") throw Error(p$1(191, e));
-              e.call(d);
-            }
-          }
-      }
-      var Bg = new aa.Component().refs;
-      function Cg(a, b, c, d) {
-        b = a.memoizedState;
-        c = c(d, b);
-        c = c === null || c === void 0 ? b : A({}, b, c);
-        a.memoizedState = c;
-        a.lanes === 0 && (a.updateQueue.baseState = c);
-      }
-      var Fg = {
-        isMounted: function (a) {
-          return (a = a._reactInternals) ? Sb(a) === a : false;
-        },
-        enqueueSetState: function (a, b, c) {
-          a = a._reactInternals;
-          var d = M(),
-            e = Dg(a),
-            f = ug(d, e);
-          f.payload = b;
-          c !== void 0 && c !== null && (f.callback = c);
-          vg(a, f);
-          b = Eg(a, e, d);
-          b !== null && wg(b, a, e);
-        },
-        enqueueReplaceState: function (a, b, c) {
-          a = a._reactInternals;
-          var d = M(),
-            e = Dg(a),
-            f = ug(d, e);
-          f.tag = 1;
-          f.payload = b;
-          c !== void 0 && c !== null && (f.callback = c);
-          vg(a, f);
-          b = Eg(a, e, d);
-          b !== null && wg(b, a, e);
-        },
-        enqueueForceUpdate: function (a, b) {
-          a = a._reactInternals;
-          var c = M(),
-            d = Dg(a),
-            e = ug(c, d);
-          e.tag = 2;
-          b !== void 0 && b !== null && (e.callback = b);
-          vg(a, e);
-          b = Eg(a, d, c);
-          b !== null && wg(b, a, d);
-        },
-      };
-      function Gg$1(a, b, c, d, e, f, g) {
-        a = a.stateNode;
-        return typeof a.shouldComponentUpdate === "function"
-          ? a.shouldComponentUpdate(d, f, g)
-          : b.prototype && b.prototype.isPureReactComponent
-          ? !De(c, d) || !De(e, f)
-          : true;
-      }
-      function Hg(a, b, c) {
-        var d = false,
-          e = Pf;
-        var f = b.contextType;
-        typeof f === "object" && f !== null
-          ? (f = pg(f))
-          : ((e = Tf(b) ? Rf : I.current),
-            (d = b.contextTypes),
-            (f = (d = d !== null && d !== void 0) ? Sf(a, e) : Pf));
-        b = new b(c, f);
-        a.memoizedState =
-          b.state !== null && b.state !== void 0 ? b.state : null;
-        b.updater = Fg;
-        a.stateNode = b;
-        b._reactInternals = a;
-        d &&
-          ((a = a.stateNode),
-          (a.__reactInternalMemoizedUnmaskedChildContext = e),
-          (a.__reactInternalMemoizedMaskedChildContext = f));
-        return b;
-      }
-      function Ig(a, b, c, d) {
-        a = b.state;
-        typeof b.componentWillReceiveProps === "function" &&
-          b.componentWillReceiveProps(c, d);
-        typeof b.UNSAFE_componentWillReceiveProps === "function" &&
-          b.UNSAFE_componentWillReceiveProps(c, d);
-        b.state !== a && Fg.enqueueReplaceState(b, b.state, null);
-      }
-      function Jg(a, b, c, d) {
-        var e = a.stateNode;
-        e.props = c;
-        e.state = a.memoizedState;
-        e.refs = Bg;
-        sg(a);
-        var f = b.contextType;
-        typeof f === "object" && f !== null
-          ? (e.context = pg(f))
-          : ((f = Tf(b) ? Rf : I.current), (e.context = Sf(a, f)));
-        e.state = a.memoizedState;
-        f = b.getDerivedStateFromProps;
-        typeof f === "function" &&
-          (Cg(a, b, f, c), (e.state = a.memoizedState));
-        typeof b.getDerivedStateFromProps === "function" ||
-          typeof e.getSnapshotBeforeUpdate === "function" ||
-          (typeof e.UNSAFE_componentWillMount !== "function" &&
-            typeof e.componentWillMount !== "function") ||
-          ((b = e.state),
-          typeof e.componentWillMount === "function" && e.componentWillMount(),
-          typeof e.UNSAFE_componentWillMount === "function" &&
-            e.UNSAFE_componentWillMount(),
-          b !== e.state && Fg.enqueueReplaceState(e, e.state, null),
-          yg(a, c, e, d),
-          (e.state = a.memoizedState));
-        typeof e.componentDidMount === "function" && (a.flags |= 4194308);
-      }
-      var Kg = [],
-        Lg = 0,
-        Mg = null,
-        Ng = 0,
-        Og = [],
-        Pg = 0,
-        Qg = null,
-        Rg = 1,
-        Sg = "";
-      function Tg(a, b) {
-        Kg[Lg++] = Ng;
-        Kg[Lg++] = Mg;
-        Mg = a;
-        Ng = b;
-      }
-      function Ug(a, b, c) {
-        Og[Pg++] = Rg;
-        Og[Pg++] = Sg;
-        Og[Pg++] = Qg;
-        Qg = a;
-        var d = Rg;
-        a = Sg;
-        var e = 32 - lc(d) - 1;
-        d &= ~(1 << e);
-        c += 1;
-        var f = 32 - lc(b) + e;
-        if (30 < f) {
-          var g = e - (e % 5);
-          f = (d & ((1 << g) - 1)).toString(32);
-          d >>= g;
-          e -= g;
-          Rg = (1 << (32 - lc(b) + e)) | (c << e) | d;
-          Sg = f + a;
-        } else (Rg = (1 << f) | (c << e) | d), (Sg = a);
-      }
-      function Vg(a) {
-        a.return !== null && (Tg(a, 1), Ug(a, 1, 0));
-      }
-      function Wg(a) {
-        for (; a === Mg; )
-          (Mg = Kg[--Lg]), (Kg[Lg] = null), (Ng = Kg[--Lg]), (Kg[Lg] = null);
-        for (; a === Qg; )
-          (Qg = Og[--Pg]),
-            (Og[Pg] = null),
-            (Sg = Og[--Pg]),
-            (Og[Pg] = null),
-            (Rg = Og[--Pg]),
-            (Og[Pg] = null);
-      }
-      var Xg = null,
-        Yg = null,
-        N = false,
-        Zg = null;
-      function $g(a, b) {
-        var c = ah(5, null, null, 0);
-        c.elementType = "DELETED";
-        c.stateNode = b;
-        c.return = a;
-        b = a.deletions;
-        b === null ? ((a.deletions = [c]), (a.flags |= 16)) : b.push(c);
-      }
-      function bh(a, b) {
-        switch (a.tag) {
-          case 5:
-            var c = a.type;
-            b =
-              b.nodeType !== 1 || c.toLowerCase() !== b.nodeName.toLowerCase()
-                ? null
-                : b;
-            return b !== null
-              ? ((a.stateNode = b), (Xg = a), (Yg = Ff(b.firstChild)), true)
-              : false;
-          case 6:
-            return (
-              (b = a.pendingProps === "" || b.nodeType !== 3 ? null : b),
-              b !== null
-                ? ((a.stateNode = b), (Xg = a), (Yg = null), true)
-                : false
-            );
-          case 13:
-            return (
-              (b = b.nodeType !== 8 ? null : b),
-              b !== null
-                ? ((c = Qg !== null ? { id: Rg, overflow: Sg } : null),
-                  (a.memoizedState = {
-                    dehydrated: b,
-                    treeContext: c,
-                    retryLane: 1073741824,
-                  }),
-                  (c = ah(18, null, null, 0)),
-                  (c.stateNode = b),
-                  (c.return = a),
-                  (a.child = c),
-                  (Xg = a),
-                  (Yg = null),
-                  true)
-                : false
-            );
-          default:
-            return false;
-        }
-      }
-      function ch$1(a) {
-        return (a.mode & 1) !== 0 && (a.flags & 128) === 0;
-      }
-      function dh(a) {
-        if (N) {
-          var b = Yg;
-          if (b) {
-            var c = b;
-            if (!bh(a, b)) {
-              if (ch$1(a)) throw Error(p$1(418));
-              b = Ff(c.nextSibling);
-              var d = Xg;
-              b && bh(a, b)
-                ? $g(d, c)
-                : ((a.flags = (a.flags & -4097) | 2), (N = false), (Xg = a));
-            }
-          } else {
-            if (ch$1(a)) throw Error(p$1(418));
-            a.flags = (a.flags & -4097) | 2;
-            N = false;
-            Xg = a;
-          }
-        }
-      }
-      function eh(a) {
-        for (
-          a = a.return;
-          a !== null && a.tag !== 5 && a.tag !== 3 && a.tag !== 13;
-
-        )
-          a = a.return;
-        Xg = a;
-      }
-      function fh(a) {
-        if (a !== Xg) return false;
-        if (!N) return eh(a), (N = true), false;
-        var b;
-        (b = a.tag !== 3) &&
-          !(b = a.tag !== 5) &&
-          ((b = a.type),
-          (b = b !== "head" && b !== "body" && !yf(a.type, a.memoizedProps)));
-        if (b && (b = Yg)) {
-          if (ch$1(a)) {
-            for (a = Yg; a; ) a = Ff(a.nextSibling);
-            throw Error(p$1(418));
-          }
-          for (; b; ) $g(a, b), (b = Ff(b.nextSibling));
-        }
-        eh(a);
-        if (a.tag === 13) {
-          a = a.memoizedState;
-          a = a !== null ? a.dehydrated : null;
-          if (!a) throw Error(p$1(317));
-          a: {
-            a = a.nextSibling;
-            for (b = 0; a; ) {
-              if (a.nodeType === 8) {
-                var c = a.data;
-                if (c === "/$") {
-                  if (b === 0) {
-                    Yg = Ff(a.nextSibling);
-                    break a;
-                  }
-                  b--;
-                } else (c !== "$" && c !== "$!" && c !== "$?") || b++;
-              }
-              a = a.nextSibling;
-            }
-            Yg = null;
-          }
-        } else Yg = Xg ? Ff(a.stateNode.nextSibling) : null;
-        return true;
-      }
-      function gh() {
-        Yg = Xg = null;
-        N = false;
-      }
-      function hh(a) {
-        Zg === null ? (Zg = [a]) : Zg.push(a);
-      }
-      function ih(a, b, c) {
-        a = c.ref;
-        if (a !== null && typeof a !== "function" && typeof a !== "object") {
-          if (c._owner) {
-            c = c._owner;
-            if (c) {
-              if (c.tag !== 1) throw Error(p$1(309));
-              var d = c.stateNode;
-            }
-            if (!d) throw Error(p$1(147, a));
-            var e = d,
-              f = "" + a;
-            if (
-              b !== null &&
-              b.ref !== null &&
-              typeof b.ref === "function" &&
-              b.ref._stringRef === f
-            )
-              return b.ref;
-            b = function (a2) {
-              var b2 = e.refs;
-              b2 === Bg && (b2 = e.refs = {});
-              a2 === null ? delete b2[f] : (b2[f] = a2);
-            };
-            b._stringRef = f;
-            return b;
-          }
-          if (typeof a !== "string") throw Error(p$1(284));
-          if (!c._owner) throw Error(p$1(290, a));
-        }
-        return a;
-      }
-      function jh(a, b) {
-        a = Object.prototype.toString.call(b);
-        throw Error(
-          p$1(
-            31,
-            a === "[object Object]"
-              ? "object with keys {" + Object.keys(b).join(", ") + "}"
-              : a
-          )
-        );
-      }
-      function kh(a) {
-        var b = a._init;
-        return b(a._payload);
-      }
-      function lh(a) {
-        function b(b2, c2) {
-          if (a) {
-            var d2 = b2.deletions;
-            d2 === null
-              ? ((b2.deletions = [c2]), (b2.flags |= 16))
-              : d2.push(c2);
-          }
-        }
-        function c(c2, d2) {
-          if (!a) return null;
-          for (; d2 !== null; ) b(c2, d2), (d2 = d2.sibling);
-          return null;
-        }
-        function d(a2, b2) {
-          for (a2 = /* @__PURE__ */ new Map(); b2 !== null; )
-            b2.key !== null ? a2.set(b2.key, b2) : a2.set(b2.index, b2),
-              (b2 = b2.sibling);
-          return a2;
-        }
-        function e(a2, b2) {
-          a2 = mh(a2, b2);
-          a2.index = 0;
-          a2.sibling = null;
-          return a2;
-        }
-        function f(b2, c2, d2) {
-          b2.index = d2;
-          if (!a) return (b2.flags |= 1048576), c2;
-          d2 = b2.alternate;
-          if (d2 !== null)
-            return (d2 = d2.index), d2 < c2 ? ((b2.flags |= 2), c2) : d2;
-          b2.flags |= 2;
-          return c2;
-        }
-        function g(b2) {
-          a && b2.alternate === null && (b2.flags |= 2);
-          return b2;
-        }
-        function h(a2, b2, c2, d2) {
-          if (b2 === null || b2.tag !== 6)
-            return (b2 = nh(c2, a2.mode, d2)), (b2.return = a2), b2;
-          b2 = e(b2, c2);
-          b2.return = a2;
-          return b2;
-        }
-        function k(a2, b2, c2, d2) {
-          var f2 = c2.type;
-          if (f2 === va) return m(a2, b2, c2.props.children, d2, c2.key);
-          if (
-            b2 !== null &&
-            (b2.elementType === f2 ||
-              (typeof f2 === "object" &&
-                f2 !== null &&
-                f2.$$typeof === Fa &&
-                kh(f2) === b2.type))
-          )
-            return (
-              (d2 = e(b2, c2.props)),
-              (d2.ref = ih(a2, b2, c2)),
-              (d2.return = a2),
-              d2
-            );
-          d2 = oh(c2.type, c2.key, c2.props, null, a2.mode, d2);
-          d2.ref = ih(a2, b2, c2);
-          d2.return = a2;
-          return d2;
-        }
-        function l2(a2, b2, c2, d2) {
-          if (
-            b2 === null ||
-            b2.tag !== 4 ||
-            b2.stateNode.containerInfo !== c2.containerInfo ||
-            b2.stateNode.implementation !== c2.implementation
-          )
-            return (b2 = ph(c2, a2.mode, d2)), (b2.return = a2), b2;
-          b2 = e(b2, c2.children || []);
-          b2.return = a2;
-          return b2;
-        }
-        function m(a2, b2, c2, d2, f2) {
-          if (b2 === null || b2.tag !== 7)
-            return (b2 = qh(c2, a2.mode, d2, f2)), (b2.return = a2), b2;
-          b2 = e(b2, c2);
-          b2.return = a2;
-          return b2;
-        }
-        function w2(a2, b2, c2) {
-          if ((typeof b2 === "string" && b2 !== "") || typeof b2 === "number")
-            return (b2 = nh("" + b2, a2.mode, c2)), (b2.return = a2), b2;
-          if (typeof b2 === "object" && b2 !== null) {
-            switch (b2.$$typeof) {
-              case ta:
-                return (
-                  (c2 = oh(b2.type, b2.key, b2.props, null, a2.mode, c2)),
-                  (c2.ref = ih(a2, null, b2)),
-                  (c2.return = a2),
-                  c2
-                );
-              case ua:
-                return (b2 = ph(b2, a2.mode, c2)), (b2.return = a2), b2;
-              case Fa:
-                var d2 = b2._init;
-                return w2(a2, d2(b2._payload), c2);
-            }
-            if (bb(b2) || Ia(b2))
-              return (b2 = qh(b2, a2.mode, c2, null)), (b2.return = a2), b2;
-            jh(a2, b2);
-          }
-          return null;
-        }
-        function u2(a2, b2, c2, d2) {
-          var e2 = b2 !== null ? b2.key : null;
-          if ((typeof c2 === "string" && c2 !== "") || typeof c2 === "number")
-            return e2 !== null ? null : h(a2, b2, "" + c2, d2);
-          if (typeof c2 === "object" && c2 !== null) {
-            switch (c2.$$typeof) {
-              case ta:
-                return c2.key === e2 ? k(a2, b2, c2, d2) : null;
-              case ua:
-                return c2.key === e2 ? l2(a2, b2, c2, d2) : null;
-              case Fa:
-                return (e2 = c2._init), u2(a2, b2, e2(c2._payload), d2);
-            }
-            if (bb(c2) || Ia(c2))
-              return e2 !== null ? null : m(a2, b2, c2, d2, null);
-            jh(a2, c2);
-          }
-          return null;
-        }
-        function y2(a2, b2, c2, d2, e2) {
-          if ((typeof d2 === "string" && d2 !== "") || typeof d2 === "number")
-            return (a2 = a2.get(c2) || null), h(b2, a2, "" + d2, e2);
-          if (typeof d2 === "object" && d2 !== null) {
-            switch (d2.$$typeof) {
-              case ta:
-                return (
-                  (a2 = a2.get(d2.key === null ? c2 : d2.key) || null),
-                  k(b2, a2, d2, e2)
-                );
-              case ua:
-                return (
-                  (a2 = a2.get(d2.key === null ? c2 : d2.key) || null),
-                  l2(b2, a2, d2, e2)
-                );
-              case Fa:
-                var f2 = d2._init;
-                return y2(a2, b2, c2, f2(d2._payload), e2);
-            }
-            if (bb(d2) || Ia(d2))
-              return (a2 = a2.get(c2) || null), m(b2, a2, d2, e2, null);
-            jh(b2, d2);
-          }
-          return null;
-        }
-        function n2(e2, g2, h2, k2) {
-          for (
-            var l3 = null, n3 = null, m2 = g2, r2 = (g2 = 0), x2 = null;
-            m2 !== null && r2 < h2.length;
-            r2++
-          ) {
-            m2.index > r2 ? ((x2 = m2), (m2 = null)) : (x2 = m2.sibling);
-            var t2 = u2(e2, m2, h2[r2], k2);
-            if (t2 === null) {
-              m2 === null && (m2 = x2);
-              break;
-            }
-            a && m2 && t2.alternate === null && b(e2, m2);
-            g2 = f(t2, g2, r2);
-            n3 === null ? (l3 = t2) : (n3.sibling = t2);
-            n3 = t2;
-            m2 = x2;
-          }
-          if (r2 === h2.length) return c(e2, m2), N && Tg(e2, r2), l3;
-          if (m2 === null) {
-            for (; r2 < h2.length; r2++)
-              (m2 = w2(e2, h2[r2], k2)),
-                m2 !== null &&
-                  ((g2 = f(m2, g2, r2)),
-                  n3 === null ? (l3 = m2) : (n3.sibling = m2),
-                  (n3 = m2));
-            N && Tg(e2, r2);
-            return l3;
-          }
-          for (m2 = d(e2, m2); r2 < h2.length; r2++)
-            (x2 = y2(m2, e2, r2, h2[r2], k2)),
-              x2 !== null &&
-                (a &&
-                  x2.alternate !== null &&
-                  m2.delete(x2.key === null ? r2 : x2.key),
-                (g2 = f(x2, g2, r2)),
-                n3 === null ? (l3 = x2) : (n3.sibling = x2),
-                (n3 = x2));
-          a &&
-            m2.forEach(function (a2) {
-              return b(e2, a2);
-            });
-          N && Tg(e2, r2);
-          return l3;
-        }
-        function v2(e2, g2, h2, k2) {
-          var l3 = Ia(h2);
-          if (typeof l3 !== "function") throw Error(p$1(150));
-          h2 = l3.call(h2);
-          if (h2 == null) throw Error(p$1(151));
-          for (
-            var m2 = (l3 = null),
-              n3 = g2,
-              r2 = (g2 = 0),
-              x2 = null,
-              t2 = h2.next();
-            n3 !== null && !t2.done;
-            r2++, t2 = h2.next()
-          ) {
-            n3.index > r2 ? ((x2 = n3), (n3 = null)) : (x2 = n3.sibling);
-            var v3 = u2(e2, n3, t2.value, k2);
-            if (v3 === null) {
-              n3 === null && (n3 = x2);
-              break;
-            }
-            a && n3 && v3.alternate === null && b(e2, n3);
-            g2 = f(v3, g2, r2);
-            m2 === null ? (l3 = v3) : (m2.sibling = v3);
-            m2 = v3;
-            n3 = x2;
-          }
-          if (t2.done) return c(e2, n3), N && Tg(e2, r2), l3;
-          if (n3 === null) {
-            for (; !t2.done; r2++, t2 = h2.next())
-              (t2 = w2(e2, t2.value, k2)),
-                t2 !== null &&
-                  ((g2 = f(t2, g2, r2)),
-                  m2 === null ? (l3 = t2) : (m2.sibling = t2),
-                  (m2 = t2));
-            N && Tg(e2, r2);
-            return l3;
-          }
-          for (n3 = d(e2, n3); !t2.done; r2++, t2 = h2.next())
-            (t2 = y2(n3, e2, r2, t2.value, k2)),
-              t2 !== null &&
-                (a &&
-                  t2.alternate !== null &&
-                  n3.delete(t2.key === null ? r2 : t2.key),
-                (g2 = f(t2, g2, r2)),
-                m2 === null ? (l3 = t2) : (m2.sibling = t2),
-                (m2 = t2));
-          a &&
-            n3.forEach(function (a2) {
-              return b(e2, a2);
-            });
-          N && Tg(e2, r2);
-          return l3;
-        }
-        function C2(a2, d2, f2, h2) {
-          typeof f2 === "object" &&
-            f2 !== null &&
-            f2.type === va &&
-            f2.key === null &&
-            (f2 = f2.props.children);
-          if (typeof f2 === "object" && f2 !== null) {
-            switch (f2.$$typeof) {
-              case ta:
-                a: {
-                  for (var k2 = f2.key, l3 = d2; l3 !== null; ) {
-                    if (l3.key === k2) {
-                      k2 = f2.type;
-                      if (k2 === va) {
-                        if (l3.tag === 7) {
-                          c(a2, l3.sibling);
-                          d2 = e(l3, f2.props.children);
-                          d2.return = a2;
-                          a2 = d2;
-                          break a;
-                        }
-                      } else if (
-                        l3.elementType === k2 ||
-                        (typeof k2 === "object" &&
-                          k2 !== null &&
-                          k2.$$typeof === Fa &&
-                          kh(k2) === l3.type)
-                      ) {
-                        c(a2, l3.sibling);
-                        d2 = e(l3, f2.props);
-                        d2.ref = ih(a2, l3, f2);
-                        d2.return = a2;
-                        a2 = d2;
-                        break a;
-                      }
-                      c(a2, l3);
-                      break;
-                    } else b(a2, l3);
-                    l3 = l3.sibling;
-                  }
-                  f2.type === va
-                    ? ((d2 = qh(f2.props.children, a2.mode, h2, f2.key)),
-                      (d2.return = a2),
-                      (a2 = d2))
-                    : ((h2 = oh(f2.type, f2.key, f2.props, null, a2.mode, h2)),
-                      (h2.ref = ih(a2, d2, f2)),
-                      (h2.return = a2),
-                      (a2 = h2));
-                }
-                return g(a2);
-              case ua:
-                a: {
-                  for (l3 = f2.key; d2 !== null; ) {
-                    if (d2.key === l3)
-                      if (
-                        d2.tag === 4 &&
-                        d2.stateNode.containerInfo === f2.containerInfo &&
-                        d2.stateNode.implementation === f2.implementation
-                      ) {
-                        c(a2, d2.sibling);
-                        d2 = e(d2, f2.children || []);
-                        d2.return = a2;
-                        a2 = d2;
-                        break a;
-                      } else {
-                        c(a2, d2);
-                        break;
-                      }
-                    else b(a2, d2);
-                    d2 = d2.sibling;
-                  }
-                  d2 = ph(f2, a2.mode, h2);
-                  d2.return = a2;
-                  a2 = d2;
-                }
-                return g(a2);
-              case Fa:
-                return (l3 = f2._init), C2(a2, d2, l3(f2._payload), h2);
-            }
-            if (bb(f2)) return n2(a2, d2, f2, h2);
-            if (Ia(f2)) return v2(a2, d2, f2, h2);
-            jh(a2, f2);
-          }
-          return (typeof f2 === "string" && f2 !== "") || typeof f2 === "number"
-            ? ((f2 = "" + f2),
-              d2 !== null && d2.tag === 6
-                ? (c(a2, d2.sibling),
-                  (d2 = e(d2, f2)),
-                  (d2.return = a2),
-                  (a2 = d2))
-                : (c(a2, d2),
-                  (d2 = nh(f2, a2.mode, h2)),
-                  (d2.return = a2),
-                  (a2 = d2)),
-              g(a2))
-            : c(a2, d2);
-        }
-        return C2;
-      }
-      var rh = lh(true),
-        sh = lh(false),
-        th = {},
-        uh = Of(th),
-        vh = Of(th),
-        wh = Of(th);
-      function xh(a) {
-        if (a === th) throw Error(p$1(174));
-        return a;
-      }
-      function yh(a, b) {
-        H(wh, b);
-        H(vh, a);
-        H(uh, th);
-        a = b.nodeType;
-        switch (a) {
-          case 9:
-          case 11:
-            b = (b = b.documentElement) ? b.namespaceURI : ib(null, "");
-            break;
-          default:
-            (a = a === 8 ? b.parentNode : b),
-              (b = a.namespaceURI || null),
-              (a = a.tagName),
-              (b = ib(b, a));
-        }
-        G(uh);
-        H(uh, b);
-      }
-      function zh() {
-        G(uh);
-        G(vh);
-        G(wh);
-      }
-      function Ah(a) {
-        xh(wh.current);
-        var b = xh(uh.current);
-        var c = ib(b, a.type);
-        b !== c && (H(vh, a), H(uh, c));
-      }
-      function Bh(a) {
-        vh.current === a && (G(uh), G(vh));
-      }
-      var P = Of(0);
-      function Ch(a) {
-        for (var b = a; b !== null; ) {
-          if (b.tag === 13) {
-            var c = b.memoizedState;
-            if (
-              c !== null &&
-              ((c = c.dehydrated),
-              c === null || c.data === "$?" || c.data === "$!")
-            )
-              return b;
-          } else if (b.tag === 19 && b.memoizedProps.revealOrder !== void 0) {
-            if ((b.flags & 128) !== 0) return b;
-          } else if (b.child !== null) {
-            b.child.return = b;
-            b = b.child;
-            continue;
-          }
-          if (b === a) break;
-          for (; b.sibling === null; ) {
-            if (b.return === null || b.return === a) return null;
-            b = b.return;
-          }
-          b.sibling.return = b.return;
-          b = b.sibling;
-        }
-        return null;
-      }
-      var Dh = [];
-      function Eh() {
-        for (var a = 0; a < Dh.length; a++)
-          Dh[a]._workInProgressVersionPrimary = null;
-        Dh.length = 0;
-      }
-      var Fh = sa.ReactCurrentDispatcher,
-        Gh = sa.ReactCurrentBatchConfig,
-        Hh = 0,
-        Q = null,
-        R = null,
-        S = null,
-        Ih = false,
-        Jh = false,
-        Kh = 0,
-        Lh = 0;
-      function U() {
-        throw Error(p$1(321));
-      }
-      function Mh(a, b) {
-        if (b === null) return false;
-        for (var c = 0; c < b.length && c < a.length; c++)
-          if (!Ce(a[c], b[c])) return false;
-        return true;
-      }
-      function Nh(a, b, c, d, e, f) {
-        Hh = f;
-        Q = b;
-        b.memoizedState = null;
-        b.updateQueue = null;
-        b.lanes = 0;
-        Fh.current = a === null || a.memoizedState === null ? Oh : Ph;
-        a = c(d, e);
-        if (Jh) {
-          f = 0;
-          do {
-            Jh = false;
-            Kh = 0;
-            if (25 <= f) throw Error(p$1(301));
-            f += 1;
-            S = R = null;
-            b.updateQueue = null;
-            Fh.current = Qh;
-            a = c(d, e);
-          } while (Jh);
-        }
-        Fh.current = Rh;
-        b = R !== null && R.next !== null;
-        Hh = 0;
-        S = R = Q = null;
-        Ih = false;
-        if (b) throw Error(p$1(300));
-        return a;
-      }
-      function Sh() {
-        var a = Kh !== 0;
-        Kh = 0;
-        return a;
-      }
-      function Th() {
-        var a = {
-          memoizedState: null,
-          baseState: null,
-          baseQueue: null,
-          queue: null,
-          next: null,
-        };
-        S === null ? (Q.memoizedState = S = a) : (S = S.next = a);
-        return S;
-      }
-      function Uh() {
-        if (R === null) {
-          var a = Q.alternate;
-          a = a !== null ? a.memoizedState : null;
-        } else a = R.next;
-        var b = S === null ? Q.memoizedState : S.next;
-        if (b !== null) (S = b), (R = a);
-        else {
-          if (a === null) throw Error(p$1(310));
-          R = a;
-          a = {
-            memoizedState: R.memoizedState,
-            baseState: R.baseState,
-            baseQueue: R.baseQueue,
-            queue: R.queue,
-            next: null,
-          };
-          S === null ? (Q.memoizedState = S = a) : (S = S.next = a);
-        }
-        return S;
-      }
-      function Vh(a, b) {
-        return typeof b === "function" ? b(a) : b;
-      }
-      function Wh(a) {
-        var b = Uh(),
-          c = b.queue;
-        if (c === null) throw Error(p$1(311));
-        c.lastRenderedReducer = a;
-        var d = R,
-          e = d.baseQueue,
-          f = c.pending;
-        if (f !== null) {
-          if (e !== null) {
-            var g = e.next;
-            e.next = f.next;
-            f.next = g;
-          }
-          d.baseQueue = e = f;
-          c.pending = null;
-        }
-        if (e !== null) {
-          f = e.next;
-          d = d.baseState;
-          var h = (g = null),
-            k = null,
-            l2 = f;
-          do {
-            var m = l2.lane;
-            if ((Hh & m) === m)
-              k !== null &&
-                (k = k.next =
-                  {
-                    lane: 0,
-                    action: l2.action,
-                    hasEagerState: l2.hasEagerState,
-                    eagerState: l2.eagerState,
-                    next: null,
-                  }),
-                (d = l2.hasEagerState ? l2.eagerState : a(d, l2.action));
-            else {
-              var w2 = {
-                lane: m,
-                action: l2.action,
-                hasEagerState: l2.hasEagerState,
-                eagerState: l2.eagerState,
-                next: null,
-              };
-              k === null ? ((h = k = w2), (g = d)) : (k = k.next = w2);
-              Q.lanes |= m;
-              zg |= m;
-            }
-            l2 = l2.next;
-          } while (l2 !== null && l2 !== f);
-          k === null ? (g = d) : (k.next = h);
-          Ce(d, b.memoizedState) || (og = true);
-          b.memoizedState = d;
-          b.baseState = g;
-          b.baseQueue = k;
-          c.lastRenderedState = d;
-        }
-        a = c.interleaved;
-        if (a !== null) {
-          e = a;
-          do (f = e.lane), (Q.lanes |= f), (zg |= f), (e = e.next);
-          while (e !== a);
-        } else e === null && (c.lanes = 0);
-        return [b.memoizedState, c.dispatch];
-      }
-      function Xh(a) {
-        var b = Uh(),
-          c = b.queue;
-        if (c === null) throw Error(p$1(311));
-        c.lastRenderedReducer = a;
-        var d = c.dispatch,
-          e = c.pending,
-          f = b.memoizedState;
-        if (e !== null) {
-          c.pending = null;
-          var g = (e = e.next);
-          do (f = a(f, g.action)), (g = g.next);
-          while (g !== e);
-          Ce(f, b.memoizedState) || (og = true);
-          b.memoizedState = f;
-          b.baseQueue === null && (b.baseState = f);
-          c.lastRenderedState = f;
-        }
-        return [f, d];
-      }
-      function Yh() {}
-      function Zh(a, b) {
-        var c = Q,
-          d = Uh(),
-          e = b(),
-          f = !Ce(d.memoizedState, e);
-        f && ((d.memoizedState = e), (og = true));
-        d = d.queue;
-        $h(ai.bind(null, c, d, a), [a]);
-        if (
-          d.getSnapshot !== b ||
-          f ||
-          (S !== null && S.memoizedState.tag & 1)
-        ) {
-          c.flags |= 2048;
-          bi(9, ci.bind(null, c, d, e, b), void 0, null);
-          if (J === null) throw Error(p$1(349));
-          (Hh & 30) !== 0 || di(c, b, e);
-        }
-        return e;
-      }
-      function di(a, b, c) {
-        a.flags |= 16384;
-        a = { getSnapshot: b, value: c };
-        b = Q.updateQueue;
-        b === null
-          ? ((b = { lastEffect: null, stores: null }),
-            (Q.updateQueue = b),
-            (b.stores = [a]))
-          : ((c = b.stores), c === null ? (b.stores = [a]) : c.push(a));
-      }
-      function ci(a, b, c, d) {
-        b.value = c;
-        b.getSnapshot = d;
-        ei(b) && Eg(a, 1, -1);
-      }
-      function ai(a, b, c) {
-        return c(function () {
-          ei(b) && Eg(a, 1, -1);
-        });
-      }
-      function ei(a) {
-        var b = a.getSnapshot;
-        a = a.value;
-        try {
-          var c = b();
-          return !Ce(a, c);
-        } catch (d) {
-          return true;
-        }
-      }
-      function fi(a) {
-        var b = Th();
-        typeof a === "function" && (a = a());
-        b.memoizedState = b.baseState = a;
-        a = {
-          pending: null,
-          interleaved: null,
-          lanes: 0,
-          dispatch: null,
-          lastRenderedReducer: Vh,
-          lastRenderedState: a,
-        };
-        b.queue = a;
-        a = a.dispatch = gi.bind(null, Q, a);
-        return [b.memoizedState, a];
-      }
-      function bi(a, b, c, d) {
-        a = { tag: a, create: b, destroy: c, deps: d, next: null };
-        b = Q.updateQueue;
-        b === null
-          ? ((b = { lastEffect: null, stores: null }),
-            (Q.updateQueue = b),
-            (b.lastEffect = a.next = a))
-          : ((c = b.lastEffect),
-            c === null
-              ? (b.lastEffect = a.next = a)
-              : ((d = c.next), (c.next = a), (a.next = d), (b.lastEffect = a)));
-        return a;
-      }
-      function hi() {
-        return Uh().memoizedState;
-      }
-      function ii$1(a, b, c, d) {
-        var e = Th();
-        Q.flags |= a;
-        e.memoizedState = bi(1 | b, c, void 0, d === void 0 ? null : d);
-      }
-      function ji(a, b, c, d) {
-        var e = Uh();
-        d = d === void 0 ? null : d;
-        var f = void 0;
-        if (R !== null) {
-          var g = R.memoizedState;
-          f = g.destroy;
-          if (d !== null && Mh(d, g.deps)) {
-            e.memoizedState = bi(b, c, f, d);
-            return;
-          }
-        }
-        Q.flags |= a;
-        e.memoizedState = bi(1 | b, c, f, d);
-      }
-      function ki(a, b) {
-        return ii$1(8390656, 8, a, b);
-      }
-      function $h(a, b) {
-        return ji(2048, 8, a, b);
-      }
-      function li(a, b) {
-        return ji(4, 2, a, b);
-      }
-      function mi(a, b) {
-        return ji(4, 4, a, b);
-      }
-      function ni$1(a, b) {
-        if (typeof b === "function")
-          return (
-            (a = a()),
-            b(a),
-            function () {
-              b(null);
-            }
-          );
-        if (b !== null && b !== void 0)
-          return (
-            (a = a()),
-            (b.current = a),
-            function () {
-              b.current = null;
-            }
-          );
-      }
-      function oi(a, b, c) {
-        c = c !== null && c !== void 0 ? c.concat([a]) : null;
-        return ji(4, 4, ni$1.bind(null, b, a), c);
-      }
-      function pi$1() {}
-      function qi(a, b) {
-        var c = Uh();
-        b = b === void 0 ? null : b;
-        var d = c.memoizedState;
-        if (d !== null && b !== null && Mh(b, d[1])) return d[0];
-        c.memoizedState = [a, b];
-        return a;
-      }
-      function ri(a, b) {
-        var c = Uh();
-        b = b === void 0 ? null : b;
-        var d = c.memoizedState;
-        if (d !== null && b !== null && Mh(b, d[1])) return d[0];
-        a = a();
-        c.memoizedState = [a, b];
-        return a;
-      }
-      function si(a, b) {
-        var c = E;
-        E = c !== 0 && 4 > c ? c : 4;
-        a(true);
-        var d = Gh.transition;
-        Gh.transition = {};
-        try {
-          a(false), b();
-        } finally {
-          (E = c), (Gh.transition = d);
-        }
-      }
-      function ti() {
-        return Uh().memoizedState;
-      }
-      function ui(a, b, c) {
-        var d = Dg(a);
-        c = {
-          lane: d,
-          action: c,
-          hasEagerState: false,
-          eagerState: null,
-          next: null,
-        };
-        vi(a)
-          ? wi(b, c)
-          : (xi$1(a, b, c),
-            (c = M()),
-            (a = Eg(a, d, c)),
-            a !== null && yi(a, b, d));
-      }
-      function gi(a, b, c) {
-        var d = Dg(a),
-          e = {
-            lane: d,
-            action: c,
-            hasEagerState: false,
-            eagerState: null,
-            next: null,
-          };
-        if (vi(a)) wi(b, e);
-        else {
-          xi$1(a, b, e);
-          var f = a.alternate;
-          if (
-            a.lanes === 0 &&
-            (f === null || f.lanes === 0) &&
-            ((f = b.lastRenderedReducer), f !== null)
-          )
-            try {
-              var g = b.lastRenderedState,
-                h = f(g, c);
-              e.hasEagerState = true;
-              e.eagerState = h;
-              if (Ce(h, g)) return;
-            } catch (k) {
-            } finally {
-            }
-          c = M();
-          a = Eg(a, d, c);
-          a !== null && yi(a, b, d);
-        }
-      }
-      function vi(a) {
-        var b = a.alternate;
-        return a === Q || (b !== null && b === Q);
-      }
-      function wi(a, b) {
-        Jh = Ih = true;
-        var c = a.pending;
-        c === null ? (b.next = b) : ((b.next = c.next), (c.next = b));
-        a.pending = b;
-      }
-      function xi$1(a, b, c) {
-        J !== null && (a.mode & 1) !== 0 && (K & 2) === 0
-          ? ((a = b.interleaved),
-            a === null
-              ? ((c.next = c), qg === null ? (qg = [b]) : qg.push(b))
-              : ((c.next = a.next), (a.next = c)),
-            (b.interleaved = c))
-          : ((a = b.pending),
-            a === null ? (c.next = c) : ((c.next = a.next), (a.next = c)),
-            (b.pending = c));
-      }
-      function yi(a, b, c) {
-        if ((c & 4194240) !== 0) {
-          var d = b.lanes;
-          d &= a.pendingLanes;
-          c |= d;
-          b.lanes = c;
-          yc(a, c);
-        }
-      }
-      var Rh = {
-          readContext: pg,
-          useCallback: U,
-          useContext: U,
-          useEffect: U,
-          useImperativeHandle: U,
-          useInsertionEffect: U,
-          useLayoutEffect: U,
-          useMemo: U,
-          useReducer: U,
-          useRef: U,
-          useState: U,
-          useDebugValue: U,
-          useDeferredValue: U,
-          useTransition: U,
-          useMutableSource: U,
-          useSyncExternalStore: U,
-          useId: U,
-          unstable_isNewReconciler: false,
-        },
-        Oh = {
-          readContext: pg,
-          useCallback: function (a, b) {
-            Th().memoizedState = [a, b === void 0 ? null : b];
-            return a;
-          },
-          useContext: pg,
-          useEffect: ki,
-          useImperativeHandle: function (a, b, c) {
-            c = c !== null && c !== void 0 ? c.concat([a]) : null;
-            return ii$1(4194308, 4, ni$1.bind(null, b, a), c);
-          },
-          useLayoutEffect: function (a, b) {
-            return ii$1(4194308, 4, a, b);
-          },
-          useInsertionEffect: function (a, b) {
-            return ii$1(4, 2, a, b);
-          },
-          useMemo: function (a, b) {
-            var c = Th();
-            b = b === void 0 ? null : b;
-            a = a();
-            c.memoizedState = [a, b];
-            return a;
-          },
-          useReducer: function (a, b, c) {
-            var d = Th();
-            b = c !== void 0 ? c(b) : b;
-            d.memoizedState = d.baseState = b;
-            a = {
-              pending: null,
-              interleaved: null,
-              lanes: 0,
-              dispatch: null,
-              lastRenderedReducer: a,
-              lastRenderedState: b,
-            };
-            d.queue = a;
-            a = a.dispatch = ui.bind(null, Q, a);
-            return [d.memoizedState, a];
-          },
-          useRef: function (a) {
-            var b = Th();
-            a = { current: a };
-            return (b.memoizedState = a);
-          },
-          useState: fi,
-          useDebugValue: pi$1,
-          useDeferredValue: function (a) {
-            var b = fi(a),
-              c = b[0],
-              d = b[1];
-            ki(
-              function () {
-                var b2 = Gh.transition;
-                Gh.transition = {};
-                try {
-                  d(a);
-                } finally {
-                  Gh.transition = b2;
-                }
-              },
-              [a]
-            );
-            return c;
-          },
-          useTransition: function () {
-            var a = fi(false),
-              b = a[0];
-            a = si.bind(null, a[1]);
-            Th().memoizedState = a;
-            return [b, a];
-          },
-          useMutableSource: function () {},
-          useSyncExternalStore: function (a, b, c) {
-            var d = Q,
-              e = Th();
-            if (N) {
-              if (c === void 0) throw Error(p$1(407));
-              c = c();
-            } else {
-              c = b();
-              if (J === null) throw Error(p$1(349));
-              (Hh & 30) !== 0 || di(d, b, c);
-            }
-            e.memoizedState = c;
-            var f = { value: c, getSnapshot: b };
-            e.queue = f;
-            ki(ai.bind(null, d, f, a), [a]);
-            d.flags |= 2048;
-            bi(9, ci.bind(null, d, f, c, b), void 0, null);
-            return c;
-          },
-          useId: function () {
-            var a = Th(),
-              b = J.identifierPrefix;
-            if (N) {
-              var c = Sg;
-              var d = Rg;
-              c = (d & ~(1 << (32 - lc(d) - 1))).toString(32) + c;
-              b = ":" + b + "R" + c;
-              c = Kh++;
-              0 < c && (b += "H" + c.toString(32));
-              b += ":";
-            } else (c = Lh++), (b = ":" + b + "r" + c.toString(32) + ":");
-            return (a.memoizedState = b);
-          },
-          unstable_isNewReconciler: false,
-        },
-        Ph = {
-          readContext: pg,
-          useCallback: qi,
-          useContext: pg,
-          useEffect: $h,
-          useImperativeHandle: oi,
-          useInsertionEffect: li,
-          useLayoutEffect: mi,
-          useMemo: ri,
-          useReducer: Wh,
-          useRef: hi,
-          useState: function () {
-            return Wh(Vh);
-          },
-          useDebugValue: pi$1,
-          useDeferredValue: function (a) {
-            var b = Wh(Vh),
-              c = b[0],
-              d = b[1];
-            $h(
-              function () {
-                var b2 = Gh.transition;
-                Gh.transition = {};
-                try {
-                  d(a);
-                } finally {
-                  Gh.transition = b2;
-                }
-              },
-              [a]
-            );
-            return c;
-          },
-          useTransition: function () {
-            var a = Wh(Vh)[0],
-              b = Uh().memoizedState;
-            return [a, b];
-          },
-          useMutableSource: Yh,
-          useSyncExternalStore: Zh,
-          useId: ti,
-          unstable_isNewReconciler: false,
-        },
-        Qh = {
-          readContext: pg,
-          useCallback: qi,
-          useContext: pg,
-          useEffect: $h,
-          useImperativeHandle: oi,
-          useInsertionEffect: li,
-          useLayoutEffect: mi,
-          useMemo: ri,
-          useReducer: Xh,
-          useRef: hi,
-          useState: function () {
-            return Xh(Vh);
-          },
-          useDebugValue: pi$1,
-          useDeferredValue: function (a) {
-            var b = Xh(Vh),
-              c = b[0],
-              d = b[1];
-            $h(
-              function () {
-                var b2 = Gh.transition;
-                Gh.transition = {};
-                try {
-                  d(a);
-                } finally {
-                  Gh.transition = b2;
-                }
-              },
-              [a]
-            );
-            return c;
-          },
-          useTransition: function () {
-            var a = Xh(Vh)[0],
-              b = Uh().memoizedState;
-            return [a, b];
-          },
-          useMutableSource: Yh,
-          useSyncExternalStore: Zh,
-          useId: ti,
-          unstable_isNewReconciler: false,
-        };
-      function zi(a, b) {
-        try {
-          var c = "",
-            d = b;
-          do (c += Na(d)), (d = d.return);
-          while (d);
-          var e = c;
-        } catch (f) {
-          e = "\nError generating stack: " + f.message + "\n" + f.stack;
-        }
-        return { value: a, source: b, stack: e };
-      }
-      function Ai(a, b) {
-        try {
-          console.error(b.value);
-        } catch (c) {
-          setTimeout(function () {
-            throw c;
-          });
-        }
-      }
-      var Bi = typeof WeakMap === "function" ? WeakMap : Map;
-      function Ci(a, b, c) {
-        c = ug(-1, c);
-        c.tag = 3;
-        c.payload = { element: null };
-        var d = b.value;
-        c.callback = function () {
-          Di || ((Di = true), (Ei = d));
-          Ai(a, b);
-        };
-        return c;
-      }
-      function Fi(a, b, c) {
-        c = ug(-1, c);
-        c.tag = 3;
-        var d = a.type.getDerivedStateFromError;
-        if (typeof d === "function") {
-          var e = b.value;
-          c.payload = function () {
-            return d(e);
-          };
-          c.callback = function () {
-            Ai(a, b);
-          };
-        }
-        var f = a.stateNode;
-        f !== null &&
-          typeof f.componentDidCatch === "function" &&
-          (c.callback = function () {
-            Ai(a, b);
-            typeof d !== "function" &&
-              (Gi === null
-                ? (Gi = /* @__PURE__ */ new Set([this]))
-                : Gi.add(this));
-            var c2 = b.stack;
-            this.componentDidCatch(b.value, {
-              componentStack: c2 !== null ? c2 : "",
-            });
-          });
-        return c;
-      }
-      function Hi(a, b, c) {
-        var d = a.pingCache;
-        if (d === null) {
-          d = a.pingCache = new Bi();
-          var e = /* @__PURE__ */ new Set();
-          d.set(b, e);
-        } else
-          (e = d.get(b)),
-            e === void 0 && ((e = /* @__PURE__ */ new Set()), d.set(b, e));
-        e.has(c) || (e.add(c), (a = Ii.bind(null, a, b, c)), b.then(a, a));
-      }
-      function Ji(a) {
-        do {
-          var b;
-          if ((b = a.tag === 13))
-            (b = a.memoizedState),
-              (b = b !== null ? (b.dehydrated !== null ? true : false) : true);
-          if (b) return a;
-          a = a.return;
-        } while (a !== null);
-        return null;
-      }
-      function Ki(a, b, c, d, e) {
-        if ((a.mode & 1) === 0)
-          return (
-            a === b
-              ? (a.flags |= 65536)
-              : ((a.flags |= 128),
-                (c.flags |= 131072),
-                (c.flags &= -52805),
-                c.tag === 1 &&
-                  (c.alternate === null
-                    ? (c.tag = 17)
-                    : ((b = ug(-1, 1)), (b.tag = 2), vg(c, b))),
-                (c.lanes |= 1)),
-            a
-          );
-        a.flags |= 65536;
-        a.lanes = e;
-        return a;
-      }
-      var Li, Mi, Ni, Oi;
-      Li = function (a, b) {
-        for (var c = b.child; c !== null; ) {
-          if (c.tag === 5 || c.tag === 6) a.appendChild(c.stateNode);
-          else if (c.tag !== 4 && c.child !== null) {
-            c.child.return = c;
-            c = c.child;
-            continue;
-          }
-          if (c === b) break;
-          for (; c.sibling === null; ) {
-            if (c.return === null || c.return === b) return;
-            c = c.return;
-          }
-          c.sibling.return = c.return;
-          c = c.sibling;
-        }
-      };
-      Mi = function () {};
-      Ni = function (a, b, c, d) {
-        var e = a.memoizedProps;
-        if (e !== d) {
-          a = b.stateNode;
-          xh(uh.current);
-          var f = null;
-          switch (c) {
-            case "input":
-              e = Wa(a, e);
-              d = Wa(a, d);
-              f = [];
-              break;
-            case "select":
-              e = A({}, e, { value: void 0 });
-              d = A({}, d, { value: void 0 });
-              f = [];
-              break;
-            case "textarea":
-              e = db(a, e);
-              d = db(a, d);
-              f = [];
-              break;
-            default:
-              typeof e.onClick !== "function" &&
-                typeof d.onClick === "function" &&
-                (a.onclick = wf);
-          }
-          rb(c, d);
-          var g;
-          c = null;
-          for (l2 in e)
-            if (!d.hasOwnProperty(l2) && e.hasOwnProperty(l2) && e[l2] != null)
-              if (l2 === "style") {
-                var h = e[l2];
-                for (g in h)
-                  h.hasOwnProperty(g) && (c || (c = {}), (c[g] = ""));
-              } else
-                l2 !== "dangerouslySetInnerHTML" &&
-                  l2 !== "children" &&
-                  l2 !== "suppressContentEditableWarning" &&
-                  l2 !== "suppressHydrationWarning" &&
-                  l2 !== "autoFocus" &&
-                  (da.hasOwnProperty(l2)
-                    ? f || (f = [])
-                    : (f = f || []).push(l2, null));
-          for (l2 in d) {
-            var k = d[l2];
-            h = e != null ? e[l2] : void 0;
-            if (d.hasOwnProperty(l2) && k !== h && (k != null || h != null))
-              if (l2 === "style")
-                if (h) {
-                  for (g in h)
-                    !h.hasOwnProperty(g) ||
-                      (k && k.hasOwnProperty(g)) ||
-                      (c || (c = {}), (c[g] = ""));
-                  for (g in k)
-                    k.hasOwnProperty(g) &&
-                      h[g] !== k[g] &&
-                      (c || (c = {}), (c[g] = k[g]));
-                } else c || (f || (f = []), f.push(l2, c)), (c = k);
-              else
-                l2 === "dangerouslySetInnerHTML"
-                  ? ((k = k ? k.__html : void 0),
-                    (h = h ? h.__html : void 0),
-                    k != null && h !== k && (f = f || []).push(l2, k))
-                  : l2 === "children"
-                  ? (typeof k !== "string" && typeof k !== "number") ||
-                    (f = f || []).push(l2, "" + k)
-                  : l2 !== "suppressContentEditableWarning" &&
-                    l2 !== "suppressHydrationWarning" &&
-                    (da.hasOwnProperty(l2)
-                      ? (k != null && l2 === "onScroll" && F("scroll", a),
-                        f || h === k || (f = []))
-                      : (f = f || []).push(l2, k));
-          }
-          c && (f = f || []).push("style", c);
-          var l2 = f;
-          if ((b.updateQueue = l2)) b.flags |= 4;
-        }
-      };
-      Oi = function (a, b, c, d) {
-        c !== d && (b.flags |= 4);
-      };
-      function Pi$1(a, b) {
-        if (!N)
-          switch (a.tailMode) {
-            case "hidden":
-              b = a.tail;
-              for (var c = null; b !== null; )
-                b.alternate !== null && (c = b), (b = b.sibling);
-              c === null ? (a.tail = null) : (c.sibling = null);
-              break;
-            case "collapsed":
-              c = a.tail;
-              for (var d = null; c !== null; )
-                c.alternate !== null && (d = c), (c = c.sibling);
-              d === null
-                ? b || a.tail === null
-                  ? (a.tail = null)
-                  : (a.tail.sibling = null)
-                : (d.sibling = null);
-          }
-      }
-      function V(a) {
-        var b = a.alternate !== null && a.alternate.child === a.child,
-          c = 0,
-          d = 0;
-        if (b)
-          for (var e = a.child; e !== null; )
-            (c |= e.lanes | e.childLanes),
-              (d |= e.subtreeFlags & 14680064),
-              (d |= e.flags & 14680064),
-              (e.return = a),
-              (e = e.sibling);
-        else
-          for (e = a.child; e !== null; )
-            (c |= e.lanes | e.childLanes),
-              (d |= e.subtreeFlags),
-              (d |= e.flags),
-              (e.return = a),
-              (e = e.sibling);
-        a.subtreeFlags |= d;
-        a.childLanes = c;
-        return b;
-      }
-      function Qi(a, b, c) {
-        var d = b.pendingProps;
-        Wg(b);
-        switch (b.tag) {
-          case 2:
-          case 16:
-          case 15:
-          case 0:
-          case 11:
-          case 7:
-          case 8:
-          case 12:
-          case 9:
-          case 14:
-            return V(b), null;
-          case 1:
-            return Tf(b.type) && Uf(), V(b), null;
-          case 3:
-            d = b.stateNode;
-            zh();
-            G(Qf);
-            G(I);
-            Eh();
-            d.pendingContext &&
-              ((d.context = d.pendingContext), (d.pendingContext = null));
-            if (a === null || a.child === null)
-              fh(b)
-                ? (b.flags |= 4)
-                : a === null ||
-                  (a.memoizedState.isDehydrated && (b.flags & 256) === 0) ||
-                  ((b.flags |= 1024), Zg !== null && (Ri(Zg), (Zg = null)));
-            Mi(a, b);
-            V(b);
-            return null;
-          case 5:
-            Bh(b);
-            var e = xh(wh.current);
-            c = b.type;
-            if (a !== null && b.stateNode != null)
-              Ni(a, b, c, d, e),
-                a.ref !== b.ref && ((b.flags |= 512), (b.flags |= 2097152));
-            else {
-              if (!d) {
-                if (b.stateNode === null) throw Error(p$1(166));
-                V(b);
-                return null;
-              }
-              a = xh(uh.current);
-              if (fh(b)) {
-                d = b.stateNode;
-                c = b.type;
-                var f = b.memoizedProps;
-                d[If] = b;
-                d[Jf] = f;
-                a = (b.mode & 1) !== 0;
-                switch (c) {
-                  case "dialog":
-                    F("cancel", d);
-                    F("close", d);
-                    break;
-                  case "iframe":
-                  case "object":
-                  case "embed":
-                    F("load", d);
-                    break;
-                  case "video":
-                  case "audio":
-                    for (e = 0; e < ff.length; e++) F(ff[e], d);
-                    break;
-                  case "source":
-                    F("error", d);
-                    break;
-                  case "img":
-                  case "image":
-                  case "link":
-                    F("error", d);
-                    F("load", d);
-                    break;
-                  case "details":
-                    F("toggle", d);
-                    break;
-                  case "input":
-                    Xa(d, f);
-                    F("invalid", d);
-                    break;
-                  case "select":
-                    d._wrapperState = { wasMultiple: !!f.multiple };
-                    F("invalid", d);
-                    break;
-                  case "textarea":
-                    eb(d, f), F("invalid", d);
-                }
-                rb(c, f);
-                e = null;
-                for (var g in f)
-                  if (f.hasOwnProperty(g)) {
-                    var h = f[g];
-                    g === "children"
-                      ? typeof h === "string"
-                        ? d.textContent !== h &&
-                          (vf(d.textContent, h, a), (e = ["children", h]))
-                        : typeof h === "number" &&
-                          d.textContent !== "" + h &&
-                          (vf(d.textContent, h, a), (e = ["children", "" + h]))
-                      : da.hasOwnProperty(g) &&
-                        h != null &&
-                        g === "onScroll" &&
-                        F("scroll", d);
-                  }
-                switch (c) {
-                  case "input":
-                    Ta(d);
-                    ab(d, f, true);
-                    break;
-                  case "textarea":
-                    Ta(d);
-                    gb(d);
-                    break;
-                  case "select":
-                  case "option":
-                    break;
-                  default:
-                    typeof f.onClick === "function" && (d.onclick = wf);
-                }
-                d = e;
-                b.updateQueue = d;
-                d !== null && (b.flags |= 4);
-              } else {
-                g = e.nodeType === 9 ? e : e.ownerDocument;
-                a === "http://www.w3.org/1999/xhtml" && (a = hb(c));
-                a === "http://www.w3.org/1999/xhtml"
-                  ? c === "script"
-                    ? ((a = g.createElement("div")),
-                      (a.innerHTML = "<script><\/script>"),
-                      (a = a.removeChild(a.firstChild)))
-                    : typeof d.is === "string"
-                    ? (a = g.createElement(c, { is: d.is }))
-                    : ((a = g.createElement(c)),
-                      c === "select" &&
-                        ((g = a),
-                        d.multiple
-                          ? (g.multiple = true)
-                          : d.size && (g.size = d.size)))
-                  : (a = g.createElementNS(a, c));
-                a[If] = b;
-                a[Jf] = d;
-                Li(a, b, false, false);
-                b.stateNode = a;
-                a: {
-                  g = sb(c, d);
-                  switch (c) {
-                    case "dialog":
-                      F("cancel", a);
-                      F("close", a);
-                      e = d;
-                      break;
-                    case "iframe":
-                    case "object":
-                    case "embed":
-                      F("load", a);
-                      e = d;
-                      break;
-                    case "video":
-                    case "audio":
-                      for (e = 0; e < ff.length; e++) F(ff[e], a);
-                      e = d;
-                      break;
-                    case "source":
-                      F("error", a);
-                      e = d;
-                      break;
-                    case "img":
-                    case "image":
-                    case "link":
-                      F("error", a);
-                      F("load", a);
-                      e = d;
-                      break;
-                    case "details":
-                      F("toggle", a);
-                      e = d;
-                      break;
-                    case "input":
-                      Xa(a, d);
-                      e = Wa(a, d);
-                      F("invalid", a);
-                      break;
-                    case "option":
-                      e = d;
-                      break;
-                    case "select":
-                      a._wrapperState = { wasMultiple: !!d.multiple };
-                      e = A({}, d, { value: void 0 });
-                      F("invalid", a);
-                      break;
-                    case "textarea":
-                      eb(a, d);
-                      e = db(a, d);
-                      F("invalid", a);
-                      break;
-                    default:
-                      e = d;
-                  }
-                  rb(c, e);
-                  h = e;
-                  for (f in h)
-                    if (h.hasOwnProperty(f)) {
-                      var k = h[f];
-                      f === "style"
-                        ? pb(a, k)
-                        : f === "dangerouslySetInnerHTML"
-                        ? ((k = k ? k.__html : void 0), k != null && kb(a, k))
-                        : f === "children"
-                        ? typeof k === "string"
-                          ? (c !== "textarea" || k !== "") && lb(a, k)
-                          : typeof k === "number" && lb(a, "" + k)
-                        : f !== "suppressContentEditableWarning" &&
-                          f !== "suppressHydrationWarning" &&
-                          f !== "autoFocus" &&
-                          (da.hasOwnProperty(f)
-                            ? k != null && f === "onScroll" && F("scroll", a)
-                            : k != null && ra(a, f, k, g));
-                    }
-                  switch (c) {
-                    case "input":
-                      Ta(a);
-                      ab(a, d, false);
-                      break;
-                    case "textarea":
-                      Ta(a);
-                      gb(a);
-                      break;
-                    case "option":
-                      d.value != null &&
-                        a.setAttribute("value", "" + Qa(d.value));
-                      break;
-                    case "select":
-                      a.multiple = !!d.multiple;
-                      f = d.value;
-                      f != null
-                        ? cb(a, !!d.multiple, f, false)
-                        : d.defaultValue != null &&
-                          cb(a, !!d.multiple, d.defaultValue, true);
-                      break;
-                    default:
-                      typeof e.onClick === "function" && (a.onclick = wf);
-                  }
-                  switch (c) {
-                    case "button":
-                    case "input":
-                    case "select":
-                    case "textarea":
-                      d = !!d.autoFocus;
-                      break a;
-                    case "img":
-                      d = true;
-                      break a;
-                    default:
-                      d = false;
-                  }
-                }
-                d && (b.flags |= 4);
-              }
-              b.ref !== null && ((b.flags |= 512), (b.flags |= 2097152));
-            }
-            V(b);
-            return null;
-          case 6:
-            if (a && b.stateNode != null) Oi(a, b, a.memoizedProps, d);
-            else {
-              if (typeof d !== "string" && b.stateNode === null)
-                throw Error(p$1(166));
-              c = xh(wh.current);
-              xh(uh.current);
-              if (fh(b)) {
-                d = b.stateNode;
-                c = b.memoizedProps;
-                d[If] = b;
-                if ((f = d.nodeValue !== c)) {
-                  if (((a = Xg), a !== null))
-                    switch (((g = (a.mode & 1) !== 0), a.tag)) {
-                      case 3:
-                        vf(d.nodeValue, c, g);
-                        break;
-                      case 5:
-                        a.memoizedProps[void 0] !== true &&
-                          vf(d.nodeValue, c, g);
-                    }
-                }
-                f && (b.flags |= 4);
-              } else
-                (d = (c.nodeType === 9 ? c : c.ownerDocument).createTextNode(
-                  d
-                )),
-                  (d[If] = b),
-                  (b.stateNode = d);
-            }
-            V(b);
-            return null;
-          case 13:
-            G(P);
-            d = b.memoizedState;
-            if (
-              N &&
-              Yg !== null &&
-              (b.mode & 1) !== 0 &&
-              (b.flags & 128) === 0
-            ) {
-              for (d = Yg; d; ) d = Ff(d.nextSibling);
-              gh();
-              b.flags |= 98560;
-              return b;
-            }
-            if (d !== null && d.dehydrated !== null) {
-              d = fh(b);
-              if (a === null) {
-                if (!d) throw Error(p$1(318));
-                d = b.memoizedState;
-                d = d !== null ? d.dehydrated : null;
-                if (!d) throw Error(p$1(317));
-                d[If] = b;
-              } else
-                gh(),
-                  (b.flags & 128) === 0 && (b.memoizedState = null),
-                  (b.flags |= 4);
-              V(b);
-              return null;
-            }
-            Zg !== null && (Ri(Zg), (Zg = null));
-            if ((b.flags & 128) !== 0) return (b.lanes = c), b;
-            d = d !== null;
-            c = false;
-            a === null ? fh(b) : (c = a.memoizedState !== null);
-            d &&
-              !c &&
-              ((b.child.flags |= 8192),
-              (b.mode & 1) !== 0 &&
-                (a === null || (P.current & 1) !== 0
-                  ? W === 0 && (W = 3)
-                  : Si()));
-            b.updateQueue !== null && (b.flags |= 4);
-            V(b);
-            return null;
-          case 4:
-            return (
-              zh(),
-              Mi(a, b),
-              a === null && nf(b.stateNode.containerInfo),
-              V(b),
-              null
-            );
-          case 10:
-            return lg$1(b.type._context), V(b), null;
-          case 17:
-            return Tf(b.type) && Uf(), V(b), null;
-          case 19:
-            G(P);
-            f = b.memoizedState;
-            if (f === null) return V(b), null;
-            d = (b.flags & 128) !== 0;
-            g = f.rendering;
-            if (g === null)
-              if (d) Pi$1(f, false);
-              else {
-                if (W !== 0 || (a !== null && (a.flags & 128) !== 0))
-                  for (a = b.child; a !== null; ) {
-                    g = Ch(a);
-                    if (g !== null) {
-                      b.flags |= 128;
-                      Pi$1(f, false);
-                      d = g.updateQueue;
-                      d !== null && ((b.updateQueue = d), (b.flags |= 4));
-                      b.subtreeFlags = 0;
-                      d = c;
-                      for (c = b.child; c !== null; )
-                        (f = c),
-                          (a = d),
-                          (f.flags &= 14680066),
-                          (g = f.alternate),
-                          g === null
-                            ? ((f.childLanes = 0),
-                              (f.lanes = a),
-                              (f.child = null),
-                              (f.subtreeFlags = 0),
-                              (f.memoizedProps = null),
-                              (f.memoizedState = null),
-                              (f.updateQueue = null),
-                              (f.dependencies = null),
-                              (f.stateNode = null))
-                            : ((f.childLanes = g.childLanes),
-                              (f.lanes = g.lanes),
-                              (f.child = g.child),
-                              (f.subtreeFlags = 0),
-                              (f.deletions = null),
-                              (f.memoizedProps = g.memoizedProps),
-                              (f.memoizedState = g.memoizedState),
-                              (f.updateQueue = g.updateQueue),
-                              (f.type = g.type),
-                              (a = g.dependencies),
-                              (f.dependencies =
-                                a === null
-                                  ? null
-                                  : {
-                                      lanes: a.lanes,
-                                      firstContext: a.firstContext,
-                                    })),
-                          (c = c.sibling);
-                      H(P, (P.current & 1) | 2);
-                      return b.child;
-                    }
-                    a = a.sibling;
-                  }
-                f.tail !== null &&
-                  D() > Ti &&
-                  ((b.flags |= 128),
-                  (d = true),
-                  Pi$1(f, false),
-                  (b.lanes = 4194304));
-              }
-            else {
-              if (!d)
-                if (((a = Ch(g)), a !== null)) {
-                  if (
-                    ((b.flags |= 128),
-                    (d = true),
-                    (c = a.updateQueue),
-                    c !== null && ((b.updateQueue = c), (b.flags |= 4)),
-                    Pi$1(f, true),
-                    f.tail === null &&
-                      f.tailMode === "hidden" &&
-                      !g.alternate &&
-                      !N)
-                  )
-                    return V(b), null;
-                } else
-                  2 * D() - f.renderingStartTime > Ti &&
-                    c !== 1073741824 &&
-                    ((b.flags |= 128),
-                    (d = true),
-                    Pi$1(f, false),
-                    (b.lanes = 4194304));
-              f.isBackwards
-                ? ((g.sibling = b.child), (b.child = g))
-                : ((c = f.last),
-                  c !== null ? (c.sibling = g) : (b.child = g),
-                  (f.last = g));
-            }
-            if (f.tail !== null)
-              return (
-                (b = f.tail),
-                (f.rendering = b),
-                (f.tail = b.sibling),
-                (f.renderingStartTime = D()),
-                (b.sibling = null),
-                (c = P.current),
-                H(P, d ? (c & 1) | 2 : c & 1),
-                b
-              );
-            V(b);
-            return null;
-          case 22:
-          case 23:
-            return (
-              Ui(),
-              (d = b.memoizedState !== null),
-              a !== null &&
-                (a.memoizedState !== null) !== d &&
-                (b.flags |= 8192),
-              d && (b.mode & 1) !== 0
-                ? (Vi & 1073741824) !== 0 &&
-                  (V(b), b.subtreeFlags & 6 && (b.flags |= 8192))
-                : V(b),
-              null
-            );
-          case 24:
-            return null;
-          case 25:
-            return null;
-        }
-        throw Error(p$1(156, b.tag));
-      }
-      var Wi = sa.ReactCurrentOwner,
-        og = false;
-      function Xi$1(a, b, c, d) {
-        b.child = a === null ? sh(b, null, c, d) : rh(b, a.child, c, d);
-      }
-      function Yi(a, b, c, d, e) {
-        c = c.render;
-        var f = b.ref;
-        ng(b, e);
-        d = Nh(a, b, c, d, f, e);
-        c = Sh();
-        if (a !== null && !og)
-          return (
-            (b.updateQueue = a.updateQueue),
-            (b.flags &= -2053),
-            (a.lanes &= ~e),
-            Zi(a, b, e)
-          );
-        N && c && Vg(b);
-        b.flags |= 1;
-        Xi$1(a, b, d, e);
-        return b.child;
-      }
-      function $i(a, b, c, d, e) {
-        if (a === null) {
-          var f = c.type;
-          if (
-            typeof f === "function" &&
-            !aj(f) &&
-            f.defaultProps === void 0 &&
-            c.compare === null &&
-            c.defaultProps === void 0
-          )
-            return (b.tag = 15), (b.type = f), bj(a, b, f, d, e);
-          a = oh(c.type, null, d, b, b.mode, e);
-          a.ref = b.ref;
-          a.return = b;
-          return (b.child = a);
-        }
-        f = a.child;
-        if ((a.lanes & e) === 0) {
-          var g = f.memoizedProps;
-          c = c.compare;
-          c = c !== null ? c : De;
-          if (c(g, d) && a.ref === b.ref) return Zi(a, b, e);
-        }
-        b.flags |= 1;
-        a = mh(f, d);
-        a.ref = b.ref;
-        a.return = b;
-        return (b.child = a);
-      }
-      function bj(a, b, c, d, e) {
-        if (a !== null && De(a.memoizedProps, d) && a.ref === b.ref)
-          if (((og = false), (a.lanes & e) !== 0))
-            (a.flags & 131072) !== 0 && (og = true);
-          else return (b.lanes = a.lanes), Zi(a, b, e);
-        return cj(a, b, c, d, e);
-      }
-      function dj(a, b, c) {
-        var d = b.pendingProps,
-          e = d.children,
-          f = a !== null ? a.memoizedState : null;
-        if (d.mode === "hidden")
-          if ((b.mode & 1) === 0)
-            (b.memoizedState = { baseLanes: 0, cachePool: null }),
-              H(ej, Vi),
-              (Vi |= c);
-          else if ((c & 1073741824) !== 0)
-            (b.memoizedState = { baseLanes: 0, cachePool: null }),
-              (d = f !== null ? f.baseLanes : c),
-              H(ej, Vi),
-              (Vi |= d);
-          else
-            return (
-              (a = f !== null ? f.baseLanes | c : c),
-              (b.lanes = b.childLanes = 1073741824),
-              (b.memoizedState = { baseLanes: a, cachePool: null }),
-              (b.updateQueue = null),
-              H(ej, Vi),
-              (Vi |= a),
-              null
-            );
-        else
-          f !== null
-            ? ((d = f.baseLanes | c), (b.memoizedState = null))
-            : (d = c),
-            H(ej, Vi),
-            (Vi |= d);
-        Xi$1(a, b, e, c);
-        return b.child;
-      }
-      function fj(a, b) {
-        var c = b.ref;
-        if ((a === null && c !== null) || (a !== null && a.ref !== c))
-          (b.flags |= 512), (b.flags |= 2097152);
-      }
-      function cj(a, b, c, d, e) {
-        var f = Tf(c) ? Rf : I.current;
-        f = Sf(b, f);
-        ng(b, e);
-        c = Nh(a, b, c, d, f, e);
-        d = Sh();
-        if (a !== null && !og)
-          return (
-            (b.updateQueue = a.updateQueue),
-            (b.flags &= -2053),
-            (a.lanes &= ~e),
-            Zi(a, b, e)
-          );
-        N && d && Vg(b);
-        b.flags |= 1;
-        Xi$1(a, b, c, e);
-        return b.child;
-      }
-      function gj(a, b, c, d, e) {
-        if (Tf(c)) {
-          var f = true;
-          Xf(b);
-        } else f = false;
-        ng(b, e);
-        if (b.stateNode === null)
-          a !== null &&
-            ((a.alternate = null), (b.alternate = null), (b.flags |= 2)),
-            Hg(b, c, d),
-            Jg(b, c, d, e),
-            (d = true);
-        else if (a === null) {
-          var g = b.stateNode,
-            h = b.memoizedProps;
-          g.props = h;
-          var k = g.context,
-            l2 = c.contextType;
-          typeof l2 === "object" && l2 !== null
-            ? (l2 = pg(l2))
-            : ((l2 = Tf(c) ? Rf : I.current), (l2 = Sf(b, l2)));
-          var m = c.getDerivedStateFromProps,
-            w2 =
-              typeof m === "function" ||
-              typeof g.getSnapshotBeforeUpdate === "function";
-          w2 ||
-            (typeof g.UNSAFE_componentWillReceiveProps !== "function" &&
-              typeof g.componentWillReceiveProps !== "function") ||
-            ((h !== d || k !== l2) && Ig(b, g, d, l2));
-          rg = false;
-          var u2 = b.memoizedState;
-          g.state = u2;
-          yg(b, d, g, e);
-          k = b.memoizedState;
-          h !== d || u2 !== k || Qf.current || rg
-            ? (typeof m === "function" &&
-                (Cg(b, c, m, d), (k = b.memoizedState)),
-              (h = rg || Gg$1(b, c, h, d, u2, k, l2))
-                ? (w2 ||
-                    (typeof g.UNSAFE_componentWillMount !== "function" &&
-                      typeof g.componentWillMount !== "function") ||
-                    (typeof g.componentWillMount === "function" &&
-                      g.componentWillMount(),
-                    typeof g.UNSAFE_componentWillMount === "function" &&
-                      g.UNSAFE_componentWillMount()),
-                  typeof g.componentDidMount === "function" &&
-                    (b.flags |= 4194308))
-                : (typeof g.componentDidMount === "function" &&
-                    (b.flags |= 4194308),
-                  (b.memoizedProps = d),
-                  (b.memoizedState = k)),
-              (g.props = d),
-              (g.state = k),
-              (g.context = l2),
-              (d = h))
-            : (typeof g.componentDidMount === "function" &&
-                (b.flags |= 4194308),
-              (d = false));
-        } else {
-          g = b.stateNode;
-          tg(a, b);
-          h = b.memoizedProps;
-          l2 = b.type === b.elementType ? h : fg(b.type, h);
-          g.props = l2;
-          w2 = b.pendingProps;
-          u2 = g.context;
-          k = c.contextType;
-          typeof k === "object" && k !== null
-            ? (k = pg(k))
-            : ((k = Tf(c) ? Rf : I.current), (k = Sf(b, k)));
-          var y2 = c.getDerivedStateFromProps;
-          (m =
-            typeof y2 === "function" ||
-            typeof g.getSnapshotBeforeUpdate === "function") ||
-            (typeof g.UNSAFE_componentWillReceiveProps !== "function" &&
-              typeof g.componentWillReceiveProps !== "function") ||
-            ((h !== w2 || u2 !== k) && Ig(b, g, d, k));
-          rg = false;
-          u2 = b.memoizedState;
-          g.state = u2;
-          yg(b, d, g, e);
-          var n2 = b.memoizedState;
-          h !== w2 || u2 !== n2 || Qf.current || rg
-            ? (typeof y2 === "function" &&
-                (Cg(b, c, y2, d), (n2 = b.memoizedState)),
-              (l2 = rg || Gg$1(b, c, l2, d, u2, n2, k) || false)
-                ? (m ||
-                    (typeof g.UNSAFE_componentWillUpdate !== "function" &&
-                      typeof g.componentWillUpdate !== "function") ||
-                    (typeof g.componentWillUpdate === "function" &&
-                      g.componentWillUpdate(d, n2, k),
-                    typeof g.UNSAFE_componentWillUpdate === "function" &&
-                      g.UNSAFE_componentWillUpdate(d, n2, k)),
-                  typeof g.componentDidUpdate === "function" && (b.flags |= 4),
-                  typeof g.getSnapshotBeforeUpdate === "function" &&
-                    (b.flags |= 1024))
-                : (typeof g.componentDidUpdate !== "function" ||
-                    (h === a.memoizedProps && u2 === a.memoizedState) ||
-                    (b.flags |= 4),
-                  typeof g.getSnapshotBeforeUpdate !== "function" ||
-                    (h === a.memoizedProps && u2 === a.memoizedState) ||
-                    (b.flags |= 1024),
-                  (b.memoizedProps = d),
-                  (b.memoizedState = n2)),
-              (g.props = d),
-              (g.state = n2),
-              (g.context = k),
-              (d = l2))
-            : (typeof g.componentDidUpdate !== "function" ||
-                (h === a.memoizedProps && u2 === a.memoizedState) ||
-                (b.flags |= 4),
-              typeof g.getSnapshotBeforeUpdate !== "function" ||
-                (h === a.memoizedProps && u2 === a.memoizedState) ||
-                (b.flags |= 1024),
-              (d = false));
-        }
-        return hj(a, b, c, d, f, e);
-      }
-      function hj(a, b, c, d, e, f) {
-        fj(a, b);
-        var g = (b.flags & 128) !== 0;
-        if (!d && !g) return e && Yf(b, c, false), Zi(a, b, f);
-        d = b.stateNode;
-        Wi.current = b;
-        var h =
-          g && typeof c.getDerivedStateFromError !== "function"
-            ? null
-            : d.render();
-        b.flags |= 1;
-        a !== null && g
-          ? ((b.child = rh(b, a.child, null, f)), (b.child = rh(b, null, h, f)))
-          : Xi$1(a, b, h, f);
-        b.memoizedState = d.state;
-        e && Yf(b, c, true);
-        return b.child;
-      }
-      function ij(a) {
-        var b = a.stateNode;
-        b.pendingContext
-          ? Vf(a, b.pendingContext, b.pendingContext !== b.context)
-          : b.context && Vf(a, b.context, false);
-        yh(a, b.containerInfo);
-      }
-      function jj(a, b, c, d, e) {
-        gh();
-        hh(e);
-        b.flags |= 256;
-        Xi$1(a, b, c, d);
-        return b.child;
-      }
-      var kj = { dehydrated: null, treeContext: null, retryLane: 0 };
-      function lj(a) {
-        return { baseLanes: a, cachePool: null };
-      }
-      function mj(a, b, c) {
-        var d = b.pendingProps,
-          e = P.current,
-          f = false,
-          g = (b.flags & 128) !== 0,
-          h;
-        (h = g) ||
-          (h = a !== null && a.memoizedState === null ? false : (e & 2) !== 0);
-        if (h) (f = true), (b.flags &= -129);
-        else if (a === null || a.memoizedState !== null) e |= 1;
-        H(P, e & 1);
-        if (a === null) {
-          dh(b);
-          a = b.memoizedState;
-          if (a !== null && ((a = a.dehydrated), a !== null))
-            return (
-              (b.mode & 1) === 0
-                ? (b.lanes = 1)
-                : a.data === "$!"
-                ? (b.lanes = 8)
-                : (b.lanes = 1073741824),
-              null
-            );
-          e = d.children;
-          a = d.fallback;
-          return f
-            ? ((d = b.mode),
-              (f = b.child),
-              (e = { mode: "hidden", children: e }),
-              (d & 1) === 0 && f !== null
-                ? ((f.childLanes = 0), (f.pendingProps = e))
-                : (f = nj(e, d, 0, null)),
-              (a = qh(a, d, c, null)),
-              (f.return = b),
-              (a.return = b),
-              (f.sibling = a),
-              (b.child = f),
-              (b.child.memoizedState = lj(c)),
-              (b.memoizedState = kj),
-              a)
-            : oj(b, e);
-        }
-        e = a.memoizedState;
-        if (e !== null) {
-          h = e.dehydrated;
-          if (h !== null) {
-            if (g) {
-              if (b.flags & 256)
-                return (b.flags &= -257), pj(a, b, c, Error(p$1(422)));
-              if (b.memoizedState !== null)
-                return (b.child = a.child), (b.flags |= 128), null;
-              f = d.fallback;
-              e = b.mode;
-              d = nj({ mode: "visible", children: d.children }, e, 0, null);
-              f = qh(f, e, c, null);
-              f.flags |= 2;
-              d.return = b;
-              f.return = b;
-              d.sibling = f;
-              b.child = d;
-              (b.mode & 1) !== 0 && rh(b, a.child, null, c);
-              b.child.memoizedState = lj(c);
-              b.memoizedState = kj;
-              return f;
-            }
-            if ((b.mode & 1) === 0) b = pj(a, b, c, null);
-            else if (h.data === "$!") b = pj(a, b, c, Error(p$1(419)));
-            else if (((d = (c & a.childLanes) !== 0), og || d)) {
-              d = J;
-              if (d !== null) {
-                switch (c & -c) {
-                  case 4:
-                    f = 2;
-                    break;
-                  case 16:
-                    f = 8;
-                    break;
-                  case 64:
-                  case 128:
-                  case 256:
-                  case 512:
-                  case 1024:
-                  case 2048:
-                  case 4096:
-                  case 8192:
-                  case 16384:
-                  case 32768:
-                  case 65536:
-                  case 131072:
-                  case 262144:
-                  case 524288:
-                  case 1048576:
-                  case 2097152:
-                  case 4194304:
-                  case 8388608:
-                  case 16777216:
-                  case 33554432:
-                  case 67108864:
-                    f = 32;
-                    break;
-                  case 536870912:
-                    f = 268435456;
-                    break;
-                  default:
-                    f = 0;
-                }
-                d = (f & (d.suspendedLanes | c)) !== 0 ? 0 : f;
-                d !== 0 &&
-                  d !== e.retryLane &&
-                  ((e.retryLane = d), Eg(a, d, -1));
-              }
-              Si();
-              b = pj(a, b, c, Error(p$1(421)));
-            } else
-              h.data === "$?"
-                ? ((b.flags |= 128),
-                  (b.child = a.child),
-                  (b = qj.bind(null, a)),
-                  (h._reactRetry = b),
-                  (b = null))
-                : ((c = e.treeContext),
-                  (Yg = Ff(h.nextSibling)),
-                  (Xg = b),
-                  (N = true),
-                  (Zg = null),
-                  c !== null &&
-                    ((Og[Pg++] = Rg),
-                    (Og[Pg++] = Sg),
-                    (Og[Pg++] = Qg),
-                    (Rg = c.id),
-                    (Sg = c.overflow),
-                    (Qg = b)),
-                  (b = oj(b, b.pendingProps.children)),
-                  (b.flags |= 4096));
-            return b;
-          }
-          if (f)
-            return (
-              (d = rj(a, b, d.children, d.fallback, c)),
-              (f = b.child),
-              (e = a.child.memoizedState),
-              (f.memoizedState =
-                e === null
-                  ? lj(c)
-                  : { baseLanes: e.baseLanes | c, cachePool: null }),
-              (f.childLanes = a.childLanes & ~c),
-              (b.memoizedState = kj),
-              d
-            );
-          c = sj(a, b, d.children, c);
-          b.memoizedState = null;
-          return c;
-        }
-        if (f)
-          return (
-            (d = rj(a, b, d.children, d.fallback, c)),
-            (f = b.child),
-            (e = a.child.memoizedState),
-            (f.memoizedState =
-              e === null
-                ? lj(c)
-                : { baseLanes: e.baseLanes | c, cachePool: null }),
-            (f.childLanes = a.childLanes & ~c),
-            (b.memoizedState = kj),
-            d
-          );
-        c = sj(a, b, d.children, c);
-        b.memoizedState = null;
-        return c;
-      }
-      function oj(a, b) {
-        b = nj({ mode: "visible", children: b }, a.mode, 0, null);
-        b.return = a;
-        return (a.child = b);
-      }
-      function sj(a, b, c, d) {
-        var e = a.child;
-        a = e.sibling;
-        c = mh(e, { mode: "visible", children: c });
-        (b.mode & 1) === 0 && (c.lanes = d);
-        c.return = b;
-        c.sibling = null;
-        a !== null &&
-          ((d = b.deletions),
-          d === null ? ((b.deletions = [a]), (b.flags |= 16)) : d.push(a));
-        return (b.child = c);
-      }
-      function rj(a, b, c, d, e) {
-        var f = b.mode;
-        a = a.child;
-        var g = a.sibling,
-          h = { mode: "hidden", children: c };
-        (f & 1) === 0 && b.child !== a
-          ? ((c = b.child),
-            (c.childLanes = 0),
-            (c.pendingProps = h),
-            (b.deletions = null))
-          : ((c = mh(a, h)), (c.subtreeFlags = a.subtreeFlags & 14680064));
-        g !== null ? (d = mh(g, d)) : ((d = qh(d, f, e, null)), (d.flags |= 2));
-        d.return = b;
-        c.return = b;
-        c.sibling = d;
-        b.child = c;
-        return d;
-      }
-      function pj(a, b, c, d) {
-        d !== null && hh(d);
-        rh(b, a.child, null, c);
-        a = oj(b, b.pendingProps.children);
-        a.flags |= 2;
-        b.memoizedState = null;
-        return a;
-      }
-      function tj(a, b, c) {
-        a.lanes |= b;
-        var d = a.alternate;
-        d !== null && (d.lanes |= b);
-        mg(a.return, b, c);
-      }
-      function uj(a, b, c, d, e) {
-        var f = a.memoizedState;
-        f === null
-          ? (a.memoizedState = {
-              isBackwards: b,
-              rendering: null,
-              renderingStartTime: 0,
-              last: d,
-              tail: c,
-              tailMode: e,
-            })
-          : ((f.isBackwards = b),
-            (f.rendering = null),
-            (f.renderingStartTime = 0),
-            (f.last = d),
-            (f.tail = c),
-            (f.tailMode = e));
-      }
-      function vj(a, b, c) {
-        var d = b.pendingProps,
-          e = d.revealOrder,
-          f = d.tail;
-        Xi$1(a, b, d.children, c);
-        d = P.current;
-        if ((d & 2) !== 0) (d = (d & 1) | 2), (b.flags |= 128);
-        else {
-          if (a !== null && (a.flags & 128) !== 0)
-            a: for (a = b.child; a !== null; ) {
-              if (a.tag === 13) a.memoizedState !== null && tj(a, c, b);
-              else if (a.tag === 19) tj(a, c, b);
-              else if (a.child !== null) {
-                a.child.return = a;
-                a = a.child;
-                continue;
-              }
-              if (a === b) break a;
-              for (; a.sibling === null; ) {
-                if (a.return === null || a.return === b) break a;
-                a = a.return;
-              }
-              a.sibling.return = a.return;
-              a = a.sibling;
-            }
-          d &= 1;
-        }
-        H(P, d);
-        if ((b.mode & 1) === 0) b.memoizedState = null;
-        else
-          switch (e) {
-            case "forwards":
-              c = b.child;
-              for (e = null; c !== null; )
-                (a = c.alternate),
-                  a !== null && Ch(a) === null && (e = c),
-                  (c = c.sibling);
-              c = e;
-              c === null
-                ? ((e = b.child), (b.child = null))
-                : ((e = c.sibling), (c.sibling = null));
-              uj(b, false, e, c, f);
-              break;
-            case "backwards":
-              c = null;
-              e = b.child;
-              for (b.child = null; e !== null; ) {
-                a = e.alternate;
-                if (a !== null && Ch(a) === null) {
-                  b.child = e;
-                  break;
-                }
-                a = e.sibling;
-                e.sibling = c;
-                c = e;
-                e = a;
-              }
-              uj(b, true, c, null, f);
-              break;
-            case "together":
-              uj(b, false, null, null, void 0);
-              break;
-            default:
-              b.memoizedState = null;
-          }
-        return b.child;
-      }
-      function Zi(a, b, c) {
-        a !== null && (b.dependencies = a.dependencies);
-        zg |= b.lanes;
-        if ((c & b.childLanes) === 0) return null;
-        if (a !== null && b.child !== a.child) throw Error(p$1(153));
-        if (b.child !== null) {
-          a = b.child;
-          c = mh(a, a.pendingProps);
-          b.child = c;
-          for (c.return = b; a.sibling !== null; )
-            (a = a.sibling),
-              (c = c.sibling = mh(a, a.pendingProps)),
-              (c.return = b);
-          c.sibling = null;
-        }
-        return b.child;
-      }
-      function wj(a, b, c) {
-        switch (b.tag) {
-          case 3:
-            ij(b);
-            gh();
-            break;
-          case 5:
-            Ah(b);
-            break;
-          case 1:
-            Tf(b.type) && Xf(b);
-            break;
-          case 4:
-            yh(b, b.stateNode.containerInfo);
-            break;
-          case 10:
-            var d = b.type._context,
-              e = b.memoizedProps.value;
-            H(gg$1, d._currentValue);
-            d._currentValue = e;
-            break;
-          case 13:
-            d = b.memoizedState;
-            if (d !== null) {
-              if (d.dehydrated !== null)
-                return H(P, P.current & 1), (b.flags |= 128), null;
-              if ((c & b.child.childLanes) !== 0) return mj(a, b, c);
-              H(P, P.current & 1);
-              a = Zi(a, b, c);
-              return a !== null ? a.sibling : null;
-            }
-            H(P, P.current & 1);
-            break;
-          case 19:
-            d = (c & b.childLanes) !== 0;
-            if ((a.flags & 128) !== 0) {
-              if (d) return vj(a, b, c);
-              b.flags |= 128;
-            }
-            e = b.memoizedState;
-            e !== null &&
-              ((e.rendering = null), (e.tail = null), (e.lastEffect = null));
-            H(P, P.current);
-            if (d) break;
-            else return null;
-          case 22:
-          case 23:
-            return (b.lanes = 0), dj(a, b, c);
-        }
-        return Zi(a, b, c);
-      }
-      function xj(a, b) {
-        Wg(b);
-        switch (b.tag) {
-          case 1:
-            return (
-              Tf(b.type) && Uf(),
-              (a = b.flags),
-              a & 65536 ? ((b.flags = (a & -65537) | 128), b) : null
-            );
-          case 3:
-            return (
-              zh(),
-              G(Qf),
-              G(I),
-              Eh(),
-              (a = b.flags),
-              (a & 65536) !== 0 && (a & 128) === 0
-                ? ((b.flags = (a & -65537) | 128), b)
-                : null
-            );
-          case 5:
-            return Bh(b), null;
-          case 13:
-            G(P);
-            a = b.memoizedState;
-            if (a !== null && a.dehydrated !== null) {
-              if (b.alternate === null) throw Error(p$1(340));
-              gh();
-            }
-            a = b.flags;
-            return a & 65536 ? ((b.flags = (a & -65537) | 128), b) : null;
-          case 19:
-            return G(P), null;
-          case 4:
-            return zh(), null;
-          case 10:
-            return lg$1(b.type._context), null;
-          case 22:
-          case 23:
-            return Ui(), null;
-          case 24:
-            return null;
-          default:
-            return null;
-        }
-      }
-      var yj = false,
-        zj = false,
-        Aj = typeof WeakSet === "function" ? WeakSet : Set,
-        X = null;
-      function Bj(a, b) {
-        var c = a.ref;
-        if (c !== null)
-          if (typeof c === "function")
-            try {
-              c(null);
-            } catch (d) {
-              Cj(a, b, d);
-            }
-          else c.current = null;
-      }
-      function Dj(a, b, c) {
-        try {
-          c();
-        } catch (d) {
-          Cj(a, b, d);
-        }
-      }
-      var Ej = false;
-      function Fj(a, b) {
-        a = He();
-        if (Ie(a)) {
-          if ("selectionStart" in a)
-            var c = { start: a.selectionStart, end: a.selectionEnd };
-          else
-            a: {
-              c = ((c = a.ownerDocument) && c.defaultView) || window;
-              var d = c.getSelection && c.getSelection();
-              if (d && d.rangeCount !== 0) {
-                c = d.anchorNode;
-                var e = d.anchorOffset,
-                  f = d.focusNode;
-                d = d.focusOffset;
-                try {
-                  c.nodeType, f.nodeType;
-                } catch (O2) {
-                  c = null;
-                  break a;
-                }
-                var g = 0,
-                  h = -1,
-                  k = -1,
-                  l2 = 0,
-                  m = 0,
-                  w2 = a,
-                  u2 = null;
-                b: for (;;) {
-                  for (var y2; ; ) {
-                    w2 !== c || (e !== 0 && w2.nodeType !== 3) || (h = g + e);
-                    w2 !== f || (d !== 0 && w2.nodeType !== 3) || (k = g + d);
-                    w2.nodeType === 3 && (g += w2.nodeValue.length);
-                    if ((y2 = w2.firstChild) === null) break;
-                    u2 = w2;
-                    w2 = y2;
-                  }
-                  for (;;) {
-                    if (w2 === a) break b;
-                    u2 === c && ++l2 === e && (h = g);
-                    u2 === f && ++m === d && (k = g);
-                    if ((y2 = w2.nextSibling) !== null) break;
-                    w2 = u2;
-                    u2 = w2.parentNode;
-                  }
-                  w2 = y2;
-                }
-                c = h === -1 || k === -1 ? null : { start: h, end: k };
-              } else c = null;
-            }
-          c = c || { start: 0, end: 0 };
-        } else c = null;
-        xf = { focusedElem: a, selectionRange: c };
-        for (X = b; X !== null; )
-          if (
-            ((b = X),
-            (a = b.child),
-            (b.subtreeFlags & 1028) !== 0 && a !== null)
-          )
-            (a.return = b), (X = a);
-          else
-            for (; X !== null; ) {
-              b = X;
-              try {
-                var n2 = b.alternate;
-                if ((b.flags & 1024) !== 0)
-                  switch (b.tag) {
-                    case 0:
-                    case 11:
-                    case 15:
-                      break;
-                    case 1:
-                      if (n2 !== null) {
-                        var v2 = n2.memoizedProps,
-                          C2 = n2.memoizedState,
-                          t2 = b.stateNode,
-                          r2 = t2.getSnapshotBeforeUpdate(
-                            b.elementType === b.type ? v2 : fg(b.type, v2),
-                            C2
-                          );
-                        t2.__reactInternalSnapshotBeforeUpdate = r2;
-                      }
-                      break;
-                    case 3:
-                      var x2 = b.stateNode.containerInfo;
-                      if (x2.nodeType === 1) x2.textContent = "";
-                      else if (x2.nodeType === 9) {
-                        var B2 = x2.body;
-                        B2 != null && (B2.textContent = "");
-                      }
-                      break;
-                    case 5:
-                    case 6:
-                    case 4:
-                    case 17:
-                      break;
-                    default:
-                      throw Error(p$1(163));
-                  }
-              } catch (O2) {
-                Cj(b, b.return, O2);
-              }
-              a = b.sibling;
-              if (a !== null) {
-                a.return = b.return;
-                X = a;
-                break;
-              }
-              X = b.return;
-            }
-        n2 = Ej;
-        Ej = false;
-        return n2;
-      }
-      function Gj(a, b, c) {
-        var d = b.updateQueue;
-        d = d !== null ? d.lastEffect : null;
-        if (d !== null) {
-          var e = (d = d.next);
-          do {
-            if ((e.tag & a) === a) {
-              var f = e.destroy;
-              e.destroy = void 0;
-              f !== void 0 && Dj(b, c, f);
-            }
-            e = e.next;
-          } while (e !== d);
-        }
-      }
-      function Hj(a, b) {
-        b = b.updateQueue;
-        b = b !== null ? b.lastEffect : null;
-        if (b !== null) {
-          var c = (b = b.next);
-          do {
-            if ((c.tag & a) === a) {
-              var d = c.create;
-              c.destroy = d();
-            }
-            c = c.next;
-          } while (c !== b);
-        }
-      }
-      function Ij(a) {
-        var b = a.ref;
-        if (b !== null) {
-          var c = a.stateNode;
-          switch (a.tag) {
-            case 5:
-              a = c;
-              break;
-            default:
-              a = c;
-          }
-          typeof b === "function" ? b(a) : (b.current = a);
-        }
-      }
-      function Jj(a, b, c) {
-        if (ic$1 && typeof ic$1.onCommitFiberUnmount === "function")
-          try {
-            ic$1.onCommitFiberUnmount(hc, b);
-          } catch (g) {}
-        switch (b.tag) {
-          case 0:
-          case 11:
-          case 14:
-          case 15:
-            a = b.updateQueue;
-            if (a !== null && ((a = a.lastEffect), a !== null)) {
-              var d = (a = a.next);
-              do {
-                var e = d,
-                  f = e.destroy;
-                e = e.tag;
-                f !== void 0 &&
-                  ((e & 2) !== 0 ? Dj(b, c, f) : (e & 4) !== 0 && Dj(b, c, f));
-                d = d.next;
-              } while (d !== a);
-            }
-            break;
-          case 1:
-            Bj(b, c);
-            a = b.stateNode;
-            if (typeof a.componentWillUnmount === "function")
-              try {
-                (a.props = b.memoizedProps),
-                  (a.state = b.memoizedState),
-                  a.componentWillUnmount();
-              } catch (g) {
-                Cj(b, c, g);
-              }
-            break;
-          case 5:
-            Bj(b, c);
-            break;
-          case 4:
-            Kj(a, b, c);
-        }
-      }
-      function Lj(a) {
-        var b = a.alternate;
-        b !== null && ((a.alternate = null), Lj(b));
-        a.child = null;
-        a.deletions = null;
-        a.sibling = null;
-        a.tag === 5 &&
-          ((b = a.stateNode),
-          b !== null &&
-            (delete b[If],
-            delete b[Jf],
-            delete b[jf],
-            delete b[Kf],
-            delete b[Lf]));
-        a.stateNode = null;
-        a.return = null;
-        a.dependencies = null;
-        a.memoizedProps = null;
-        a.memoizedState = null;
-        a.pendingProps = null;
-        a.stateNode = null;
-        a.updateQueue = null;
-      }
-      function Mj(a) {
-        return a.tag === 5 || a.tag === 3 || a.tag === 4;
-      }
-      function Nj(a) {
-        a: for (;;) {
-          for (; a.sibling === null; ) {
-            if (a.return === null || Mj(a.return)) return null;
-            a = a.return;
-          }
-          a.sibling.return = a.return;
-          for (a = a.sibling; a.tag !== 5 && a.tag !== 6 && a.tag !== 18; ) {
-            if (a.flags & 2) continue a;
-            if (a.child === null || a.tag === 4) continue a;
-            else (a.child.return = a), (a = a.child);
-          }
-          if (!(a.flags & 2)) return a.stateNode;
-        }
-      }
-      function Oj(a) {
-        a: {
-          for (var b = a.return; b !== null; ) {
-            if (Mj(b)) break a;
-            b = b.return;
-          }
-          throw Error(p$1(160));
-        }
-        var c = b;
-        switch (c.tag) {
-          case 5:
-            b = c.stateNode;
-            c.flags & 32 && (lb(b, ""), (c.flags &= -33));
-            c = Nj(a);
-            Pj(a, c, b);
-            break;
-          case 3:
-          case 4:
-            b = c.stateNode.containerInfo;
-            c = Nj(a);
-            Qj(a, c, b);
-            break;
-          default:
-            throw Error(p$1(161));
-        }
-      }
-      function Qj(a, b, c) {
-        var d = a.tag;
-        if (d === 5 || d === 6)
-          (a = a.stateNode),
-            b
-              ? c.nodeType === 8
-                ? c.parentNode.insertBefore(a, b)
-                : c.insertBefore(a, b)
-              : (c.nodeType === 8
-                  ? ((b = c.parentNode), b.insertBefore(a, c))
-                  : ((b = c), b.appendChild(a)),
-                (c = c._reactRootContainer),
-                (c !== null && c !== void 0) ||
-                  b.onclick !== null ||
-                  (b.onclick = wf));
-        else if (d !== 4 && ((a = a.child), a !== null))
-          for (Qj(a, b, c), a = a.sibling; a !== null; )
-            Qj(a, b, c), (a = a.sibling);
-      }
-      function Pj(a, b, c) {
-        var d = a.tag;
-        if (d === 5 || d === 6)
-          (a = a.stateNode), b ? c.insertBefore(a, b) : c.appendChild(a);
-        else if (d !== 4 && ((a = a.child), a !== null))
-          for (Pj(a, b, c), a = a.sibling; a !== null; )
-            Pj(a, b, c), (a = a.sibling);
-      }
-      function Kj(a, b, c) {
-        for (var d = b, e = false, f, g; ; ) {
-          if (!e) {
-            e = d.return;
-            a: for (;;) {
-              if (e === null) throw Error(p$1(160));
-              f = e.stateNode;
-              switch (e.tag) {
-                case 5:
-                  g = false;
-                  break a;
-                case 3:
-                  f = f.containerInfo;
-                  g = true;
-                  break a;
-                case 4:
-                  f = f.containerInfo;
-                  g = true;
-                  break a;
-              }
-              e = e.return;
-            }
-            e = true;
-          }
-          if (d.tag === 5 || d.tag === 6) {
-            a: for (var h = a, k = d, l2 = c, m = k; ; )
-              if ((Jj(h, m, l2), m.child !== null && m.tag !== 4))
-                (m.child.return = m), (m = m.child);
-              else {
-                if (m === k) break a;
-                for (; m.sibling === null; ) {
-                  if (m.return === null || m.return === k) break a;
-                  m = m.return;
-                }
-                m.sibling.return = m.return;
-                m = m.sibling;
-              }
-            g
-              ? ((h = f),
-                (k = d.stateNode),
-                h.nodeType === 8
-                  ? h.parentNode.removeChild(k)
-                  : h.removeChild(k))
-              : f.removeChild(d.stateNode);
-          } else if (d.tag === 18)
-            g
-              ? ((h = f),
-                (k = d.stateNode),
-                h.nodeType === 8
-                  ? Ef(h.parentNode, k)
-                  : h.nodeType === 1 && Ef(h, k),
-                Yc(h))
-              : Ef(f, d.stateNode);
-          else if (d.tag === 4) {
-            if (d.child !== null) {
-              f = d.stateNode.containerInfo;
-              g = true;
-              d.child.return = d;
-              d = d.child;
-              continue;
-            }
-          } else if ((Jj(a, d, c), d.child !== null)) {
-            d.child.return = d;
-            d = d.child;
-            continue;
-          }
-          if (d === b) break;
-          for (; d.sibling === null; ) {
-            if (d.return === null || d.return === b) return;
-            d = d.return;
-            d.tag === 4 && (e = false);
-          }
-          d.sibling.return = d.return;
-          d = d.sibling;
-        }
-      }
-      function Rj(a, b) {
-        switch (b.tag) {
-          case 0:
-          case 11:
-          case 14:
-          case 15:
-            Gj(3, b, b.return);
-            Hj(3, b);
-            Gj(5, b, b.return);
-            return;
-          case 1:
-            return;
-          case 5:
-            var c = b.stateNode;
-            if (c != null) {
-              var d = b.memoizedProps,
-                e = a !== null ? a.memoizedProps : d;
-              a = b.type;
-              var f = b.updateQueue;
-              b.updateQueue = null;
-              if (f !== null) {
-                a === "input" &&
-                  d.type === "radio" &&
-                  d.name != null &&
-                  Ya(c, d);
-                sb(a, e);
-                b = sb(a, d);
-                for (e = 0; e < f.length; e += 2) {
-                  var g = f[e],
-                    h = f[e + 1];
-                  g === "style"
-                    ? pb(c, h)
-                    : g === "dangerouslySetInnerHTML"
-                    ? kb(c, h)
-                    : g === "children"
-                    ? lb(c, h)
-                    : ra(c, g, h, b);
-                }
-                switch (a) {
-                  case "input":
-                    Za(c, d);
-                    break;
-                  case "textarea":
-                    fb(c, d);
-                    break;
-                  case "select":
-                    (a = c._wrapperState.wasMultiple),
-                      (c._wrapperState.wasMultiple = !!d.multiple),
-                      (f = d.value),
-                      f != null
-                        ? cb(c, !!d.multiple, f, false)
-                        : a !== !!d.multiple &&
-                          (d.defaultValue != null
-                            ? cb(c, !!d.multiple, d.defaultValue, true)
-                            : cb(c, !!d.multiple, d.multiple ? [] : "", false));
-                }
-                c[Jf] = d;
-              }
-            }
-            return;
-          case 6:
-            if (b.stateNode === null) throw Error(p$1(162));
-            b.stateNode.nodeValue = b.memoizedProps;
-            return;
-          case 3:
-            a !== null &&
-              a.memoizedState.isDehydrated &&
-              Yc(b.stateNode.containerInfo);
-            return;
-          case 12:
-            return;
-          case 13:
-            Sj(b);
-            return;
-          case 19:
-            Sj(b);
-            return;
-          case 17:
-            return;
-        }
-        throw Error(p$1(163));
-      }
-      function Sj(a) {
-        var b = a.updateQueue;
-        if (b !== null) {
-          a.updateQueue = null;
-          var c = a.stateNode;
-          c === null && (c = a.stateNode = new Aj());
-          b.forEach(function (b2) {
-            var d = Tj.bind(null, a, b2);
-            c.has(b2) || (c.add(b2), b2.then(d, d));
-          });
-        }
-      }
-      function Uj(a, b) {
-        for (X = b; X !== null; ) {
-          b = X;
-          var c = b.deletions;
-          if (c !== null)
-            for (var d = 0; d < c.length; d++) {
-              var e = c[d];
-              try {
-                Kj(a, e, b);
-                var f = e.alternate;
-                f !== null && (f.return = null);
-                e.return = null;
-              } catch (L2) {
-                Cj(e, b, L2);
-              }
-            }
-          c = b.child;
-          if ((b.subtreeFlags & 12854) !== 0 && c !== null)
-            (c.return = b), (X = c);
-          else
-            for (; X !== null; ) {
-              b = X;
-              try {
-                var g = b.flags;
-                g & 32 && lb(b.stateNode, "");
-                if (g & 512) {
-                  var h = b.alternate;
-                  if (h !== null) {
-                    var k = h.ref;
-                    k !== null &&
-                      (typeof k === "function" ? k(null) : (k.current = null));
-                  }
-                }
-                if (g & 8192)
-                  switch (b.tag) {
-                    case 13:
-                      if (b.memoizedState !== null) {
-                        var l2 = b.alternate;
-                        if (l2 === null || l2.memoizedState === null) Vj = D();
-                      }
-                      break;
-                    case 22:
-                      var m = b.memoizedState !== null,
-                        w2 = b.alternate,
-                        u2 = w2 !== null && w2.memoizedState !== null;
-                      c = b;
-                      a: {
-                        d = c;
-                        e = m;
-                        for (var y2 = null, n2 = d; ; ) {
-                          if (n2.tag === 5) {
-                            if (y2 === null) {
-                              y2 = n2;
-                              var v2 = n2.stateNode;
-                              if (e) {
-                                var C2 = v2.style;
-                                typeof C2.setProperty === "function"
-                                  ? C2.setProperty(
-                                      "display",
-                                      "none",
-                                      "important"
-                                    )
-                                  : (C2.display = "none");
-                              } else {
-                                var t2 = n2.stateNode,
-                                  r2 = n2.memoizedProps.style,
-                                  x2 =
-                                    r2 !== void 0 &&
-                                    r2 !== null &&
-                                    r2.hasOwnProperty("display")
-                                      ? r2.display
-                                      : null;
-                                t2.style.display = ob("display", x2);
-                              }
-                            }
-                          } else if (n2.tag === 6)
-                            y2 === null &&
-                              (n2.stateNode.nodeValue = e
-                                ? ""
-                                : n2.memoizedProps);
-                          else if (
-                            ((n2.tag !== 22 && n2.tag !== 23) ||
-                              n2.memoizedState === null ||
-                              n2 === d) &&
-                            n2.child !== null
-                          ) {
-                            n2.child.return = n2;
-                            n2 = n2.child;
-                            continue;
-                          }
-                          if (n2 === d) break;
-                          for (; n2.sibling === null; ) {
-                            if (n2.return === null || n2.return === d) break a;
-                            y2 === n2 && (y2 = null);
-                            n2 = n2.return;
-                          }
-                          y2 === n2 && (y2 = null);
-                          n2.sibling.return = n2.return;
-                          n2 = n2.sibling;
-                        }
-                      }
-                      if (m && !u2 && (c.mode & 1) !== 0) {
-                        X = c;
-                        for (var B2 = c.child; B2 !== null; ) {
-                          for (c = X = B2; X !== null; ) {
-                            d = X;
-                            var O2 = d.child;
-                            switch (d.tag) {
-                              case 0:
-                              case 11:
-                              case 14:
-                              case 15:
-                                Gj(4, d, d.return);
-                                break;
-                              case 1:
-                                Bj(d, d.return);
-                                var T2 = d.stateNode;
-                                if (
-                                  typeof T2.componentWillUnmount === "function"
-                                ) {
-                                  var za = d.return;
-                                  try {
-                                    (T2.props = d.memoizedProps),
-                                      (T2.state = d.memoizedState),
-                                      T2.componentWillUnmount();
-                                  } catch (L2) {
-                                    Cj(d, za, L2);
-                                  }
-                                }
-                                break;
-                              case 5:
-                                Bj(d, d.return);
-                                break;
-                              case 22:
-                                if (d.memoizedState !== null) {
-                                  Wj(c);
-                                  continue;
-                                }
-                            }
-                            O2 !== null ? ((O2.return = d), (X = O2)) : Wj(c);
-                          }
-                          B2 = B2.sibling;
-                        }
-                      }
-                  }
-                switch (g & 4102) {
-                  case 2:
-                    Oj(b);
-                    b.flags &= -3;
-                    break;
-                  case 6:
-                    Oj(b);
-                    b.flags &= -3;
-                    Rj(b.alternate, b);
-                    break;
-                  case 4096:
-                    b.flags &= -4097;
-                    break;
-                  case 4100:
-                    b.flags &= -4097;
-                    Rj(b.alternate, b);
-                    break;
-                  case 4:
-                    Rj(b.alternate, b);
-                }
-              } catch (L2) {
-                Cj(b, b.return, L2);
-              }
-              c = b.sibling;
-              if (c !== null) {
-                c.return = b.return;
-                X = c;
-                break;
-              }
-              X = b.return;
-            }
-        }
-      }
-      function Xj(a, b, c) {
-        X = a;
-        Yj(a);
-      }
-      function Yj(a, b, c) {
-        for (var d = (a.mode & 1) !== 0; X !== null; ) {
-          var e = X,
-            f = e.child;
-          if (e.tag === 22 && d) {
-            var g = e.memoizedState !== null || yj;
-            if (!g) {
-              var h = e.alternate,
-                k = (h !== null && h.memoizedState !== null) || zj;
-              h = yj;
-              var l2 = zj;
-              yj = g;
-              if ((zj = k) && !l2)
-                for (X = e; X !== null; )
-                  (g = X),
-                    (k = g.child),
-                    g.tag === 22 && g.memoizedState !== null
-                      ? Zj(e)
-                      : k !== null
-                      ? ((k.return = g), (X = k))
-                      : Zj(e);
-              for (; f !== null; ) (X = f), Yj(f), (f = f.sibling);
-              X = e;
-              yj = h;
-              zj = l2;
-            }
-            ak(a);
-          } else
-            (e.subtreeFlags & 8772) !== 0 && f !== null
-              ? ((f.return = e), (X = f))
-              : ak(a);
-        }
-      }
-      function ak(a) {
-        for (; X !== null; ) {
-          var b = X;
-          if ((b.flags & 8772) !== 0) {
-            var c = b.alternate;
-            try {
-              if ((b.flags & 8772) !== 0)
-                switch (b.tag) {
-                  case 0:
-                  case 11:
-                  case 15:
-                    zj || Hj(5, b);
-                    break;
-                  case 1:
-                    var d = b.stateNode;
-                    if (b.flags & 4 && !zj)
-                      if (c === null) d.componentDidMount();
-                      else {
-                        var e =
-                          b.elementType === b.type
-                            ? c.memoizedProps
-                            : fg(b.type, c.memoizedProps);
-                        d.componentDidUpdate(
-                          e,
-                          c.memoizedState,
-                          d.__reactInternalSnapshotBeforeUpdate
-                        );
-                      }
-                    var f = b.updateQueue;
-                    f !== null && Ag(b, f, d);
-                    break;
-                  case 3:
-                    var g = b.updateQueue;
-                    if (g !== null) {
-                      c = null;
-                      if (b.child !== null)
-                        switch (b.child.tag) {
-                          case 5:
-                            c = b.child.stateNode;
-                            break;
-                          case 1:
-                            c = b.child.stateNode;
-                        }
-                      Ag(b, g, c);
-                    }
-                    break;
-                  case 5:
-                    var h = b.stateNode;
-                    if (c === null && b.flags & 4) {
-                      c = h;
-                      var k = b.memoizedProps;
-                      switch (b.type) {
-                        case "button":
-                        case "input":
-                        case "select":
-                        case "textarea":
-                          k.autoFocus && c.focus();
-                          break;
-                        case "img":
-                          k.src && (c.src = k.src);
-                      }
-                    }
-                    break;
-                  case 6:
-                    break;
-                  case 4:
-                    break;
-                  case 12:
-                    break;
-                  case 13:
-                    if (b.memoizedState === null) {
-                      var l2 = b.alternate;
-                      if (l2 !== null) {
-                        var m = l2.memoizedState;
-                        if (m !== null) {
-                          var w2 = m.dehydrated;
-                          w2 !== null && Yc(w2);
-                        }
-                      }
-                    }
-                    break;
-                  case 19:
-                  case 17:
-                  case 21:
-                  case 22:
-                  case 23:
-                    break;
-                  default:
-                    throw Error(p$1(163));
-                }
-              zj || (b.flags & 512 && Ij(b));
-            } catch (u2) {
-              Cj(b, b.return, u2);
-            }
-          }
-          if (b === a) {
-            X = null;
-            break;
-          }
-          c = b.sibling;
-          if (c !== null) {
-            c.return = b.return;
-            X = c;
-            break;
-          }
-          X = b.return;
-        }
-      }
-      function Wj(a) {
-        for (; X !== null; ) {
-          var b = X;
-          if (b === a) {
-            X = null;
-            break;
-          }
-          var c = b.sibling;
-          if (c !== null) {
-            c.return = b.return;
-            X = c;
-            break;
-          }
-          X = b.return;
-        }
-      }
-      function Zj(a) {
-        for (; X !== null; ) {
-          var b = X;
-          try {
-            switch (b.tag) {
-              case 0:
-              case 11:
-              case 15:
-                var c = b.return;
-                try {
-                  Hj(4, b);
-                } catch (k) {
-                  Cj(b, c, k);
-                }
-                break;
-              case 1:
-                var d = b.stateNode;
-                if (typeof d.componentDidMount === "function") {
-                  var e = b.return;
-                  try {
-                    d.componentDidMount();
-                  } catch (k) {
-                    Cj(b, e, k);
-                  }
-                }
-                var f = b.return;
-                try {
-                  Ij(b);
-                } catch (k) {
-                  Cj(b, f, k);
-                }
-                break;
-              case 5:
-                var g = b.return;
-                try {
-                  Ij(b);
-                } catch (k) {
-                  Cj(b, g, k);
-                }
-            }
-          } catch (k) {
-            Cj(b, b.return, k);
-          }
-          if (b === a) {
-            X = null;
-            break;
-          }
-          var h = b.sibling;
-          if (h !== null) {
-            h.return = b.return;
-            X = h;
-            break;
-          }
-          X = b.return;
-        }
-      }
-      var bk = Math.ceil,
-        ck = sa.ReactCurrentDispatcher,
-        dk = sa.ReactCurrentOwner,
-        ek = sa.ReactCurrentBatchConfig,
-        K = 0,
-        J = null,
-        Y = null,
-        Z = 0,
-        Vi = 0,
-        ej = Of(0),
-        W = 0,
-        fk = null,
-        zg = 0,
-        gk = 0,
-        hk = 0,
-        ik = null,
-        jk = null,
-        Vj = 0,
-        Ti = Infinity,
-        Di = false,
-        Ei = null,
-        Gi = null,
-        kk = false,
-        lk = null,
-        mk = 0,
-        nk = 0,
-        ok = null,
-        pk = -1,
-        qk = 0;
-      function M() {
-        return (K & 6) !== 0 ? D() : pk !== -1 ? pk : (pk = D());
-      }
-      function Dg(a) {
-        if ((a.mode & 1) === 0) return 1;
-        if ((K & 2) !== 0 && Z !== 0) return Z & -Z;
-        if (eg$1.transition !== null)
-          return (
-            qk === 0 &&
-              ((a = oc),
-              (oc <<= 1),
-              (oc & 4194240) === 0 && (oc = 64),
-              (qk = a)),
-            qk
-          );
-        a = E;
-        if (a !== 0) return a;
-        a = window.event;
-        a = a === void 0 ? 16 : ed(a.type);
-        return a;
-      }
-      function Eg(a, b, c) {
-        if (50 < nk) throw ((nk = 0), (ok = null), Error(p$1(185)));
-        var d = rk(a, b);
-        if (d === null) return null;
-        wc(d, b, c);
-        if ((K & 2) === 0 || d !== J)
-          d === J && ((K & 2) === 0 && (gk |= b), W === 4 && sk(d, Z)),
-            tk(d, c),
-            b === 1 &&
-              K === 0 &&
-              (a.mode & 1) === 0 &&
-              ((Ti = D() + 500), $f && dg());
-        return d;
-      }
-      function rk(a, b) {
-        a.lanes |= b;
-        var c = a.alternate;
-        c !== null && (c.lanes |= b);
-        c = a;
-        for (a = a.return; a !== null; )
-          (a.childLanes |= b),
-            (c = a.alternate),
-            c !== null && (c.childLanes |= b),
-            (c = a),
-            (a = a.return);
-        return c.tag === 3 ? c.stateNode : null;
-      }
-      function tk(a, b) {
-        var c = a.callbackNode;
-        tc(a, b);
-        var d = rc(a, a === J ? Z : 0);
-        if (d === 0)
-          c !== null && Zb(c),
-            (a.callbackNode = null),
-            (a.callbackPriority = 0);
-        else if (((b = d & -d), a.callbackPriority !== b)) {
-          c != null && Zb(c);
-          if (b === 1)
-            a.tag === 0 ? cg(uk.bind(null, a)) : bg(uk.bind(null, a)),
-              Df(function () {
-                K === 0 && dg();
-              }),
-              (c = null);
-          else {
-            switch (zc(d)) {
-              case 1:
-                c = cc;
-                break;
-              case 4:
-                c = dc;
-                break;
-              case 16:
-                c = ec;
-                break;
-              case 536870912:
-                c = gc;
-                break;
-              default:
-                c = ec;
-            }
-            c = vk(c, wk.bind(null, a));
-          }
-          a.callbackPriority = b;
-          a.callbackNode = c;
-        }
-      }
-      function wk(a, b) {
-        pk = -1;
-        qk = 0;
-        if ((K & 6) !== 0) throw Error(p$1(327));
-        var c = a.callbackNode;
-        if (xk() && a.callbackNode !== c) return null;
-        var d = rc(a, a === J ? Z : 0);
-        if (d === 0) return null;
-        if ((d & 30) !== 0 || (d & a.expiredLanes) !== 0 || b) b = yk(a, d);
-        else {
-          b = d;
-          var e = K;
-          K |= 2;
-          var f = zk();
-          if (J !== a || Z !== b) (Ti = D() + 500), Ak(a, b);
-          do
-            try {
-              Bk();
-              break;
-            } catch (h) {
-              Ck(a, h);
-            }
-          while (1);
-          kg();
-          ck.current = f;
-          K = e;
-          Y !== null ? (b = 0) : ((J = null), (Z = 0), (b = W));
-        }
-        if (b !== 0) {
-          b === 2 && ((e = uc(a)), e !== 0 && ((d = e), (b = Dk(a, e))));
-          if (b === 1) throw ((c = fk), Ak(a, 0), sk(a, d), tk(a, D()), c);
-          if (b === 6) sk(a, d);
-          else {
-            e = a.current.alternate;
-            if (
-              (d & 30) === 0 &&
-              !Ek(e) &&
-              ((b = yk(a, d)),
-              b === 2 && ((f = uc(a)), f !== 0 && ((d = f), (b = Dk(a, f)))),
-              b === 1)
-            )
-              throw ((c = fk), Ak(a, 0), sk(a, d), tk(a, D()), c);
-            a.finishedWork = e;
-            a.finishedLanes = d;
-            switch (b) {
-              case 0:
-              case 1:
-                throw Error(p$1(345));
-              case 2:
-                Fk(a, jk);
-                break;
-              case 3:
-                sk(a, d);
-                if ((d & 130023424) === d && ((b = Vj + 500 - D()), 10 < b)) {
-                  if (rc(a, 0) !== 0) break;
-                  e = a.suspendedLanes;
-                  if ((e & d) !== d) {
-                    M();
-                    a.pingedLanes |= a.suspendedLanes & e;
-                    break;
-                  }
-                  a.timeoutHandle = zf(Fk.bind(null, a, jk), b);
-                  break;
-                }
-                Fk(a, jk);
-                break;
-              case 4:
-                sk(a, d);
-                if ((d & 4194240) === d) break;
-                b = a.eventTimes;
-                for (e = -1; 0 < d; ) {
-                  var g = 31 - lc(d);
-                  f = 1 << g;
-                  g = b[g];
-                  g > e && (e = g);
-                  d &= ~f;
-                }
-                d = e;
-                d = D() - d;
-                d =
-                  (120 > d
-                    ? 120
-                    : 480 > d
-                    ? 480
-                    : 1080 > d
-                    ? 1080
-                    : 1920 > d
-                    ? 1920
-                    : 3e3 > d
-                    ? 3e3
-                    : 4320 > d
-                    ? 4320
-                    : 1960 * bk(d / 1960)) - d;
-                if (10 < d) {
-                  a.timeoutHandle = zf(Fk.bind(null, a, jk), d);
-                  break;
-                }
-                Fk(a, jk);
-                break;
-              case 5:
-                Fk(a, jk);
-                break;
-              default:
-                throw Error(p$1(329));
-            }
-          }
-        }
-        tk(a, D());
-        return a.callbackNode === c ? wk.bind(null, a) : null;
-      }
-      function Dk(a, b) {
-        var c = ik;
-        a.current.memoizedState.isDehydrated && (Ak(a, b).flags |= 256);
-        a = yk(a, b);
-        a !== 2 && ((b = jk), (jk = c), b !== null && Ri(b));
-        return a;
-      }
-      function Ri(a) {
-        jk === null ? (jk = a) : jk.push.apply(jk, a);
-      }
-      function Ek(a) {
-        for (var b = a; ; ) {
-          if (b.flags & 16384) {
-            var c = b.updateQueue;
-            if (c !== null && ((c = c.stores), c !== null))
-              for (var d = 0; d < c.length; d++) {
-                var e = c[d],
-                  f = e.getSnapshot;
-                e = e.value;
-                try {
-                  if (!Ce(f(), e)) return false;
-                } catch (g) {
-                  return false;
-                }
-              }
-          }
-          c = b.child;
-          if (b.subtreeFlags & 16384 && c !== null) (c.return = b), (b = c);
-          else {
-            if (b === a) break;
-            for (; b.sibling === null; ) {
-              if (b.return === null || b.return === a) return true;
-              b = b.return;
-            }
-            b.sibling.return = b.return;
-            b = b.sibling;
-          }
-        }
-        return true;
-      }
-      function sk(a, b) {
-        b &= ~hk;
-        b &= ~gk;
-        a.suspendedLanes |= b;
-        a.pingedLanes &= ~b;
-        for (a = a.expirationTimes; 0 < b; ) {
-          var c = 31 - lc(b),
-            d = 1 << c;
-          a[c] = -1;
-          b &= ~d;
-        }
-      }
-      function uk(a) {
-        if ((K & 6) !== 0) throw Error(p$1(327));
-        xk();
-        var b = rc(a, 0);
-        if ((b & 1) === 0) return tk(a, D()), null;
-        var c = yk(a, b);
-        if (a.tag !== 0 && c === 2) {
-          var d = uc(a);
-          d !== 0 && ((b = d), (c = Dk(a, d)));
-        }
-        if (c === 1) throw ((c = fk), Ak(a, 0), sk(a, b), tk(a, D()), c);
-        if (c === 6) throw Error(p$1(345));
-        a.finishedWork = a.current.alternate;
-        a.finishedLanes = b;
-        Fk(a, jk);
-        tk(a, D());
-        return null;
-      }
-      function Gk(a, b) {
-        var c = K;
-        K |= 1;
-        try {
-          return a(b);
-        } finally {
-          (K = c), K === 0 && ((Ti = D() + 500), $f && dg());
-        }
-      }
-      function Hk(a) {
-        lk !== null && lk.tag === 0 && (K & 6) === 0 && xk();
-        var b = K;
-        K |= 1;
-        var c = ek.transition,
-          d = E;
-        try {
-          if (((ek.transition = null), (E = 1), a)) return a();
-        } finally {
-          (E = d), (ek.transition = c), (K = b), (K & 6) === 0 && dg();
-        }
-      }
-      function Ui() {
-        Vi = ej.current;
-        G(ej);
-      }
-      function Ak(a, b) {
-        a.finishedWork = null;
-        a.finishedLanes = 0;
-        var c = a.timeoutHandle;
-        c !== -1 && ((a.timeoutHandle = -1), Af(c));
-        if (Y !== null)
-          for (c = Y.return; c !== null; ) {
-            var d = c;
-            Wg(d);
-            switch (d.tag) {
-              case 1:
-                d = d.type.childContextTypes;
-                d !== null && d !== void 0 && Uf();
-                break;
-              case 3:
-                zh();
-                G(Qf);
-                G(I);
-                Eh();
-                break;
-              case 5:
-                Bh(d);
-                break;
-              case 4:
-                zh();
-                break;
-              case 13:
-                G(P);
-                break;
-              case 19:
-                G(P);
-                break;
-              case 10:
-                lg$1(d.type._context);
-                break;
-              case 22:
-              case 23:
-                Ui();
-            }
-            c = c.return;
-          }
-        J = a;
-        Y = a = mh(a.current, null);
-        Z = Vi = b;
-        W = 0;
-        fk = null;
-        hk = gk = zg = 0;
-        jk = ik = null;
-        if (qg !== null) {
-          for (b = 0; b < qg.length; b++)
-            if (((c = qg[b]), (d = c.interleaved), d !== null)) {
-              c.interleaved = null;
-              var e = d.next,
-                f = c.pending;
-              if (f !== null) {
-                var g = f.next;
-                f.next = e;
-                d.next = g;
-              }
-              c.pending = d;
-            }
-          qg = null;
-        }
-        return a;
-      }
-      function Ck(a, b) {
-        do {
-          var c = Y;
-          try {
-            kg();
-            Fh.current = Rh;
-            if (Ih) {
-              for (var d = Q.memoizedState; d !== null; ) {
-                var e = d.queue;
-                e !== null && (e.pending = null);
-                d = d.next;
-              }
-              Ih = false;
-            }
-            Hh = 0;
-            S = R = Q = null;
-            Jh = false;
-            Kh = 0;
-            dk.current = null;
-            if (c === null || c.return === null) {
-              W = 1;
-              fk = b;
-              Y = null;
-              break;
-            }
-            a: {
-              var f = a,
-                g = c.return,
-                h = c,
-                k = b;
-              b = Z;
-              h.flags |= 32768;
-              if (
-                k !== null &&
-                typeof k === "object" &&
-                typeof k.then === "function"
-              ) {
-                var l2 = k,
-                  m = h,
-                  w2 = m.tag;
-                if (
-                  (m.mode & 1) === 0 &&
-                  (w2 === 0 || w2 === 11 || w2 === 15)
-                ) {
-                  var u2 = m.alternate;
-                  u2
-                    ? ((m.updateQueue = u2.updateQueue),
-                      (m.memoizedState = u2.memoizedState),
-                      (m.lanes = u2.lanes))
-                    : ((m.updateQueue = null), (m.memoizedState = null));
-                }
-                var y2 = Ji(g);
-                if (y2 !== null) {
-                  y2.flags &= -257;
-                  Ki(y2, g, h, f, b);
-                  y2.mode & 1 && Hi(f, l2, b);
-                  b = y2;
-                  k = l2;
-                  var n2 = b.updateQueue;
-                  if (n2 === null) {
-                    var v2 = /* @__PURE__ */ new Set();
-                    v2.add(k);
-                    b.updateQueue = v2;
-                  } else n2.add(k);
-                  break a;
-                } else {
-                  if ((b & 1) === 0) {
-                    Hi(f, l2, b);
-                    Si();
-                    break a;
-                  }
-                  k = Error(p$1(426));
-                }
-              } else if (N && h.mode & 1) {
-                var C2 = Ji(g);
-                if (C2 !== null) {
-                  (C2.flags & 65536) === 0 && (C2.flags |= 256);
-                  Ki(C2, g, h, f, b);
-                  hh(k);
-                  break a;
-                }
-              }
-              f = k;
-              W !== 4 && (W = 2);
-              ik === null ? (ik = [f]) : ik.push(f);
-              k = zi(k, h);
-              h = g;
-              do {
-                switch (h.tag) {
-                  case 3:
-                    h.flags |= 65536;
-                    b &= -b;
-                    h.lanes |= b;
-                    var t2 = Ci(h, k, b);
-                    xg(h, t2);
-                    break a;
-                  case 1:
-                    f = k;
-                    var r2 = h.type,
-                      x2 = h.stateNode;
-                    if (
-                      (h.flags & 128) === 0 &&
-                      (typeof r2.getDerivedStateFromError === "function" ||
-                        (x2 !== null &&
-                          typeof x2.componentDidCatch === "function" &&
-                          (Gi === null || !Gi.has(x2))))
-                    ) {
-                      h.flags |= 65536;
-                      b &= -b;
-                      h.lanes |= b;
-                      var B2 = Fi(h, f, b);
-                      xg(h, B2);
-                      break a;
-                    }
-                }
-                h = h.return;
-              } while (h !== null);
-            }
-            Ik(c);
-          } catch (O2) {
-            b = O2;
-            Y === c && c !== null && (Y = c = c.return);
-            continue;
-          }
-          break;
-        } while (1);
-      }
-      function zk() {
-        var a = ck.current;
-        ck.current = Rh;
-        return a === null ? Rh : a;
-      }
-      function Si() {
-        if (W === 0 || W === 3 || W === 2) W = 4;
-        J === null ||
-          ((zg & 268435455) === 0 && (gk & 268435455) === 0) ||
-          sk(J, Z);
-      }
-      function yk(a, b) {
-        var c = K;
-        K |= 2;
-        var d = zk();
-        (J === a && Z === b) || Ak(a, b);
-        do
-          try {
-            Jk();
-            break;
-          } catch (e) {
-            Ck(a, e);
-          }
-        while (1);
-        kg();
-        K = c;
-        ck.current = d;
-        if (Y !== null) throw Error(p$1(261));
-        J = null;
-        Z = 0;
-        return W;
-      }
-      function Jk() {
-        for (; Y !== null; ) Kk(Y);
-      }
-      function Bk() {
-        for (; Y !== null && !$b(); ) Kk(Y);
-      }
-      function Kk(a) {
-        var b = Lk(a.alternate, a, Vi);
-        a.memoizedProps = a.pendingProps;
-        b === null ? Ik(a) : (Y = b);
-        dk.current = null;
-      }
-      function Ik(a) {
-        var b = a;
-        do {
-          var c = b.alternate;
-          a = b.return;
-          if ((b.flags & 32768) === 0) {
-            if (((c = Qi(c, b, Vi)), c !== null)) {
-              Y = c;
-              return;
-            }
-          } else {
-            c = xj(c, b);
-            if (c !== null) {
-              c.flags &= 32767;
-              Y = c;
-              return;
-            }
-            if (a !== null)
-              (a.flags |= 32768), (a.subtreeFlags = 0), (a.deletions = null);
-            else {
-              W = 6;
-              Y = null;
-              return;
-            }
-          }
-          b = b.sibling;
-          if (b !== null) {
-            Y = b;
-            return;
-          }
-          Y = b = a;
-        } while (b !== null);
-        W === 0 && (W = 5);
-      }
-      function Fk(a, b) {
-        var c = E,
-          d = ek.transition;
-        try {
-          (ek.transition = null), (E = 1), Mk(a, b, c);
-        } finally {
-          (ek.transition = d), (E = c);
-        }
-        return null;
-      }
-      function Mk(a, b, c) {
-        do xk();
-        while (lk !== null);
-        if ((K & 6) !== 0) throw Error(p$1(327));
-        var d = a.finishedWork,
-          e = a.finishedLanes;
-        if (d === null) return null;
-        a.finishedWork = null;
-        a.finishedLanes = 0;
-        if (d === a.current) throw Error(p$1(177));
-        a.callbackNode = null;
-        a.callbackPriority = 0;
-        var f = d.lanes | d.childLanes;
-        xc(a, f);
-        a === J && ((Y = J = null), (Z = 0));
-        ((d.subtreeFlags & 2064) === 0 && (d.flags & 2064) === 0) ||
-          kk ||
-          ((kk = true),
-          vk(ec, function () {
-            xk();
-            return null;
-          }));
-        f = (d.flags & 15990) !== 0;
-        if ((d.subtreeFlags & 15990) !== 0 || f) {
-          f = ek.transition;
-          ek.transition = null;
-          var g = E;
-          E = 1;
-          var h = K;
-          K |= 4;
-          dk.current = null;
-          Fj(a, d);
-          Uj(a, d);
-          Je(xf);
-          xf = null;
-          a.current = d;
-          Xj(d);
-          ac$1();
-          K = h;
-          E = g;
-          ek.transition = f;
-        } else a.current = d;
-        kk && ((kk = false), (lk = a), (mk = e));
-        f = a.pendingLanes;
-        f === 0 && (Gi = null);
-        jc(d.stateNode);
-        tk(a, D());
-        if (b !== null)
-          for (c = a.onRecoverableError, d = 0; d < b.length; d++) c(b[d]);
-        if (Di) throw ((Di = false), (a = Ei), (Ei = null), a);
-        (mk & 1) !== 0 && a.tag !== 0 && xk();
-        f = a.pendingLanes;
-        (f & 1) !== 0 ? (a === ok ? nk++ : ((nk = 0), (ok = a))) : (nk = 0);
-        dg();
-        return null;
-      }
-      function xk() {
-        if (lk !== null) {
-          var a = zc(mk),
-            b = ek.transition,
-            c = E;
-          try {
-            ek.transition = null;
-            E = 16 > a ? 16 : a;
-            if (lk === null) var d = false;
-            else {
-              a = lk;
-              lk = null;
-              mk = 0;
-              if ((K & 6) !== 0) throw Error(p$1(331));
-              var e = K;
-              K |= 4;
-              for (X = a.current; X !== null; ) {
-                var f = X,
-                  g = f.child;
-                if ((X.flags & 16) !== 0) {
-                  var h = f.deletions;
-                  if (h !== null) {
-                    for (var k = 0; k < h.length; k++) {
-                      var l2 = h[k];
-                      for (X = l2; X !== null; ) {
-                        var m = X;
-                        switch (m.tag) {
-                          case 0:
-                          case 11:
-                          case 15:
-                            Gj(8, m, f);
-                        }
-                        var w2 = m.child;
-                        if (w2 !== null) (w2.return = m), (X = w2);
-                        else
-                          for (; X !== null; ) {
-                            m = X;
-                            var u2 = m.sibling,
-                              y2 = m.return;
-                            Lj(m);
-                            if (m === l2) {
-                              X = null;
-                              break;
-                            }
-                            if (u2 !== null) {
-                              u2.return = y2;
-                              X = u2;
-                              break;
-                            }
-                            X = y2;
-                          }
-                      }
-                    }
-                    var n2 = f.alternate;
-                    if (n2 !== null) {
-                      var v2 = n2.child;
-                      if (v2 !== null) {
-                        n2.child = null;
-                        do {
-                          var C2 = v2.sibling;
-                          v2.sibling = null;
-                          v2 = C2;
-                        } while (v2 !== null);
-                      }
-                    }
-                    X = f;
-                  }
-                }
-                if ((f.subtreeFlags & 2064) !== 0 && g !== null)
-                  (g.return = f), (X = g);
-                else
-                  b: for (; X !== null; ) {
-                    f = X;
-                    if ((f.flags & 2048) !== 0)
-                      switch (f.tag) {
-                        case 0:
-                        case 11:
-                        case 15:
-                          Gj(9, f, f.return);
-                      }
-                    var t2 = f.sibling;
-                    if (t2 !== null) {
-                      t2.return = f.return;
-                      X = t2;
-                      break b;
-                    }
-                    X = f.return;
-                  }
-              }
-              var r2 = a.current;
-              for (X = r2; X !== null; ) {
-                g = X;
-                var x2 = g.child;
-                if ((g.subtreeFlags & 2064) !== 0 && x2 !== null)
-                  (x2.return = g), (X = x2);
-                else
-                  b: for (g = r2; X !== null; ) {
-                    h = X;
-                    if ((h.flags & 2048) !== 0)
-                      try {
-                        switch (h.tag) {
-                          case 0:
-                          case 11:
-                          case 15:
-                            Hj(9, h);
-                        }
-                      } catch (O2) {
-                        Cj(h, h.return, O2);
-                      }
-                    if (h === g) {
-                      X = null;
-                      break b;
-                    }
-                    var B2 = h.sibling;
-                    if (B2 !== null) {
-                      B2.return = h.return;
-                      X = B2;
-                      break b;
-                    }
-                    X = h.return;
-                  }
-              }
-              K = e;
-              dg();
-              if (ic$1 && typeof ic$1.onPostCommitFiberRoot === "function")
-                try {
-                  ic$1.onPostCommitFiberRoot(hc, a);
-                } catch (O2) {}
-              d = true;
-            }
-            return d;
-          } finally {
-            (E = c), (ek.transition = b);
-          }
-        }
-        return false;
-      }
-      function Nk(a, b, c) {
-        b = zi(c, b);
-        b = Ci(a, b, 1);
-        vg(a, b);
-        b = M();
-        a = rk(a, 1);
-        a !== null && (wc(a, 1, b), tk(a, b));
-      }
-      function Cj(a, b, c) {
-        if (a.tag === 3) Nk(a, a, c);
-        else
-          for (; b !== null; ) {
-            if (b.tag === 3) {
-              Nk(b, a, c);
-              break;
-            } else if (b.tag === 1) {
-              var d = b.stateNode;
-              if (
-                typeof b.type.getDerivedStateFromError === "function" ||
-                (typeof d.componentDidCatch === "function" &&
-                  (Gi === null || !Gi.has(d)))
-              ) {
-                a = zi(c, a);
-                a = Fi(b, a, 1);
-                vg(b, a);
-                a = M();
-                b = rk(b, 1);
-                b !== null && (wc(b, 1, a), tk(b, a));
-                break;
-              }
-            }
-            b = b.return;
-          }
-      }
-      function Ii(a, b, c) {
-        var d = a.pingCache;
-        d !== null && d.delete(b);
-        b = M();
-        a.pingedLanes |= a.suspendedLanes & c;
-        J === a &&
-          (Z & c) === c &&
-          (W === 4 || (W === 3 && (Z & 130023424) === Z && 500 > D() - Vj)
-            ? Ak(a, 0)
-            : (hk |= c));
-        tk(a, b);
-      }
-      function Ok(a, b) {
-        b === 0 &&
-          ((a.mode & 1) === 0
-            ? (b = 1)
-            : ((b = pc), (pc <<= 1), (pc & 130023424) === 0 && (pc = 4194304)));
-        var c = M();
-        a = rk(a, b);
-        a !== null && (wc(a, b, c), tk(a, c));
-      }
-      function qj(a) {
-        var b = a.memoizedState,
-          c = 0;
-        b !== null && (c = b.retryLane);
-        Ok(a, c);
-      }
-      function Tj(a, b) {
-        var c = 0;
-        switch (a.tag) {
-          case 13:
-            var d = a.stateNode;
-            var e = a.memoizedState;
-            e !== null && (c = e.retryLane);
-            break;
-          case 19:
-            d = a.stateNode;
-            break;
-          default:
-            throw Error(p$1(314));
-        }
-        d !== null && d.delete(b);
-        Ok(a, c);
-      }
-      var Lk;
-      Lk = function (a, b, c) {
-        if (a !== null)
-          if (a.memoizedProps !== b.pendingProps || Qf.current) og = true;
-          else {
-            if ((a.lanes & c) === 0 && (b.flags & 128) === 0)
-              return (og = false), wj(a, b, c);
-            og = (a.flags & 131072) !== 0 ? true : false;
-          }
-        else (og = false), N && (b.flags & 1048576) !== 0 && Ug(b, Ng, b.index);
-        b.lanes = 0;
-        switch (b.tag) {
-          case 2:
-            var d = b.type;
-            a !== null &&
-              ((a.alternate = null), (b.alternate = null), (b.flags |= 2));
-            a = b.pendingProps;
-            var e = Sf(b, I.current);
-            ng(b, c);
-            e = Nh(null, b, d, a, e, c);
-            var f = Sh();
-            b.flags |= 1;
-            typeof e === "object" &&
-            e !== null &&
-            typeof e.render === "function" &&
-            e.$$typeof === void 0
-              ? ((b.tag = 1),
-                (b.memoizedState = null),
-                (b.updateQueue = null),
-                Tf(d) ? ((f = true), Xf(b)) : (f = false),
-                (b.memoizedState =
-                  e.state !== null && e.state !== void 0 ? e.state : null),
-                sg(b),
-                (e.updater = Fg),
-                (b.stateNode = e),
-                (e._reactInternals = b),
-                Jg(b, d, a, c),
-                (b = hj(null, b, d, true, f, c)))
-              : ((b.tag = 0),
-                N && f && Vg(b),
-                Xi$1(null, b, e, c),
-                (b = b.child));
-            return b;
-          case 16:
-            d = b.elementType;
-            a: {
-              a !== null &&
-                ((a.alternate = null), (b.alternate = null), (b.flags |= 2));
-              a = b.pendingProps;
-              e = d._init;
-              d = e(d._payload);
-              b.type = d;
-              e = b.tag = Pk(d);
-              a = fg(d, a);
-              switch (e) {
-                case 0:
-                  b = cj(null, b, d, a, c);
-                  break a;
-                case 1:
-                  b = gj(null, b, d, a, c);
-                  break a;
-                case 11:
-                  b = Yi(null, b, d, a, c);
-                  break a;
-                case 14:
-                  b = $i(null, b, d, fg(d.type, a), c);
-                  break a;
-              }
-              throw Error(p$1(306, d, ""));
-            }
-            return b;
-          case 0:
-            return (
-              (d = b.type),
-              (e = b.pendingProps),
-              (e = b.elementType === d ? e : fg(d, e)),
-              cj(a, b, d, e, c)
-            );
-          case 1:
-            return (
-              (d = b.type),
-              (e = b.pendingProps),
-              (e = b.elementType === d ? e : fg(d, e)),
-              gj(a, b, d, e, c)
-            );
-          case 3:
-            a: {
-              ij(b);
-              if (a === null) throw Error(p$1(387));
-              d = b.pendingProps;
-              f = b.memoizedState;
-              e = f.element;
-              tg(a, b);
-              yg(b, d, null, c);
-              var g = b.memoizedState;
-              d = g.element;
-              if (f.isDehydrated)
-                if (
-                  ((f = {
-                    element: d,
-                    isDehydrated: false,
-                    cache: g.cache,
-                    transitions: g.transitions,
-                  }),
-                  (b.updateQueue.baseState = f),
-                  (b.memoizedState = f),
-                  b.flags & 256)
-                ) {
-                  e = Error(p$1(423));
-                  b = jj(a, b, d, c, e);
-                  break a;
-                } else if (d !== e) {
-                  e = Error(p$1(424));
-                  b = jj(a, b, d, c, e);
-                  break a;
-                } else
-                  for (
-                    Yg = Ff(b.stateNode.containerInfo.firstChild),
-                      Xg = b,
-                      N = true,
-                      Zg = null,
-                      c = sh(b, null, d, c),
-                      b.child = c;
-                    c;
-
-                  )
-                    (c.flags = (c.flags & -3) | 4096), (c = c.sibling);
-              else {
-                gh();
-                if (d === e) {
-                  b = Zi(a, b, c);
-                  break a;
-                }
-                Xi$1(a, b, d, c);
-              }
-              b = b.child;
-            }
-            return b;
-          case 5:
-            return (
-              Ah(b),
-              a === null && dh(b),
-              (d = b.type),
-              (e = b.pendingProps),
-              (f = a !== null ? a.memoizedProps : null),
-              (g = e.children),
-              yf(d, e) ? (g = null) : f !== null && yf(d, f) && (b.flags |= 32),
-              fj(a, b),
-              Xi$1(a, b, g, c),
-              b.child
-            );
-          case 6:
-            return a === null && dh(b), null;
-          case 13:
-            return mj(a, b, c);
-          case 4:
-            return (
-              yh(b, b.stateNode.containerInfo),
-              (d = b.pendingProps),
-              a === null ? (b.child = rh(b, null, d, c)) : Xi$1(a, b, d, c),
-              b.child
-            );
-          case 11:
-            return (
-              (d = b.type),
-              (e = b.pendingProps),
-              (e = b.elementType === d ? e : fg(d, e)),
-              Yi(a, b, d, e, c)
-            );
-          case 7:
-            return Xi$1(a, b, b.pendingProps, c), b.child;
-          case 8:
-            return Xi$1(a, b, b.pendingProps.children, c), b.child;
-          case 12:
-            return Xi$1(a, b, b.pendingProps.children, c), b.child;
-          case 10:
-            a: {
-              d = b.type._context;
-              e = b.pendingProps;
-              f = b.memoizedProps;
-              g = e.value;
-              H(gg$1, d._currentValue);
-              d._currentValue = g;
-              if (f !== null)
-                if (Ce(f.value, g)) {
-                  if (f.children === e.children && !Qf.current) {
-                    b = Zi(a, b, c);
-                    break a;
-                  }
-                } else
-                  for (
-                    f = b.child, f !== null && (f.return = b);
-                    f !== null;
-
-                  ) {
-                    var h = f.dependencies;
-                    if (h !== null) {
-                      g = f.child;
-                      for (var k = h.firstContext; k !== null; ) {
-                        if (k.context === d) {
-                          if (f.tag === 1) {
-                            k = ug(-1, c & -c);
-                            k.tag = 2;
-                            var l2 = f.updateQueue;
-                            if (l2 !== null) {
-                              l2 = l2.shared;
-                              var m = l2.pending;
-                              m === null
-                                ? (k.next = k)
-                                : ((k.next = m.next), (m.next = k));
-                              l2.pending = k;
-                            }
-                          }
-                          f.lanes |= c;
-                          k = f.alternate;
-                          k !== null && (k.lanes |= c);
-                          mg(f.return, c, b);
-                          h.lanes |= c;
-                          break;
-                        }
-                        k = k.next;
-                      }
-                    } else if (f.tag === 10)
-                      g = f.type === b.type ? null : f.child;
-                    else if (f.tag === 18) {
-                      g = f.return;
-                      if (g === null) throw Error(p$1(341));
-                      g.lanes |= c;
-                      h = g.alternate;
-                      h !== null && (h.lanes |= c);
-                      mg(g, c, b);
-                      g = f.sibling;
-                    } else g = f.child;
-                    if (g !== null) g.return = f;
-                    else
-                      for (g = f; g !== null; ) {
-                        if (g === b) {
-                          g = null;
-                          break;
-                        }
-                        f = g.sibling;
-                        if (f !== null) {
-                          f.return = g.return;
-                          g = f;
-                          break;
-                        }
-                        g = g.return;
-                      }
-                    f = g;
-                  }
-              Xi$1(a, b, e.children, c);
-              b = b.child;
-            }
-            return b;
-          case 9:
-            return (
-              (e = b.type),
-              (d = b.pendingProps.children),
-              ng(b, c),
-              (e = pg(e)),
-              (d = d(e)),
-              (b.flags |= 1),
-              Xi$1(a, b, d, c),
-              b.child
-            );
-          case 14:
-            return (
-              (d = b.type),
-              (e = fg(d, b.pendingProps)),
-              (e = fg(d.type, e)),
-              $i(a, b, d, e, c)
-            );
-          case 15:
-            return bj(a, b, b.type, b.pendingProps, c);
-          case 17:
-            return (
-              (d = b.type),
-              (e = b.pendingProps),
-              (e = b.elementType === d ? e : fg(d, e)),
-              a !== null &&
-                ((a.alternate = null), (b.alternate = null), (b.flags |= 2)),
-              (b.tag = 1),
-              Tf(d) ? ((a = true), Xf(b)) : (a = false),
-              ng(b, c),
-              Hg(b, d, e),
-              Jg(b, d, e, c),
-              hj(null, b, d, true, a, c)
-            );
-          case 19:
-            return vj(a, b, c);
-          case 22:
-            return dj(a, b, c);
-        }
-        throw Error(p$1(156, b.tag));
-      };
-      function vk(a, b) {
-        return Yb(a, b);
-      }
-      function Qk(a, b, c, d) {
-        this.tag = a;
-        this.key = c;
-        this.sibling =
-          this.child =
-          this.return =
-          this.stateNode =
-          this.type =
-          this.elementType =
-            null;
-        this.index = 0;
-        this.ref = null;
-        this.pendingProps = b;
-        this.dependencies =
-          this.memoizedState =
-          this.updateQueue =
-          this.memoizedProps =
-            null;
-        this.mode = d;
-        this.subtreeFlags = this.flags = 0;
-        this.deletions = null;
-        this.childLanes = this.lanes = 0;
-        this.alternate = null;
-      }
-      function ah(a, b, c, d) {
-        return new Qk(a, b, c, d);
-      }
-      function aj(a) {
-        a = a.prototype;
-        return !(!a || !a.isReactComponent);
-      }
-      function Pk(a) {
-        if (typeof a === "function") return aj(a) ? 1 : 0;
-        if (a !== void 0 && a !== null) {
-          a = a.$$typeof;
-          if (a === Ba) return 11;
-          if (a === Ea) return 14;
-        }
-        return 2;
-      }
-      function mh(a, b) {
-        var c = a.alternate;
-        c === null
-          ? ((c = ah(a.tag, b, a.key, a.mode)),
-            (c.elementType = a.elementType),
-            (c.type = a.type),
-            (c.stateNode = a.stateNode),
-            (c.alternate = a),
-            (a.alternate = c))
-          : ((c.pendingProps = b),
-            (c.type = a.type),
-            (c.flags = 0),
-            (c.subtreeFlags = 0),
-            (c.deletions = null));
-        c.flags = a.flags & 14680064;
-        c.childLanes = a.childLanes;
-        c.lanes = a.lanes;
-        c.child = a.child;
-        c.memoizedProps = a.memoizedProps;
-        c.memoizedState = a.memoizedState;
-        c.updateQueue = a.updateQueue;
-        b = a.dependencies;
-        c.dependencies =
-          b === null ? null : { lanes: b.lanes, firstContext: b.firstContext };
-        c.sibling = a.sibling;
-        c.index = a.index;
-        c.ref = a.ref;
-        return c;
-      }
-      function oh(a, b, c, d, e, f) {
-        var g = 2;
-        d = a;
-        if (typeof a === "function") aj(a) && (g = 1);
-        else if (typeof a === "string") g = 5;
-        else
-          a: switch (a) {
-            case va:
-              return qh(c.children, e, f, b);
-            case wa:
-              g = 8;
-              e |= 8;
-              break;
-            case xa:
-              return (
-                (a = ah(12, c, b, e | 2)),
-                (a.elementType = xa),
-                (a.lanes = f),
-                a
-              );
-            case Ca:
-              return (
-                (a = ah(13, c, b, e)), (a.elementType = Ca), (a.lanes = f), a
-              );
-            case Da:
-              return (
-                (a = ah(19, c, b, e)), (a.elementType = Da), (a.lanes = f), a
-              );
-            case Ga:
-              return nj(c, e, f, b);
-            default:
-              if (typeof a === "object" && a !== null)
-                switch (a.$$typeof) {
-                  case ya:
-                    g = 10;
-                    break a;
-                  case Aa:
-                    g = 9;
-                    break a;
-                  case Ba:
-                    g = 11;
-                    break a;
-                  case Ea:
-                    g = 14;
-                    break a;
-                  case Fa:
-                    g = 16;
-                    d = null;
-                    break a;
-                }
-              throw Error(p$1(130, a == null ? a : typeof a, ""));
-          }
-        b = ah(g, c, b, e);
-        b.elementType = a;
-        b.type = d;
-        b.lanes = f;
-        return b;
-      }
-      function qh(a, b, c, d) {
-        a = ah(7, a, d, b);
-        a.lanes = c;
-        return a;
-      }
-      function nj(a, b, c, d) {
-        a = ah(22, a, d, b);
-        a.elementType = Ga;
-        a.lanes = c;
-        a.stateNode = {};
-        return a;
-      }
-      function nh(a, b, c) {
-        a = ah(6, a, null, b);
-        a.lanes = c;
-        return a;
-      }
-      function ph(a, b, c) {
-        b = ah(4, a.children !== null ? a.children : [], a.key, b);
-        b.lanes = c;
-        b.stateNode = {
-          containerInfo: a.containerInfo,
-          pendingChildren: null,
-          implementation: a.implementation,
-        };
-        return b;
-      }
-      function Rk(a, b, c, d, e) {
-        this.tag = b;
-        this.containerInfo = a;
-        this.finishedWork =
-          this.pingCache =
-          this.current =
-          this.pendingChildren =
-            null;
-        this.timeoutHandle = -1;
-        this.callbackNode = this.pendingContext = this.context = null;
-        this.callbackPriority = 0;
-        this.eventTimes = vc(0);
-        this.expirationTimes = vc(-1);
-        this.entangledLanes =
-          this.finishedLanes =
-          this.mutableReadLanes =
-          this.expiredLanes =
-          this.pingedLanes =
-          this.suspendedLanes =
-          this.pendingLanes =
-            0;
-        this.entanglements = vc(0);
-        this.identifierPrefix = d;
-        this.onRecoverableError = e;
-        this.mutableSourceEagerHydrationData = null;
-      }
-      function Sk(a, b, c, d, e, f, g, h, k) {
-        a = new Rk(a, b, c, h, k);
-        b === 1 ? ((b = 1), f === true && (b |= 8)) : (b = 0);
-        f = ah(3, null, null, b);
-        a.current = f;
-        f.stateNode = a;
-        f.memoizedState = {
-          element: d,
-          isDehydrated: c,
-          cache: null,
-          transitions: null,
-        };
-        sg(f);
-        return a;
-      }
-      function Tk(a, b, c) {
-        var d =
-          3 < arguments.length && arguments[3] !== void 0 ? arguments[3] : null;
-        return {
-          $$typeof: ua,
-          key: d == null ? null : "" + d,
-          children: a,
-          containerInfo: b,
-          implementation: c,
-        };
-      }
-      function Uk(a) {
-        if (!a) return Pf;
-        a = a._reactInternals;
-        a: {
-          if (Sb(a) !== a || a.tag !== 1) throw Error(p$1(170));
-          var b = a;
-          do {
-            switch (b.tag) {
-              case 3:
-                b = b.stateNode.context;
-                break a;
-              case 1:
-                if (Tf(b.type)) {
-                  b = b.stateNode.__reactInternalMemoizedMergedChildContext;
-                  break a;
-                }
-            }
-            b = b.return;
-          } while (b !== null);
-          throw Error(p$1(171));
-        }
-        if (a.tag === 1) {
-          var c = a.type;
-          if (Tf(c)) return Wf(a, c, b);
-        }
-        return b;
-      }
-      function Vk(a, b, c, d, e, f, g, h, k) {
-        a = Sk(c, d, true, a, e, f, g, h, k);
-        a.context = Uk(null);
-        c = a.current;
-        d = M();
-        e = Dg(c);
-        f = ug(d, e);
-        f.callback = b !== void 0 && b !== null ? b : null;
-        vg(c, f);
-        a.current.lanes = e;
-        wc(a, e, d);
-        tk(a, d);
-        return a;
-      }
-      function Wk(a, b, c, d) {
-        var e = b.current,
-          f = M(),
-          g = Dg(e);
-        c = Uk(c);
-        b.context === null ? (b.context = c) : (b.pendingContext = c);
-        b = ug(f, g);
-        b.payload = { element: a };
-        d = d === void 0 ? null : d;
-        d !== null && (b.callback = d);
-        vg(e, b);
-        a = Eg(e, g, f);
-        a !== null && wg(a, e, g);
-        return g;
-      }
-      function Xk(a) {
-        a = a.current;
-        if (!a.child) return null;
-        switch (a.child.tag) {
-          case 5:
-            return a.child.stateNode;
-          default:
-            return a.child.stateNode;
-        }
-      }
-      function Yk(a, b) {
-        a = a.memoizedState;
-        if (a !== null && a.dehydrated !== null) {
-          var c = a.retryLane;
-          a.retryLane = c !== 0 && c < b ? c : b;
-        }
-      }
-      function Zk(a, b) {
-        Yk(a, b);
-        (a = a.alternate) && Yk(a, b);
-      }
-      function $k() {
-        return null;
-      }
-      var al =
-        typeof reportError === "function"
-          ? reportError
-          : function (a) {
-              console.error(a);
-            };
-      function bl(a) {
-        this._internalRoot = a;
-      }
-      cl.prototype.render = bl.prototype.render = function (a) {
-        var b = this._internalRoot;
-        if (b === null) throw Error(p$1(409));
-        Wk(a, b, null, null);
-      };
-      cl.prototype.unmount = bl.prototype.unmount = function () {
-        var a = this._internalRoot;
-        if (a !== null) {
-          this._internalRoot = null;
-          var b = a.containerInfo;
-          Hk(function () {
-            Wk(null, a, null, null);
-          });
-          b[pf] = null;
-        }
-      };
-      function cl(a) {
-        this._internalRoot = a;
-      }
-      cl.prototype.unstable_scheduleHydration = function (a) {
-        if (a) {
-          var b = Dc();
-          a = { blockedOn: null, target: a, priority: b };
-          for (var c = 0; c < Mc.length && b !== 0 && b < Mc[c].priority; c++);
-          Mc.splice(c, 0, a);
-          c === 0 && Rc(a);
-        }
-      };
-      function dl(a) {
-        return !(
-          !a ||
-          (a.nodeType !== 1 && a.nodeType !== 9 && a.nodeType !== 11)
-        );
-      }
-      function el$1(a) {
-        return !(
-          !a ||
-          (a.nodeType !== 1 &&
-            a.nodeType !== 9 &&
-            a.nodeType !== 11 &&
-            (a.nodeType !== 8 ||
-              a.nodeValue !== " react-mount-point-unstable "))
-        );
-      }
-      function fl() {}
-      function gl$1(a, b, c, d, e) {
-        if (e) {
-          if (typeof d === "function") {
-            var f = d;
-            d = function () {
-              var a2 = Xk(g);
-              f.call(a2);
-            };
-          }
-          var g = Vk(b, d, a, 0, null, false, false, "", fl);
-          a._reactRootContainer = g;
-          a[pf] = g.current;
-          nf(a.nodeType === 8 ? a.parentNode : a);
-          Hk();
-          return g;
-        }
-        for (; (e = a.lastChild); ) a.removeChild(e);
-        if (typeof d === "function") {
-          var h = d;
-          d = function () {
-            var a2 = Xk(k);
-            h.call(a2);
-          };
-        }
-        var k = Sk(a, 0, false, null, null, false, false, "", fl);
-        a._reactRootContainer = k;
-        a[pf] = k.current;
-        nf(a.nodeType === 8 ? a.parentNode : a);
-        Hk(function () {
-          Wk(b, k, c, d);
-        });
-        return k;
-      }
-      function hl(a, b, c, d, e) {
-        var f = c._reactRootContainer;
-        if (f) {
-          var g = f;
-          if (typeof e === "function") {
-            var h = e;
-            e = function () {
-              var a2 = Xk(g);
-              h.call(a2);
-            };
-          }
-          Wk(b, g, a, e);
-        } else g = gl$1(c, b, a, e, d);
-        return Xk(g);
-      }
-      Ac = function (a) {
-        switch (a.tag) {
-          case 3:
-            var b = a.stateNode;
-            if (b.current.memoizedState.isDehydrated) {
-              var c = qc(b.pendingLanes);
-              c !== 0 &&
-                (yc(b, c | 1),
-                tk(b, D()),
-                (K & 6) === 0 && ((Ti = D() + 500), dg()));
-            }
-            break;
-          case 13:
-            var d = M();
-            Hk(function () {
-              return Eg(a, 1, d);
-            });
-            Zk(a, 1);
-        }
-      };
-      Bc = function (a) {
-        if (a.tag === 13) {
-          var b = M();
-          Eg(a, 134217728, b);
-          Zk(a, 134217728);
-        }
-      };
-      Cc = function (a) {
-        if (a.tag === 13) {
-          var b = M(),
-            c = Dg(a);
-          Eg(a, c, b);
-          Zk(a, c);
-        }
-      };
-      Dc = function () {
-        return E;
-      };
-      Ec = function (a, b) {
-        var c = E;
-        try {
-          return (E = a), b();
-        } finally {
-          E = c;
-        }
-      };
-      vb = function (a, b, c) {
-        switch (b) {
-          case "input":
-            Za(a, c);
-            b = c.name;
-            if (c.type === "radio" && b != null) {
-              for (c = a; c.parentNode; ) c = c.parentNode;
-              c = c.querySelectorAll(
-                "input[name=" + JSON.stringify("" + b) + '][type="radio"]'
-              );
-              for (b = 0; b < c.length; b++) {
-                var d = c[b];
-                if (d !== a && d.form === a.form) {
-                  var e = Ab(d);
-                  if (!e) throw Error(p$1(90));
-                  Ua(d);
-                  Za(d, e);
-                }
-              }
-            }
-            break;
-          case "textarea":
-            fb(a, c);
-            break;
-          case "select":
-            (b = c.value), b != null && cb(a, !!c.multiple, b, false);
-        }
-      };
-      Db = Gk;
-      Eb = Hk;
-      var il = {
-          usingClientEntryPoint: false,
-          Events: [zb, pe, Ab, Bb, Cb, Gk],
-        },
-        jl = {
-          findFiberByHostInstance: Sc$1,
-          bundleType: 0,
-          version: "18.0.0-fc46dba67-20220329",
-          rendererPackageName: "react-dom",
-        };
-      var kl = {
-        bundleType: jl.bundleType,
-        version: jl.version,
-        rendererPackageName: jl.rendererPackageName,
-        rendererConfig: jl.rendererConfig,
-        overrideHookState: null,
-        overrideHookStateDeletePath: null,
-        overrideHookStateRenamePath: null,
-        overrideProps: null,
-        overridePropsDeletePath: null,
-        overridePropsRenamePath: null,
-        setErrorHandler: null,
-        setSuspenseHandler: null,
-        scheduleUpdate: null,
-        currentDispatcherRef: sa.ReactCurrentDispatcher,
-        findHostInstanceByFiber: function (a) {
-          a = Wb(a);
-          return a === null ? null : a.stateNode;
-        },
-        findFiberByHostInstance: jl.findFiberByHostInstance || $k,
-        findHostInstancesForRefresh: null,
-        scheduleRefresh: null,
-        scheduleRoot: null,
-        setRefreshHandler: null,
-        getCurrentFiber: null,
-        reconcilerVersion: "18.0.0-fc46dba67-20220329",
-      };
-      if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined") {
-        var ll$1 = __REACT_DEVTOOLS_GLOBAL_HOOK__;
-        if (!ll$1.isDisabled && ll$1.supportsFiber)
-          try {
-            (hc = ll$1.inject(kl)), (ic$1 = ll$1);
-          } catch (a) {}
-      }
-      reactDom_production_min.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED =
-        il;
-      reactDom_production_min.createPortal = function (a, b) {
-        var c =
-          2 < arguments.length && arguments[2] !== void 0 ? arguments[2] : null;
-        if (!dl(b)) throw Error(p$1(200));
-        return Tk(a, b, null, c);
-      };
-      reactDom_production_min.createRoot = function (a, b) {
-        if (!dl(a)) throw Error(p$1(299));
-        var c = false,
-          d = "",
-          e = al;
-        b !== null &&
-          b !== void 0 &&
-          (b.unstable_strictMode === true && (c = true),
-          b.identifierPrefix !== void 0 && (d = b.identifierPrefix),
-          b.onRecoverableError !== void 0 && (e = b.onRecoverableError));
-        b = Sk(a, 1, false, null, null, c, false, d, e);
-        a[pf] = b.current;
-        nf(a.nodeType === 8 ? a.parentNode : a);
-        return new bl(b);
-      };
-      reactDom_production_min.findDOMNode = function (a) {
-        if (a == null) return null;
-        if (a.nodeType === 1) return a;
-        var b = a._reactInternals;
-        if (b === void 0) {
-          if (typeof a.render === "function") throw Error(p$1(188));
-          a = Object.keys(a).join(",");
-          throw Error(p$1(268, a));
-        }
-        a = Wb(b);
-        a = a === null ? null : a.stateNode;
-        return a;
-      };
-      reactDom_production_min.flushSync = function (a) {
-        return Hk(a);
-      };
-      reactDom_production_min.hydrate = function (a, b, c) {
-        if (!el$1(b)) throw Error(p$1(200));
-        return hl(null, a, b, true, c);
-      };
-      reactDom_production_min.hydrateRoot = function (a, b, c) {
-        if (!dl(a)) throw Error(p$1(405));
-        var d = (c != null && c.hydratedSources) || null,
-          e = false,
-          f = "",
-          g = al;
-        c !== null &&
-          c !== void 0 &&
-          (c.unstable_strictMode === true && (e = true),
-          c.identifierPrefix !== void 0 && (f = c.identifierPrefix),
-          c.onRecoverableError !== void 0 && (g = c.onRecoverableError));
-        b = Vk(b, null, a, 1, c != null ? c : null, e, false, f, g);
-        a[pf] = b.current;
-        nf(a);
-        if (d)
-          for (a = 0; a < d.length; a++)
-            (c = d[a]),
-              (e = c._getVersion),
-              (e = e(c._source)),
-              b.mutableSourceEagerHydrationData == null
-                ? (b.mutableSourceEagerHydrationData = [c, e])
-                : b.mutableSourceEagerHydrationData.push(c, e);
-        return new cl(b);
-      };
-      reactDom_production_min.render = function (a, b, c) {
-        if (!el$1(b)) throw Error(p$1(200));
-        return hl(null, a, b, false, c);
-      };
-      reactDom_production_min.unmountComponentAtNode = function (a) {
-        if (!el$1(a)) throw Error(p$1(40));
-        return a._reactRootContainer
-          ? (Hk(function () {
-              hl(null, null, a, false, function () {
-                a._reactRootContainer = null;
-                a[pf] = null;
-              });
-            }),
-            true)
-          : false;
-      };
-      reactDom_production_min.unstable_batchedUpdates = Gk;
-      reactDom_production_min.unstable_renderSubtreeIntoContainer = function (
-        a,
-        b,
-        c,
-        d
-      ) {
-        if (!el$1(c)) throw Error(p$1(200));
-        if (a == null || a._reactInternals === void 0) throw Error(p$1(38));
-        return hl(a, b, c, false, d);
-      };
-      reactDom_production_min.version = "18.0.0-fc46dba67-20220329";
-      function checkDCE() {
-        if (
-          typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === "undefined" ||
-          typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE !== "function"
-        ) {
-          return;
-        }
-        try {
-          __REACT_DEVTOOLS_GLOBAL_HOOK__.checkDCE(checkDCE);
-        } catch (err) {
-          console.error(err);
-        }
-      }
-      {
-        checkDCE();
-        reactDom.exports = reactDom_production_min;
-      }
-      var ReactDOM = reactDom.exports;
-      var toggleSelection = function () {
-        var selection = document.getSelection();
-        if (!selection.rangeCount) {
-          return function () {};
-        }
-        var active = document.activeElement;
-        var ranges = [];
-        for (var i = 0; i < selection.rangeCount; i++) {
-          ranges.push(selection.getRangeAt(i));
-        }
-        switch (active.tagName.toUpperCase()) {
-          case "INPUT":
-          case "TEXTAREA":
-            active.blur();
-            break;
-          default:
-            active = null;
-            break;
-        }
-        selection.removeAllRanges();
-        return function () {
-          selection.type === "Caret" && selection.removeAllRanges();
-          if (!selection.rangeCount) {
-            ranges.forEach(function (range2) {
-              selection.addRange(range2);
-            });
-          }
-          active && active.focus();
-        };
-      };
-      var deselectCurrent = toggleSelection;
-      var clipboardToIE11Formatting = {
-        "text/plain": "Text",
-        "text/html": "Url",
-        default: "Text",
-      };
-      var defaultMessage = "Copy to clipboard: #{key}, Enter";
-      function format$1(message) {
-        var copyKey =
-          (/mac os x/i.test(navigator.userAgent) ? "\u2318" : "Ctrl") + "+C";
-        return message.replace(/#{\s*key\s*}/g, copyKey);
-      }
-      function copy$1(text3, options) {
-        var debug,
-          message,
-          reselectPrevious,
-          range2,
-          selection,
-          mark,
-          success = false;
-        if (!options) {
-          options = {};
-        }
-        debug = options.debug || false;
-        try {
-          reselectPrevious = deselectCurrent();
-          range2 = document.createRange();
-          selection = document.getSelection();
-          mark = document.createElement("span");
-          mark.textContent = text3;
-          mark.style.all = "unset";
-          mark.style.position = "fixed";
-          mark.style.top = 0;
-          mark.style.clip = "rect(0, 0, 0, 0)";
-          mark.style.whiteSpace = "pre";
-          mark.style.webkitUserSelect = "text";
-          mark.style.MozUserSelect = "text";
-          mark.style.msUserSelect = "text";
-          mark.style.userSelect = "text";
-          mark.addEventListener("copy", function (e) {
-            e.stopPropagation();
-            if (options.format) {
-              e.preventDefault();
-              if (typeof e.clipboardData === "undefined") {
-                debug && console.warn("unable to use e.clipboardData");
-                debug && console.warn("trying IE specific stuff");
-                window.clipboardData.clearData();
-                var format3 =
-                  clipboardToIE11Formatting[options.format] ||
-                  clipboardToIE11Formatting["default"];
-                window.clipboardData.setData(format3, text3);
-              } else {
-                e.clipboardData.clearData();
-                e.clipboardData.setData(options.format, text3);
-              }
-            }
-            if (options.onCopy) {
-              e.preventDefault();
-              options.onCopy(e.clipboardData);
-            }
-          });
-          document.body.appendChild(mark);
-          range2.selectNodeContents(mark);
-          selection.addRange(range2);
-          var successful = document.execCommand("copy");
-          if (!successful) {
-            throw new Error("copy command was unsuccessful");
-          }
-          success = true;
-        } catch (err) {
-          debug && console.error("unable to copy using execCommand: ", err);
-          debug && console.warn("trying IE specific stuff");
-          try {
-            window.clipboardData.setData(options.format || "text", text3);
-            options.onCopy && options.onCopy(window.clipboardData);
-            success = true;
-          } catch (err2) {
-            debug &&
-              console.error("unable to copy using clipboardData: ", err2);
-            debug && console.error("falling back to prompt");
-            message = format$1(
-              "message" in options ? options.message : defaultMessage
-            );
-            window.prompt(message, text3);
-          }
-        } finally {
-          if (selection) {
-            if (typeof selection.removeRange == "function") {
-              selection.removeRange(range2);
-            } else {
-              selection.removeAllRanges();
-            }
-          }
-          if (mark) {
-            document.body.removeChild(mark);
-          }
-          reselectPrevious();
-        }
-        return success;
-      }
-      var copyToClipboard = copy$1;
-      const version = "16.4.0";
-      const versionInfo = Object.freeze({
-        major: 16,
-        minor: 4,
-        patch: 0,
-        preReleaseTag: null,
-      });
-      function devAssert$1(condition, message) {
-        const booleanCondition = Boolean(condition);
-        if (!booleanCondition) {
-          throw new Error(message);
-        }
-      }
-      function isPromise$2(value) {
-        return (
-          typeof (value === null || value === void 0 ? void 0 : value.then) ===
-          "function"
-        );
-      }
-      function isObjectLike$1(value) {
-        return typeof value == "object" && value !== null;
-      }
-      function invariant$2(condition, message) {
-        const booleanCondition = Boolean(condition);
-        if (!booleanCondition) {
-          throw new Error(
-            message != null ? message : "Unexpected invariant triggered."
-          );
-        }
-      }
-      const LineRegExp = /\r\n|[\n\r]/g;
-      function getLocation$1(source, position) {
-        let lastLineStart = 0;
-        let line = 1;
-        for (const match2 of source.body.matchAll(LineRegExp)) {
-          typeof match2.index === "number" || invariant$2(false);
-          if (match2.index >= position) {
-            break;
-          }
-          lastLineStart = match2.index + match2[0].length;
-          line += 1;
-        }
-        return {
-          line,
-          column: position + 1 - lastLineStart,
-        };
-      }
-      function printLocation(location2) {
-        return printSourceLocation(
-          location2.source,
-          getLocation$1(location2.source, location2.start)
-        );
-      }
-      function printSourceLocation(source, sourceLocation) {
-        const firstLineColumnOffset = source.locationOffset.column - 1;
-        const body = "".padStart(firstLineColumnOffset) + source.body;
-        const lineIndex = sourceLocation.line - 1;
-        const lineOffset = source.locationOffset.line - 1;
-        const lineNum = sourceLocation.line + lineOffset;
-        const columnOffset =
-          sourceLocation.line === 1 ? firstLineColumnOffset : 0;
-        const columnNum = sourceLocation.column + columnOffset;
-        const locationStr = `${source.name}:${lineNum}:${columnNum}
-`;
-        const lines = body.split(/\r\n|[\n\r]/g);
-        const locationLine = lines[lineIndex];
-        if (locationLine.length > 120) {
-          const subLineIndex = Math.floor(columnNum / 80);
-          const subLineColumnNum = columnNum % 80;
-          const subLines = [];
-          for (let i = 0; i < locationLine.length; i += 80) {
-            subLines.push(locationLine.slice(i, i + 80));
-          }
-          return (
-            locationStr +
-            printPrefixedLines([
-              [`${lineNum} |`, subLines[0]],
-              ...subLines
-                .slice(1, subLineIndex + 1)
-                .map((subLine) => ["|", subLine]),
-              ["|", "^".padStart(subLineColumnNum)],
-              ["|", subLines[subLineIndex + 1]],
-            ])
-          );
-        }
-        return (
-          locationStr +
-          printPrefixedLines([
-            [`${lineNum - 1} |`, lines[lineIndex - 1]],
-            [`${lineNum} |`, locationLine],
-            ["|", "^".padStart(columnNum)],
-            [`${lineNum + 1} |`, lines[lineIndex + 1]],
-          ])
-        );
-      }
-      function printPrefixedLines(lines) {
-        const existingLines = lines.filter(([_, line]) => line !== void 0);
-        const padLen = Math.max(
-          ...existingLines.map(([prefix]) => prefix.length)
-        );
-        return existingLines
-          .map(
-            ([prefix, line]) =>
-              prefix.padStart(padLen) + (line ? " " + line : "")
-          )
-          .join("\n");
-      }
-      function toNormalizedArgs(args) {
-        const firstArg = args[0];
-        if (firstArg == null || "kind" in firstArg || "length" in firstArg) {
-          return {
-            nodes: firstArg,
-            source: args[1],
-            positions: args[2],
-            path: args[3],
-            originalError: args[4],
-            extensions: args[5],
-          };
-        }
-        return firstArg;
-      }
-      class GraphQLError extends Error {
-        constructor(message, ...rawArgs) {
-          var _this$nodes, _nodeLocations$, _ref;
-          const { nodes, source, positions, path, originalError, extensions } =
-            toNormalizedArgs(rawArgs);
-          super(message);
-          this.name = "GraphQLError";
-          this.path = path !== null && path !== void 0 ? path : void 0;
-          this.originalError =
-            originalError !== null && originalError !== void 0
-              ? originalError
-              : void 0;
-          this.nodes = undefinedIfEmpty(
-            Array.isArray(nodes) ? nodes : nodes ? [nodes] : void 0
-          );
-          const nodeLocations = undefinedIfEmpty(
-            (_this$nodes = this.nodes) === null || _this$nodes === void 0
-              ? void 0
-              : _this$nodes.map((node) => node.loc).filter((loc) => loc != null)
-          );
-          this.source =
-            source !== null && source !== void 0
-              ? source
-              : nodeLocations === null || nodeLocations === void 0
-              ? void 0
-              : (_nodeLocations$ = nodeLocations[0]) === null ||
-                _nodeLocations$ === void 0
-              ? void 0
-              : _nodeLocations$.source;
-          this.positions =
-            positions !== null && positions !== void 0
-              ? positions
-              : nodeLocations === null || nodeLocations === void 0
-              ? void 0
-              : nodeLocations.map((loc) => loc.start);
-          this.locations =
-            positions && source
-              ? positions.map((pos) => getLocation$1(source, pos))
-              : nodeLocations === null || nodeLocations === void 0
-              ? void 0
-              : nodeLocations.map((loc) =>
-                  getLocation$1(loc.source, loc.start)
-                );
-          const originalExtensions = isObjectLike$1(
-            originalError === null || originalError === void 0
-              ? void 0
-              : originalError.extensions
-          )
-            ? originalError === null || originalError === void 0
-              ? void 0
-              : originalError.extensions
-            : void 0;
-          this.extensions =
-            (_ref =
-              extensions !== null && extensions !== void 0
-                ? extensions
-                : originalExtensions) !== null && _ref !== void 0
-              ? _ref
-              : /* @__PURE__ */ Object.create(null);
-          Object.defineProperties(this, {
-            message: {
-              writable: true,
-              enumerable: true,
-            },
-            name: {
-              enumerable: false,
-            },
-            nodes: {
-              enumerable: false,
-            },
-            source: {
-              enumerable: false,
-            },
-            positions: {
-              enumerable: false,
-            },
-            originalError: {
-              enumerable: false,
-            },
-          });
-          if (
-            originalError !== null &&
-            originalError !== void 0 &&
-            originalError.stack
-          ) {
-            Object.defineProperty(this, "stack", {
-              value: originalError.stack,
-              writable: true,
-              configurable: true,
-            });
-          } else if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, GraphQLError);
-          } else {
-            Object.defineProperty(this, "stack", {
-              value: Error().stack,
-              writable: true,
-              configurable: true,
-            });
-          }
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLError";
-        }
-        toString() {
-          let output = this.message;
-          if (this.nodes) {
-            for (const node of this.nodes) {
-              if (node.loc) {
-                output += "\n\n" + printLocation(node.loc);
-              }
-            }
-          } else if (this.source && this.locations) {
-            for (const location2 of this.locations) {
-              output += "\n\n" + printSourceLocation(this.source, location2);
-            }
-          }
-          return output;
-        }
-        toJSON() {
-          const formattedError = {
-            message: this.message,
-          };
-          if (this.locations != null) {
-            formattedError.locations = this.locations;
-          }
-          if (this.path != null) {
-            formattedError.path = this.path;
-          }
-          if (
-            this.extensions != null &&
-            Object.keys(this.extensions).length > 0
-          ) {
-            formattedError.extensions = this.extensions;
-          }
-          return formattedError;
-        }
-      }
-      function undefinedIfEmpty(array) {
-        return array === void 0 || array.length === 0 ? void 0 : array;
-      }
-      function printError(error2) {
-        return error2.toString();
-      }
-      function formatError$1(error2) {
-        return error2.toJSON();
-      }
-      function syntaxError$1(source, position, description) {
-        return new GraphQLError(`Syntax Error: ${description}`, {
-          source,
-          positions: [position],
-        });
-      }
-      class Location$1 {
-        constructor(startToken, endToken, source) {
-          this.start = startToken.start;
-          this.end = endToken.end;
-          this.startToken = startToken;
-          this.endToken = endToken;
-          this.source = source;
-        }
-        get [Symbol.toStringTag]() {
-          return "Location";
-        }
-        toJSON() {
-          return {
-            start: this.start,
-            end: this.end,
-          };
-        }
-      }
-      class Token$4 {
-        constructor(kind2, start2, end2, line, column, value) {
-          this.kind = kind2;
-          this.start = start2;
-          this.end = end2;
-          this.line = line;
-          this.column = column;
-          this.value = value;
-          this.prev = null;
-          this.next = null;
-        }
-        get [Symbol.toStringTag]() {
-          return "Token";
-        }
-        toJSON() {
-          return {
-            kind: this.kind,
-            value: this.value,
-            line: this.line,
-            column: this.column,
-          };
-        }
-      }
-      const QueryDocumentKeys = {
-        Name: [],
-        Document: ["definitions"],
-        OperationDefinition: [
-          "name",
-          "variableDefinitions",
-          "directives",
-          "selectionSet",
-        ],
-        VariableDefinition: ["variable", "type", "defaultValue", "directives"],
-        Variable: ["name"],
-        SelectionSet: ["selections"],
-        Field: ["alias", "name", "arguments", "directives", "selectionSet"],
-        Argument: ["name", "value"],
-        FragmentSpread: ["name", "directives"],
-        InlineFragment: ["typeCondition", "directives", "selectionSet"],
-        FragmentDefinition: [
-          "name",
-          "variableDefinitions",
-          "typeCondition",
-          "directives",
-          "selectionSet",
-        ],
-        IntValue: [],
-        FloatValue: [],
-        StringValue: [],
-        BooleanValue: [],
-        NullValue: [],
-        EnumValue: [],
-        ListValue: ["values"],
-        ObjectValue: ["fields"],
-        ObjectField: ["name", "value"],
-        Directive: ["name", "arguments"],
-        NamedType: ["name"],
-        ListType: ["type"],
-        NonNullType: ["type"],
-        SchemaDefinition: ["description", "directives", "operationTypes"],
-        OperationTypeDefinition: ["type"],
-        ScalarTypeDefinition: ["description", "name", "directives"],
-        ObjectTypeDefinition: [
-          "description",
-          "name",
-          "interfaces",
-          "directives",
-          "fields",
-        ],
-        FieldDefinition: [
-          "description",
-          "name",
-          "arguments",
-          "type",
-          "directives",
-        ],
-        InputValueDefinition: [
-          "description",
-          "name",
-          "type",
-          "defaultValue",
-          "directives",
-        ],
-        InterfaceTypeDefinition: [
-          "description",
-          "name",
-          "interfaces",
-          "directives",
-          "fields",
-        ],
-        UnionTypeDefinition: ["description", "name", "directives", "types"],
-        EnumTypeDefinition: ["description", "name", "directives", "values"],
-        EnumValueDefinition: ["description", "name", "directives"],
-        InputObjectTypeDefinition: [
-          "description",
-          "name",
-          "directives",
-          "fields",
-        ],
-        DirectiveDefinition: ["description", "name", "arguments", "locations"],
-        SchemaExtension: ["directives", "operationTypes"],
-        ScalarTypeExtension: ["name", "directives"],
-        ObjectTypeExtension: ["name", "interfaces", "directives", "fields"],
-        InterfaceTypeExtension: ["name", "interfaces", "directives", "fields"],
-        UnionTypeExtension: ["name", "directives", "types"],
-        EnumTypeExtension: ["name", "directives", "values"],
-        InputObjectTypeExtension: ["name", "directives", "fields"],
-      };
-      const kindValues = new Set(Object.keys(QueryDocumentKeys));
-      function isNode(maybeNode) {
-        const maybeKind =
-          maybeNode === null || maybeNode === void 0 ? void 0 : maybeNode.kind;
-        return typeof maybeKind === "string" && kindValues.has(maybeKind);
-      }
-      let OperationTypeNode;
-      (function (OperationTypeNode2) {
-        OperationTypeNode2["QUERY"] = "query";
-        OperationTypeNode2["MUTATION"] = "mutation";
-        OperationTypeNode2["SUBSCRIPTION"] = "subscription";
-      })(OperationTypeNode || (OperationTypeNode = {}));
-      let DirectiveLocation;
-      (function (DirectiveLocation2) {
-        DirectiveLocation2["QUERY"] = "QUERY";
-        DirectiveLocation2["MUTATION"] = "MUTATION";
-        DirectiveLocation2["SUBSCRIPTION"] = "SUBSCRIPTION";
-        DirectiveLocation2["FIELD"] = "FIELD";
-        DirectiveLocation2["FRAGMENT_DEFINITION"] = "FRAGMENT_DEFINITION";
-        DirectiveLocation2["FRAGMENT_SPREAD"] = "FRAGMENT_SPREAD";
-        DirectiveLocation2["INLINE_FRAGMENT"] = "INLINE_FRAGMENT";
-        DirectiveLocation2["VARIABLE_DEFINITION"] = "VARIABLE_DEFINITION";
-        DirectiveLocation2["SCHEMA"] = "SCHEMA";
-        DirectiveLocation2["SCALAR"] = "SCALAR";
-        DirectiveLocation2["OBJECT"] = "OBJECT";
-        DirectiveLocation2["FIELD_DEFINITION"] = "FIELD_DEFINITION";
-        DirectiveLocation2["ARGUMENT_DEFINITION"] = "ARGUMENT_DEFINITION";
-        DirectiveLocation2["INTERFACE"] = "INTERFACE";
-        DirectiveLocation2["UNION"] = "UNION";
-        DirectiveLocation2["ENUM"] = "ENUM";
-        DirectiveLocation2["ENUM_VALUE"] = "ENUM_VALUE";
-        DirectiveLocation2["INPUT_OBJECT"] = "INPUT_OBJECT";
-        DirectiveLocation2["INPUT_FIELD_DEFINITION"] = "INPUT_FIELD_DEFINITION";
-      })(DirectiveLocation || (DirectiveLocation = {}));
-      let Kind;
-      (function (Kind2) {
-        Kind2["NAME"] = "Name";
-        Kind2["DOCUMENT"] = "Document";
-        Kind2["OPERATION_DEFINITION"] = "OperationDefinition";
-        Kind2["VARIABLE_DEFINITION"] = "VariableDefinition";
-        Kind2["SELECTION_SET"] = "SelectionSet";
-        Kind2["FIELD"] = "Field";
-        Kind2["ARGUMENT"] = "Argument";
-        Kind2["FRAGMENT_SPREAD"] = "FragmentSpread";
-        Kind2["INLINE_FRAGMENT"] = "InlineFragment";
-        Kind2["FRAGMENT_DEFINITION"] = "FragmentDefinition";
-        Kind2["VARIABLE"] = "Variable";
-        Kind2["INT"] = "IntValue";
-        Kind2["FLOAT"] = "FloatValue";
-        Kind2["STRING"] = "StringValue";
-        Kind2["BOOLEAN"] = "BooleanValue";
-        Kind2["NULL"] = "NullValue";
-        Kind2["ENUM"] = "EnumValue";
-        Kind2["LIST"] = "ListValue";
-        Kind2["OBJECT"] = "ObjectValue";
-        Kind2["OBJECT_FIELD"] = "ObjectField";
-        Kind2["DIRECTIVE"] = "Directive";
-        Kind2["NAMED_TYPE"] = "NamedType";
-        Kind2["LIST_TYPE"] = "ListType";
-        Kind2["NON_NULL_TYPE"] = "NonNullType";
-        Kind2["SCHEMA_DEFINITION"] = "SchemaDefinition";
-        Kind2["OPERATION_TYPE_DEFINITION"] = "OperationTypeDefinition";
-        Kind2["SCALAR_TYPE_DEFINITION"] = "ScalarTypeDefinition";
-        Kind2["OBJECT_TYPE_DEFINITION"] = "ObjectTypeDefinition";
-        Kind2["FIELD_DEFINITION"] = "FieldDefinition";
-        Kind2["INPUT_VALUE_DEFINITION"] = "InputValueDefinition";
-        Kind2["INTERFACE_TYPE_DEFINITION"] = "InterfaceTypeDefinition";
-        Kind2["UNION_TYPE_DEFINITION"] = "UnionTypeDefinition";
-        Kind2["ENUM_TYPE_DEFINITION"] = "EnumTypeDefinition";
-        Kind2["ENUM_VALUE_DEFINITION"] = "EnumValueDefinition";
-        Kind2["INPUT_OBJECT_TYPE_DEFINITION"] = "InputObjectTypeDefinition";
-        Kind2["DIRECTIVE_DEFINITION"] = "DirectiveDefinition";
-        Kind2["SCHEMA_EXTENSION"] = "SchemaExtension";
-        Kind2["SCALAR_TYPE_EXTENSION"] = "ScalarTypeExtension";
-        Kind2["OBJECT_TYPE_EXTENSION"] = "ObjectTypeExtension";
-        Kind2["INTERFACE_TYPE_EXTENSION"] = "InterfaceTypeExtension";
-        Kind2["UNION_TYPE_EXTENSION"] = "UnionTypeExtension";
-        Kind2["ENUM_TYPE_EXTENSION"] = "EnumTypeExtension";
-        Kind2["INPUT_OBJECT_TYPE_EXTENSION"] = "InputObjectTypeExtension";
-      })(Kind || (Kind = {}));
-      function isWhiteSpace$2(code3) {
-        return code3 === 9 || code3 === 32;
-      }
-      function isDigit$2(code3) {
-        return code3 >= 48 && code3 <= 57;
-      }
-      function isLetter$1(code3) {
-        return (code3 >= 97 && code3 <= 122) || (code3 >= 65 && code3 <= 90);
-      }
-      function isNameStart(code3) {
-        return isLetter$1(code3) || code3 === 95;
-      }
-      function isNameContinue(code3) {
-        return isLetter$1(code3) || isDigit$2(code3) || code3 === 95;
-      }
-      function dedentBlockStringLines(lines) {
-        var _firstNonEmptyLine2;
-        let commonIndent = Number.MAX_SAFE_INTEGER;
-        let firstNonEmptyLine = null;
-        let lastNonEmptyLine = -1;
-        for (let i = 0; i < lines.length; ++i) {
-          var _firstNonEmptyLine;
-          const line = lines[i];
-          const indent2 = leadingWhitespace$1(line);
-          if (indent2 === line.length) {
-            continue;
-          }
-          firstNonEmptyLine =
-            (_firstNonEmptyLine = firstNonEmptyLine) !== null &&
-            _firstNonEmptyLine !== void 0
-              ? _firstNonEmptyLine
-              : i;
-          lastNonEmptyLine = i;
-          if (i !== 0 && indent2 < commonIndent) {
-            commonIndent = indent2;
-          }
-        }
-        return lines
-          .map((line, i) => (i === 0 ? line : line.slice(commonIndent)))
-          .slice(
-            (_firstNonEmptyLine2 = firstNonEmptyLine) !== null &&
-              _firstNonEmptyLine2 !== void 0
-              ? _firstNonEmptyLine2
-              : 0,
-            lastNonEmptyLine + 1
-          );
-      }
-      function leadingWhitespace$1(str) {
-        let i = 0;
-        while (i < str.length && isWhiteSpace$2(str.charCodeAt(i))) {
-          ++i;
-        }
-        return i;
-      }
-      function isPrintableAsBlockString(value) {
-        if (value === "") {
-          return true;
-        }
-        let isEmptyLine = true;
-        let hasIndent = false;
-        let hasCommonIndent = true;
-        let seenNonEmptyLine = false;
-        for (let i = 0; i < value.length; ++i) {
-          switch (value.codePointAt(i)) {
-            case 0:
-            case 1:
-            case 2:
-            case 3:
-            case 4:
-            case 5:
-            case 6:
-            case 7:
-            case 8:
-            case 11:
-            case 12:
-            case 14:
-            case 15:
-              return false;
-            case 13:
-              return false;
-            case 10:
-              if (isEmptyLine && !seenNonEmptyLine) {
-                return false;
-              }
-              seenNonEmptyLine = true;
-              isEmptyLine = true;
-              hasIndent = false;
-              break;
-            case 9:
-            case 32:
-              hasIndent || (hasIndent = isEmptyLine);
-              break;
-            default:
-              hasCommonIndent && (hasCommonIndent = hasIndent);
-              isEmptyLine = false;
-          }
-        }
-        if (isEmptyLine) {
-          return false;
-        }
-        if (hasCommonIndent && seenNonEmptyLine) {
-          return false;
-        }
-        return true;
-      }
-      function printBlockString$1(value, options) {
-        const escapedValue = value.replace(/"""/g, '\\"""');
-        const lines = escapedValue.split(/\r\n|[\n\r]/g);
-        const isSingleLine = lines.length === 1;
-        const forceLeadingNewLine =
-          lines.length > 1 &&
-          lines
-            .slice(1)
-            .every(
-              (line) => line.length === 0 || isWhiteSpace$2(line.charCodeAt(0))
-            );
-        const hasTrailingTripleQuotes = escapedValue.endsWith('\\"""');
-        const hasTrailingQuote =
-          value.endsWith('"') && !hasTrailingTripleQuotes;
-        const hasTrailingSlash = value.endsWith("\\");
-        const forceTrailingNewline = hasTrailingQuote || hasTrailingSlash;
-        const printAsMultipleLines =
-          !(options !== null && options !== void 0 && options.minimize) &&
-          (!isSingleLine ||
-            value.length > 70 ||
-            forceTrailingNewline ||
-            forceLeadingNewLine ||
-            hasTrailingTripleQuotes);
-        let result2 = "";
-        const skipLeadingNewLine =
-          isSingleLine && isWhiteSpace$2(value.charCodeAt(0));
-        if (
-          (printAsMultipleLines && !skipLeadingNewLine) ||
-          forceLeadingNewLine
-        ) {
-          result2 += "\n";
-        }
-        result2 += escapedValue;
-        if (printAsMultipleLines || forceTrailingNewline) {
-          result2 += "\n";
-        }
-        return '"""' + result2 + '"""';
-      }
-      let TokenKind;
-      (function (TokenKind2) {
-        TokenKind2["SOF"] = "<SOF>";
-        TokenKind2["EOF"] = "<EOF>";
-        TokenKind2["BANG"] = "!";
-        TokenKind2["DOLLAR"] = "$";
-        TokenKind2["AMP"] = "&";
-        TokenKind2["PAREN_L"] = "(";
-        TokenKind2["PAREN_R"] = ")";
-        TokenKind2["SPREAD"] = "...";
-        TokenKind2["COLON"] = ":";
-        TokenKind2["EQUALS"] = "=";
-        TokenKind2["AT"] = "@";
-        TokenKind2["BRACKET_L"] = "[";
-        TokenKind2["BRACKET_R"] = "]";
-        TokenKind2["BRACE_L"] = "{";
-        TokenKind2["PIPE"] = "|";
-        TokenKind2["BRACE_R"] = "}";
-        TokenKind2["NAME"] = "Name";
-        TokenKind2["INT"] = "Int";
-        TokenKind2["FLOAT"] = "Float";
-        TokenKind2["STRING"] = "String";
-        TokenKind2["BLOCK_STRING"] = "BlockString";
-        TokenKind2["COMMENT"] = "Comment";
-      })(TokenKind || (TokenKind = {}));
-      class Lexer {
-        constructor(source) {
-          const startOfFileToken = new Token$4(TokenKind.SOF, 0, 0, 0, 0);
-          this.source = source;
-          this.lastToken = startOfFileToken;
-          this.token = startOfFileToken;
-          this.line = 1;
-          this.lineStart = 0;
-        }
-        get [Symbol.toStringTag]() {
-          return "Lexer";
-        }
-        advance() {
-          this.lastToken = this.token;
-          const token2 = (this.token = this.lookahead());
-          return token2;
-        }
-        lookahead() {
-          let token2 = this.token;
-          if (token2.kind !== TokenKind.EOF) {
-            do {
-              if (token2.next) {
-                token2 = token2.next;
-              } else {
-                const nextToken = readNextToken(this, token2.end);
-                token2.next = nextToken;
-                nextToken.prev = token2;
-                token2 = nextToken;
-              }
-            } while (token2.kind === TokenKind.COMMENT);
-          }
-          return token2;
-        }
-      }
-      function isPunctuatorTokenKind(kind2) {
-        return (
-          kind2 === TokenKind.BANG ||
-          kind2 === TokenKind.DOLLAR ||
-          kind2 === TokenKind.AMP ||
-          kind2 === TokenKind.PAREN_L ||
-          kind2 === TokenKind.PAREN_R ||
-          kind2 === TokenKind.SPREAD ||
-          kind2 === TokenKind.COLON ||
-          kind2 === TokenKind.EQUALS ||
-          kind2 === TokenKind.AT ||
-          kind2 === TokenKind.BRACKET_L ||
-          kind2 === TokenKind.BRACKET_R ||
-          kind2 === TokenKind.BRACE_L ||
-          kind2 === TokenKind.PIPE ||
-          kind2 === TokenKind.BRACE_R
-        );
-      }
-      function isUnicodeScalarValue(code3) {
-        return (
-          (code3 >= 0 && code3 <= 55295) || (code3 >= 57344 && code3 <= 1114111)
-        );
-      }
-      function isSupplementaryCodePoint(body, location2) {
-        return (
-          isLeadingSurrogate(body.charCodeAt(location2)) &&
-          isTrailingSurrogate(body.charCodeAt(location2 + 1))
-        );
-      }
-      function isLeadingSurrogate(code3) {
-        return code3 >= 55296 && code3 <= 56319;
-      }
-      function isTrailingSurrogate(code3) {
-        return code3 >= 56320 && code3 <= 57343;
-      }
-      function printCodePointAt(lexer, location2) {
-        const code3 = lexer.source.body.codePointAt(location2);
-        if (code3 === void 0) {
-          return TokenKind.EOF;
-        } else if (code3 >= 32 && code3 <= 126) {
-          const char = String.fromCodePoint(code3);
-          return char === '"' ? `'"'` : `"${char}"`;
-        }
-        return "U+" + code3.toString(16).toUpperCase().padStart(4, "0");
-      }
-      function createToken(lexer, kind2, start2, end2, value) {
-        const line = lexer.line;
-        const col = 1 + start2 - lexer.lineStart;
-        return new Token$4(kind2, start2, end2, line, col, value);
-      }
-      function readNextToken(lexer, start2) {
-        const body = lexer.source.body;
-        const bodyLength = body.length;
-        let position = start2;
-        while (position < bodyLength) {
-          const code3 = body.charCodeAt(position);
-          switch (code3) {
-            case 65279:
-            case 9:
-            case 32:
-            case 44:
-              ++position;
-              continue;
-            case 10:
-              ++position;
-              ++lexer.line;
-              lexer.lineStart = position;
-              continue;
-            case 13:
-              if (body.charCodeAt(position + 1) === 10) {
-                position += 2;
-              } else {
-                ++position;
-              }
-              ++lexer.line;
-              lexer.lineStart = position;
-              continue;
-            case 35:
-              return readComment(lexer, position);
-            case 33:
-              return createToken(lexer, TokenKind.BANG, position, position + 1);
-            case 36:
-              return createToken(
-                lexer,
-                TokenKind.DOLLAR,
-                position,
-                position + 1
-              );
-            case 38:
-              return createToken(lexer, TokenKind.AMP, position, position + 1);
-            case 40:
-              return createToken(
-                lexer,
-                TokenKind.PAREN_L,
-                position,
-                position + 1
-              );
-            case 41:
-              return createToken(
-                lexer,
-                TokenKind.PAREN_R,
-                position,
-                position + 1
-              );
-            case 46:
-              if (
-                body.charCodeAt(position + 1) === 46 &&
-                body.charCodeAt(position + 2) === 46
-              ) {
-                return createToken(
-                  lexer,
-                  TokenKind.SPREAD,
-                  position,
-                  position + 3
-                );
-              }
-              break;
-            case 58:
-              return createToken(
-                lexer,
-                TokenKind.COLON,
-                position,
-                position + 1
-              );
-            case 61:
-              return createToken(
-                lexer,
-                TokenKind.EQUALS,
-                position,
-                position + 1
-              );
-            case 64:
-              return createToken(lexer, TokenKind.AT, position, position + 1);
-            case 91:
-              return createToken(
-                lexer,
-                TokenKind.BRACKET_L,
-                position,
-                position + 1
-              );
-            case 93:
-              return createToken(
-                lexer,
-                TokenKind.BRACKET_R,
-                position,
-                position + 1
-              );
-            case 123:
-              return createToken(
-                lexer,
-                TokenKind.BRACE_L,
-                position,
-                position + 1
-              );
-            case 124:
-              return createToken(lexer, TokenKind.PIPE, position, position + 1);
-            case 125:
-              return createToken(
-                lexer,
-                TokenKind.BRACE_R,
-                position,
-                position + 1
-              );
-            case 34:
-              if (
-                body.charCodeAt(position + 1) === 34 &&
-                body.charCodeAt(position + 2) === 34
-              ) {
-                return readBlockString(lexer, position);
-              }
-              return readString$1(lexer, position);
-          }
-          if (isDigit$2(code3) || code3 === 45) {
-            return readNumber$1(lexer, position, code3);
-          }
-          if (isNameStart(code3)) {
-            return readName(lexer, position);
-          }
-          throw syntaxError$1(
-            lexer.source,
-            position,
-            code3 === 39
-              ? `Unexpected single quote character ('), did you mean to use a double quote (")?`
-              : isUnicodeScalarValue(code3) ||
-                isSupplementaryCodePoint(body, position)
-              ? `Unexpected character: ${printCodePointAt(lexer, position)}.`
-              : `Invalid character: ${printCodePointAt(lexer, position)}.`
-          );
-        }
-        return createToken(lexer, TokenKind.EOF, bodyLength, bodyLength);
-      }
-      function readComment(lexer, start2) {
-        const body = lexer.source.body;
-        const bodyLength = body.length;
-        let position = start2 + 1;
-        while (position < bodyLength) {
-          const code3 = body.charCodeAt(position);
-          if (code3 === 10 || code3 === 13) {
-            break;
-          }
-          if (isUnicodeScalarValue(code3)) {
-            ++position;
-          } else if (isSupplementaryCodePoint(body, position)) {
-            position += 2;
-          } else {
-            break;
-          }
-        }
-        return createToken(
-          lexer,
-          TokenKind.COMMENT,
-          start2,
-          position,
-          body.slice(start2 + 1, position)
-        );
-      }
-      function readNumber$1(lexer, start2, firstCode) {
-        const body = lexer.source.body;
-        let position = start2;
-        let code3 = firstCode;
-        let isFloat = false;
-        if (code3 === 45) {
-          code3 = body.charCodeAt(++position);
-        }
-        if (code3 === 48) {
-          code3 = body.charCodeAt(++position);
-          if (isDigit$2(code3)) {
-            throw syntaxError$1(
-              lexer.source,
-              position,
-              `Invalid number, unexpected digit after 0: ${printCodePointAt(
-                lexer,
-                position
-              )}.`
-            );
-          }
-        } else {
-          position = readDigits$1(lexer, position, code3);
-          code3 = body.charCodeAt(position);
-        }
-        if (code3 === 46) {
-          isFloat = true;
-          code3 = body.charCodeAt(++position);
-          position = readDigits$1(lexer, position, code3);
-          code3 = body.charCodeAt(position);
-        }
-        if (code3 === 69 || code3 === 101) {
-          isFloat = true;
-          code3 = body.charCodeAt(++position);
-          if (code3 === 43 || code3 === 45) {
-            code3 = body.charCodeAt(++position);
-          }
-          position = readDigits$1(lexer, position, code3);
-          code3 = body.charCodeAt(position);
-        }
-        if (code3 === 46 || isNameStart(code3)) {
-          throw syntaxError$1(
-            lexer.source,
-            position,
-            `Invalid number, expected digit but got: ${printCodePointAt(
-              lexer,
-              position
-            )}.`
-          );
-        }
-        return createToken(
-          lexer,
-          isFloat ? TokenKind.FLOAT : TokenKind.INT,
-          start2,
-          position,
-          body.slice(start2, position)
-        );
-      }
-      function readDigits$1(lexer, start2, firstCode) {
-        if (!isDigit$2(firstCode)) {
-          throw syntaxError$1(
-            lexer.source,
-            start2,
-            `Invalid number, expected digit but got: ${printCodePointAt(
-              lexer,
-              start2
-            )}.`
-          );
-        }
-        const body = lexer.source.body;
-        let position = start2 + 1;
-        while (isDigit$2(body.charCodeAt(position))) {
-          ++position;
-        }
-        return position;
-      }
-      function readString$1(lexer, start2) {
-        const body = lexer.source.body;
-        const bodyLength = body.length;
-        let position = start2 + 1;
-        let chunkStart = position;
-        let value = "";
-        while (position < bodyLength) {
-          const code3 = body.charCodeAt(position);
-          if (code3 === 34) {
-            value += body.slice(chunkStart, position);
-            return createToken(
-              lexer,
-              TokenKind.STRING,
-              start2,
-              position + 1,
-              value
-            );
-          }
-          if (code3 === 92) {
-            value += body.slice(chunkStart, position);
-            const escape3 =
-              body.charCodeAt(position + 1) === 117
-                ? body.charCodeAt(position + 2) === 123
-                  ? readEscapedUnicodeVariableWidth(lexer, position)
-                  : readEscapedUnicodeFixedWidth(lexer, position)
-                : readEscapedCharacter(lexer, position);
-            value += escape3.value;
-            position += escape3.size;
-            chunkStart = position;
-            continue;
-          }
-          if (code3 === 10 || code3 === 13) {
-            break;
-          }
-          if (isUnicodeScalarValue(code3)) {
-            ++position;
-          } else if (isSupplementaryCodePoint(body, position)) {
-            position += 2;
-          } else {
-            throw syntaxError$1(
-              lexer.source,
-              position,
-              `Invalid character within String: ${printCodePointAt(
-                lexer,
-                position
-              )}.`
-            );
-          }
-        }
-        throw syntaxError$1(lexer.source, position, "Unterminated string.");
-      }
-      function readEscapedUnicodeVariableWidth(lexer, position) {
-        const body = lexer.source.body;
-        let point = 0;
-        let size = 3;
-        while (size < 12) {
-          const code3 = body.charCodeAt(position + size++);
-          if (code3 === 125) {
-            if (size < 5 || !isUnicodeScalarValue(point)) {
-              break;
-            }
-            return {
-              value: String.fromCodePoint(point),
-              size,
-            };
-          }
-          point = (point << 4) | readHexDigit(code3);
-          if (point < 0) {
-            break;
-          }
-        }
-        throw syntaxError$1(
-          lexer.source,
-          position,
-          `Invalid Unicode escape sequence: "${body.slice(
-            position,
-            position + size
-          )}".`
-        );
-      }
-      function readEscapedUnicodeFixedWidth(lexer, position) {
-        const body = lexer.source.body;
-        const code3 = read16BitHexCode(body, position + 2);
-        if (isUnicodeScalarValue(code3)) {
-          return {
-            value: String.fromCodePoint(code3),
-            size: 6,
-          };
-        }
-        if (isLeadingSurrogate(code3)) {
-          if (
-            body.charCodeAt(position + 6) === 92 &&
-            body.charCodeAt(position + 7) === 117
-          ) {
-            const trailingCode = read16BitHexCode(body, position + 8);
-            if (isTrailingSurrogate(trailingCode)) {
-              return {
-                value: String.fromCodePoint(code3, trailingCode),
-                size: 12,
-              };
-            }
-          }
-        }
-        throw syntaxError$1(
-          lexer.source,
-          position,
-          `Invalid Unicode escape sequence: "${body.slice(
-            position,
-            position + 6
-          )}".`
-        );
-      }
-      function read16BitHexCode(body, position) {
-        return (
-          (readHexDigit(body.charCodeAt(position)) << 12) |
-          (readHexDigit(body.charCodeAt(position + 1)) << 8) |
-          (readHexDigit(body.charCodeAt(position + 2)) << 4) |
-          readHexDigit(body.charCodeAt(position + 3))
-        );
-      }
-      function readHexDigit(code3) {
-        return code3 >= 48 && code3 <= 57
-          ? code3 - 48
-          : code3 >= 65 && code3 <= 70
-          ? code3 - 55
-          : code3 >= 97 && code3 <= 102
-          ? code3 - 87
-          : -1;
-      }
-      function readEscapedCharacter(lexer, position) {
-        const body = lexer.source.body;
-        const code3 = body.charCodeAt(position + 1);
-        switch (code3) {
-          case 34:
-            return {
-              value: '"',
-              size: 2,
-            };
-          case 92:
-            return {
-              value: "\\",
-              size: 2,
-            };
-          case 47:
-            return {
-              value: "/",
-              size: 2,
-            };
-          case 98:
-            return {
-              value: "\b",
-              size: 2,
-            };
-          case 102:
-            return {
-              value: "\f",
-              size: 2,
-            };
-          case 110:
-            return {
-              value: "\n",
-              size: 2,
-            };
-          case 114:
-            return {
-              value: "\r",
-              size: 2,
-            };
-          case 116:
-            return {
-              value: "	",
-              size: 2,
-            };
-        }
-        throw syntaxError$1(
-          lexer.source,
-          position,
-          `Invalid character escape sequence: "${body.slice(
-            position,
-            position + 2
-          )}".`
-        );
-      }
-      function readBlockString(lexer, start2) {
-        const body = lexer.source.body;
-        const bodyLength = body.length;
-        let lineStart = lexer.lineStart;
-        let position = start2 + 3;
-        let chunkStart = position;
-        let currentLine = "";
-        const blockLines = [];
-        while (position < bodyLength) {
-          const code3 = body.charCodeAt(position);
-          if (
-            code3 === 34 &&
-            body.charCodeAt(position + 1) === 34 &&
-            body.charCodeAt(position + 2) === 34
-          ) {
-            currentLine += body.slice(chunkStart, position);
-            blockLines.push(currentLine);
-            const token2 = createToken(
-              lexer,
-              TokenKind.BLOCK_STRING,
-              start2,
-              position + 3,
-              dedentBlockStringLines(blockLines).join("\n")
-            );
-            lexer.line += blockLines.length - 1;
-            lexer.lineStart = lineStart;
-            return token2;
-          }
-          if (
-            code3 === 92 &&
-            body.charCodeAt(position + 1) === 34 &&
-            body.charCodeAt(position + 2) === 34 &&
-            body.charCodeAt(position + 3) === 34
-          ) {
-            currentLine += body.slice(chunkStart, position);
-            chunkStart = position + 1;
-            position += 4;
-            continue;
-          }
-          if (code3 === 10 || code3 === 13) {
-            currentLine += body.slice(chunkStart, position);
-            blockLines.push(currentLine);
-            if (code3 === 13 && body.charCodeAt(position + 1) === 10) {
-              position += 2;
-            } else {
-              ++position;
-            }
-            currentLine = "";
-            chunkStart = position;
-            lineStart = position;
-            continue;
-          }
-          if (isUnicodeScalarValue(code3)) {
-            ++position;
-          } else if (isSupplementaryCodePoint(body, position)) {
-            position += 2;
-          } else {
-            throw syntaxError$1(
-              lexer.source,
-              position,
-              `Invalid character within String: ${printCodePointAt(
-                lexer,
-                position
-              )}.`
-            );
-          }
-        }
-        throw syntaxError$1(lexer.source, position, "Unterminated string.");
-      }
-      function readName(lexer, start2) {
-        const body = lexer.source.body;
-        const bodyLength = body.length;
-        let position = start2 + 1;
-        while (position < bodyLength) {
-          const code3 = body.charCodeAt(position);
-          if (isNameContinue(code3)) {
-            ++position;
-          } else {
-            break;
-          }
-        }
-        return createToken(
-          lexer,
-          TokenKind.NAME,
-          start2,
-          position,
-          body.slice(start2, position)
-        );
-      }
-      const MAX_ARRAY_LENGTH$1 = 10;
-      const MAX_RECURSIVE_DEPTH$2 = 2;
-      function inspect$2(value) {
-        return formatValue$2(value, []);
-      }
-      function formatValue$2(value, seenValues) {
-        switch (typeof value) {
-          case "string":
-            return JSON.stringify(value);
-          case "function":
-            return value.name ? `[function ${value.name}]` : "[function]";
-          case "object":
-            return formatObjectValue$2(value, seenValues);
-          default:
-            return String(value);
-        }
-      }
-      function formatObjectValue$2(value, previouslySeenValues) {
-        if (value === null) {
-          return "null";
-        }
-        if (previouslySeenValues.includes(value)) {
-          return "[Circular]";
-        }
-        const seenValues = [...previouslySeenValues, value];
-        if (isJSONable$2(value)) {
-          const jsonValue = value.toJSON();
-          if (jsonValue !== value) {
-            return typeof jsonValue === "string"
-              ? jsonValue
-              : formatValue$2(jsonValue, seenValues);
-          }
-        } else if (Array.isArray(value)) {
-          return formatArray$2(value, seenValues);
-        }
-        return formatObject$2(value, seenValues);
-      }
-      function isJSONable$2(value) {
-        return typeof value.toJSON === "function";
-      }
-      function formatObject$2(object, seenValues) {
-        const entries = Object.entries(object);
-        if (entries.length === 0) {
-          return "{}";
-        }
-        if (seenValues.length > MAX_RECURSIVE_DEPTH$2) {
-          return "[" + getObjectTag$2(object) + "]";
-        }
-        const properties = entries.map(
-          ([key, value]) => key + ": " + formatValue$2(value, seenValues)
-        );
-        return "{ " + properties.join(", ") + " }";
-      }
-      function formatArray$2(array, seenValues) {
-        if (array.length === 0) {
-          return "[]";
-        }
-        if (seenValues.length > MAX_RECURSIVE_DEPTH$2) {
-          return "[Array]";
-        }
-        const len = Math.min(MAX_ARRAY_LENGTH$1, array.length);
-        const remaining = array.length - len;
-        const items = [];
-        for (let i = 0; i < len; ++i) {
-          items.push(formatValue$2(array[i], seenValues));
-        }
-        if (remaining === 1) {
-          items.push("... 1 more item");
-        } else if (remaining > 1) {
-          items.push(`... ${remaining} more items`);
-        }
-        return "[" + items.join(", ") + "]";
-      }
-      function getObjectTag$2(object) {
-        const tag = Object.prototype.toString
-          .call(object)
-          .replace(/^\[object /, "")
-          .replace(/]$/, "");
-        if (tag === "Object" && typeof object.constructor === "function") {
-          const name2 = object.constructor.name;
-          if (typeof name2 === "string" && name2 !== "") {
-            return name2;
-          }
-        }
-        return tag;
-      }
-      const instanceOf = function instanceOf2(value, constructor) {
-        return value instanceof constructor;
-      };
-      class Source {
-        constructor(
-          body,
-          name2 = "GraphQL request",
-          locationOffset = {
-            line: 1,
-            column: 1,
-          }
-        ) {
-          typeof body === "string" ||
-            devAssert$1(
-              false,
-              `Body must be a string. Received: ${inspect$2(body)}.`
-            );
-          this.body = body;
-          this.name = name2;
-          this.locationOffset = locationOffset;
-          this.locationOffset.line > 0 ||
-            devAssert$1(
-              false,
-              "line in locationOffset is 1-indexed and must be positive."
-            );
-          this.locationOffset.column > 0 ||
-            devAssert$1(
-              false,
-              "column in locationOffset is 1-indexed and must be positive."
-            );
-        }
-        get [Symbol.toStringTag]() {
-          return "Source";
-        }
-      }
-      function isSource(source) {
-        return instanceOf(source, Source);
-      }
-      function parse$1(source, options) {
-        const parser = new Parser(source, options);
-        return parser.parseDocument();
-      }
-      function parseValue$1(source, options) {
-        const parser = new Parser(source, options);
-        parser.expectToken(TokenKind.SOF);
-        const value = parser.parseValueLiteral(false);
-        parser.expectToken(TokenKind.EOF);
-        return value;
-      }
-      function parseConstValue(source, options) {
-        const parser = new Parser(source, options);
-        parser.expectToken(TokenKind.SOF);
-        const value = parser.parseConstValueLiteral();
-        parser.expectToken(TokenKind.EOF);
-        return value;
-      }
-      function parseType(source, options) {
-        const parser = new Parser(source, options);
-        parser.expectToken(TokenKind.SOF);
-        const type2 = parser.parseTypeReference();
-        parser.expectToken(TokenKind.EOF);
-        return type2;
-      }
-      class Parser {
-        constructor(source, options) {
-          const sourceObj = isSource(source) ? source : new Source(source);
-          this._lexer = new Lexer(sourceObj);
-          this._options = options;
-        }
-        parseName() {
-          const token2 = this.expectToken(TokenKind.NAME);
-          return this.node(token2, {
-            kind: Kind.NAME,
-            value: token2.value,
-          });
-        }
-        parseDocument() {
-          return this.node(this._lexer.token, {
-            kind: Kind.DOCUMENT,
-            definitions: this.many(
-              TokenKind.SOF,
-              this.parseDefinition,
-              TokenKind.EOF
-            ),
-          });
-        }
-        parseDefinition() {
-          if (this.peek(TokenKind.BRACE_L)) {
-            return this.parseOperationDefinition();
-          }
-          const hasDescription = this.peekDescription();
-          const keywordToken = hasDescription
-            ? this._lexer.lookahead()
-            : this._lexer.token;
-          if (keywordToken.kind === TokenKind.NAME) {
-            switch (keywordToken.value) {
-              case "schema":
-                return this.parseSchemaDefinition();
-              case "scalar":
-                return this.parseScalarTypeDefinition();
-              case "type":
-                return this.parseObjectTypeDefinition();
-              case "interface":
-                return this.parseInterfaceTypeDefinition();
-              case "union":
-                return this.parseUnionTypeDefinition();
-              case "enum":
-                return this.parseEnumTypeDefinition();
-              case "input":
-                return this.parseInputObjectTypeDefinition();
-              case "directive":
-                return this.parseDirectiveDefinition();
-            }
-            if (hasDescription) {
-              throw syntaxError$1(
-                this._lexer.source,
-                this._lexer.token.start,
-                "Unexpected description, descriptions are supported only on type definitions."
-              );
-            }
-            switch (keywordToken.value) {
-              case "query":
-              case "mutation":
-              case "subscription":
-                return this.parseOperationDefinition();
-              case "fragment":
-                return this.parseFragmentDefinition();
-              case "extend":
-                return this.parseTypeSystemExtension();
-            }
-          }
-          throw this.unexpected(keywordToken);
-        }
-        parseOperationDefinition() {
-          const start2 = this._lexer.token;
-          if (this.peek(TokenKind.BRACE_L)) {
-            return this.node(start2, {
-              kind: Kind.OPERATION_DEFINITION,
-              operation: OperationTypeNode.QUERY,
-              name: void 0,
-              variableDefinitions: [],
-              directives: [],
-              selectionSet: this.parseSelectionSet(),
-            });
-          }
-          const operation = this.parseOperationType();
-          let name2;
-          if (this.peek(TokenKind.NAME)) {
-            name2 = this.parseName();
-          }
-          return this.node(start2, {
-            kind: Kind.OPERATION_DEFINITION,
-            operation,
-            name: name2,
-            variableDefinitions: this.parseVariableDefinitions(),
-            directives: this.parseDirectives(false),
-            selectionSet: this.parseSelectionSet(),
-          });
-        }
-        parseOperationType() {
-          const operationToken = this.expectToken(TokenKind.NAME);
-          switch (operationToken.value) {
-            case "query":
-              return OperationTypeNode.QUERY;
-            case "mutation":
-              return OperationTypeNode.MUTATION;
-            case "subscription":
-              return OperationTypeNode.SUBSCRIPTION;
-          }
-          throw this.unexpected(operationToken);
-        }
-        parseVariableDefinitions() {
-          return this.optionalMany(
-            TokenKind.PAREN_L,
-            this.parseVariableDefinition,
-            TokenKind.PAREN_R
-          );
-        }
-        parseVariableDefinition() {
-          return this.node(this._lexer.token, {
-            kind: Kind.VARIABLE_DEFINITION,
-            variable: this.parseVariable(),
-            type:
-              (this.expectToken(TokenKind.COLON), this.parseTypeReference()),
-            defaultValue: this.expectOptionalToken(TokenKind.EQUALS)
-              ? this.parseConstValueLiteral()
-              : void 0,
-            directives: this.parseConstDirectives(),
-          });
-        }
-        parseVariable() {
-          const start2 = this._lexer.token;
-          this.expectToken(TokenKind.DOLLAR);
-          return this.node(start2, {
-            kind: Kind.VARIABLE,
-            name: this.parseName(),
-          });
-        }
-        parseSelectionSet() {
-          return this.node(this._lexer.token, {
-            kind: Kind.SELECTION_SET,
-            selections: this.many(
-              TokenKind.BRACE_L,
-              this.parseSelection,
-              TokenKind.BRACE_R
-            ),
-          });
-        }
-        parseSelection() {
-          return this.peek(TokenKind.SPREAD)
-            ? this.parseFragment()
-            : this.parseField();
-        }
-        parseField() {
-          const start2 = this._lexer.token;
-          const nameOrAlias = this.parseName();
-          let alias;
-          let name2;
-          if (this.expectOptionalToken(TokenKind.COLON)) {
-            alias = nameOrAlias;
-            name2 = this.parseName();
-          } else {
-            name2 = nameOrAlias;
-          }
-          return this.node(start2, {
-            kind: Kind.FIELD,
-            alias,
-            name: name2,
-            arguments: this.parseArguments(false),
-            directives: this.parseDirectives(false),
-            selectionSet: this.peek(TokenKind.BRACE_L)
-              ? this.parseSelectionSet()
-              : void 0,
-          });
-        }
-        parseArguments(isConst) {
-          const item = isConst ? this.parseConstArgument : this.parseArgument;
-          return this.optionalMany(TokenKind.PAREN_L, item, TokenKind.PAREN_R);
-        }
-        parseArgument(isConst = false) {
-          const start2 = this._lexer.token;
-          const name2 = this.parseName();
-          this.expectToken(TokenKind.COLON);
-          return this.node(start2, {
-            kind: Kind.ARGUMENT,
-            name: name2,
-            value: this.parseValueLiteral(isConst),
-          });
-        }
-        parseConstArgument() {
-          return this.parseArgument(true);
-        }
-        parseFragment() {
-          const start2 = this._lexer.token;
-          this.expectToken(TokenKind.SPREAD);
-          const hasTypeCondition = this.expectOptionalKeyword("on");
-          if (!hasTypeCondition && this.peek(TokenKind.NAME)) {
-            return this.node(start2, {
-              kind: Kind.FRAGMENT_SPREAD,
-              name: this.parseFragmentName(),
-              directives: this.parseDirectives(false),
-            });
-          }
-          return this.node(start2, {
-            kind: Kind.INLINE_FRAGMENT,
-            typeCondition: hasTypeCondition ? this.parseNamedType() : void 0,
-            directives: this.parseDirectives(false),
-            selectionSet: this.parseSelectionSet(),
-          });
-        }
-        parseFragmentDefinition() {
-          var _this$_options;
-          const start2 = this._lexer.token;
-          this.expectKeyword("fragment");
-          if (
-            ((_this$_options = this._options) === null ||
-            _this$_options === void 0
-              ? void 0
-              : _this$_options.allowLegacyFragmentVariables) === true
-          ) {
-            return this.node(start2, {
-              kind: Kind.FRAGMENT_DEFINITION,
-              name: this.parseFragmentName(),
-              variableDefinitions: this.parseVariableDefinitions(),
-              typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
-              directives: this.parseDirectives(false),
-              selectionSet: this.parseSelectionSet(),
-            });
-          }
-          return this.node(start2, {
-            kind: Kind.FRAGMENT_DEFINITION,
-            name: this.parseFragmentName(),
-            typeCondition: (this.expectKeyword("on"), this.parseNamedType()),
-            directives: this.parseDirectives(false),
-            selectionSet: this.parseSelectionSet(),
-          });
-        }
-        parseFragmentName() {
-          if (this._lexer.token.value === "on") {
-            throw this.unexpected();
-          }
-          return this.parseName();
-        }
-        parseValueLiteral(isConst) {
-          const token2 = this._lexer.token;
-          switch (token2.kind) {
-            case TokenKind.BRACKET_L:
-              return this.parseList(isConst);
-            case TokenKind.BRACE_L:
-              return this.parseObject(isConst);
-            case TokenKind.INT:
-              this._lexer.advance();
-              return this.node(token2, {
-                kind: Kind.INT,
-                value: token2.value,
-              });
-            case TokenKind.FLOAT:
-              this._lexer.advance();
-              return this.node(token2, {
-                kind: Kind.FLOAT,
-                value: token2.value,
-              });
-            case TokenKind.STRING:
-            case TokenKind.BLOCK_STRING:
-              return this.parseStringLiteral();
-            case TokenKind.NAME:
-              this._lexer.advance();
-              switch (token2.value) {
-                case "true":
-                  return this.node(token2, {
-                    kind: Kind.BOOLEAN,
-                    value: true,
-                  });
-                case "false":
-                  return this.node(token2, {
-                    kind: Kind.BOOLEAN,
-                    value: false,
-                  });
-                case "null":
-                  return this.node(token2, {
-                    kind: Kind.NULL,
-                  });
-                default:
-                  return this.node(token2, {
-                    kind: Kind.ENUM,
-                    value: token2.value,
-                  });
-              }
-            case TokenKind.DOLLAR:
-              if (isConst) {
-                this.expectToken(TokenKind.DOLLAR);
-                if (this._lexer.token.kind === TokenKind.NAME) {
-                  const varName = this._lexer.token.value;
-                  throw syntaxError$1(
-                    this._lexer.source,
-                    token2.start,
-                    `Unexpected variable "$${varName}" in constant value.`
-                  );
-                } else {
-                  throw this.unexpected(token2);
-                }
-              }
-              return this.parseVariable();
-            default:
-              throw this.unexpected();
-          }
-        }
-        parseConstValueLiteral() {
-          return this.parseValueLiteral(true);
-        }
-        parseStringLiteral() {
-          const token2 = this._lexer.token;
-          this._lexer.advance();
-          return this.node(token2, {
-            kind: Kind.STRING,
-            value: token2.value,
-            block: token2.kind === TokenKind.BLOCK_STRING,
-          });
-        }
-        parseList(isConst) {
-          const item = () => this.parseValueLiteral(isConst);
-          return this.node(this._lexer.token, {
-            kind: Kind.LIST,
-            values: this.any(TokenKind.BRACKET_L, item, TokenKind.BRACKET_R),
-          });
-        }
-        parseObject(isConst) {
-          const item = () => this.parseObjectField(isConst);
-          return this.node(this._lexer.token, {
-            kind: Kind.OBJECT,
-            fields: this.any(TokenKind.BRACE_L, item, TokenKind.BRACE_R),
-          });
-        }
-        parseObjectField(isConst) {
-          const start2 = this._lexer.token;
-          const name2 = this.parseName();
-          this.expectToken(TokenKind.COLON);
-          return this.node(start2, {
-            kind: Kind.OBJECT_FIELD,
-            name: name2,
-            value: this.parseValueLiteral(isConst),
-          });
-        }
-        parseDirectives(isConst) {
-          const directives = [];
-          while (this.peek(TokenKind.AT)) {
-            directives.push(this.parseDirective(isConst));
-          }
-          return directives;
-        }
-        parseConstDirectives() {
-          return this.parseDirectives(true);
-        }
-        parseDirective(isConst) {
-          const start2 = this._lexer.token;
-          this.expectToken(TokenKind.AT);
-          return this.node(start2, {
-            kind: Kind.DIRECTIVE,
-            name: this.parseName(),
-            arguments: this.parseArguments(isConst),
-          });
-        }
-        parseTypeReference() {
-          const start2 = this._lexer.token;
-          let type2;
-          if (this.expectOptionalToken(TokenKind.BRACKET_L)) {
-            const innerType = this.parseTypeReference();
-            this.expectToken(TokenKind.BRACKET_R);
-            type2 = this.node(start2, {
-              kind: Kind.LIST_TYPE,
-              type: innerType,
-            });
-          } else {
-            type2 = this.parseNamedType();
-          }
-          if (this.expectOptionalToken(TokenKind.BANG)) {
-            return this.node(start2, {
-              kind: Kind.NON_NULL_TYPE,
-              type: type2,
-            });
-          }
-          return type2;
-        }
-        parseNamedType() {
-          return this.node(this._lexer.token, {
-            kind: Kind.NAMED_TYPE,
-            name: this.parseName(),
-          });
-        }
-        peekDescription() {
-          return (
-            this.peek(TokenKind.STRING) || this.peek(TokenKind.BLOCK_STRING)
-          );
-        }
-        parseDescription() {
-          if (this.peekDescription()) {
-            return this.parseStringLiteral();
-          }
-        }
-        parseSchemaDefinition() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          this.expectKeyword("schema");
-          const directives = this.parseConstDirectives();
-          const operationTypes = this.many(
-            TokenKind.BRACE_L,
-            this.parseOperationTypeDefinition,
-            TokenKind.BRACE_R
-          );
-          return this.node(start2, {
-            kind: Kind.SCHEMA_DEFINITION,
-            description,
-            directives,
-            operationTypes,
-          });
-        }
-        parseOperationTypeDefinition() {
-          const start2 = this._lexer.token;
-          const operation = this.parseOperationType();
-          this.expectToken(TokenKind.COLON);
-          const type2 = this.parseNamedType();
-          return this.node(start2, {
-            kind: Kind.OPERATION_TYPE_DEFINITION,
-            operation,
-            type: type2,
-          });
-        }
-        parseScalarTypeDefinition() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          this.expectKeyword("scalar");
-          const name2 = this.parseName();
-          const directives = this.parseConstDirectives();
-          return this.node(start2, {
-            kind: Kind.SCALAR_TYPE_DEFINITION,
-            description,
-            name: name2,
-            directives,
-          });
-        }
-        parseObjectTypeDefinition() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          this.expectKeyword("type");
-          const name2 = this.parseName();
-          const interfaces = this.parseImplementsInterfaces();
-          const directives = this.parseConstDirectives();
-          const fields = this.parseFieldsDefinition();
-          return this.node(start2, {
-            kind: Kind.OBJECT_TYPE_DEFINITION,
-            description,
-            name: name2,
-            interfaces,
-            directives,
-            fields,
-          });
-        }
-        parseImplementsInterfaces() {
-          return this.expectOptionalKeyword("implements")
-            ? this.delimitedMany(TokenKind.AMP, this.parseNamedType)
-            : [];
-        }
-        parseFieldsDefinition() {
-          return this.optionalMany(
-            TokenKind.BRACE_L,
-            this.parseFieldDefinition,
-            TokenKind.BRACE_R
-          );
-        }
-        parseFieldDefinition() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          const name2 = this.parseName();
-          const args = this.parseArgumentDefs();
-          this.expectToken(TokenKind.COLON);
-          const type2 = this.parseTypeReference();
-          const directives = this.parseConstDirectives();
-          return this.node(start2, {
-            kind: Kind.FIELD_DEFINITION,
-            description,
-            name: name2,
-            arguments: args,
-            type: type2,
-            directives,
-          });
-        }
-        parseArgumentDefs() {
-          return this.optionalMany(
-            TokenKind.PAREN_L,
-            this.parseInputValueDef,
-            TokenKind.PAREN_R
-          );
-        }
-        parseInputValueDef() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          const name2 = this.parseName();
-          this.expectToken(TokenKind.COLON);
-          const type2 = this.parseTypeReference();
-          let defaultValue2;
-          if (this.expectOptionalToken(TokenKind.EQUALS)) {
-            defaultValue2 = this.parseConstValueLiteral();
-          }
-          const directives = this.parseConstDirectives();
-          return this.node(start2, {
-            kind: Kind.INPUT_VALUE_DEFINITION,
-            description,
-            name: name2,
-            type: type2,
-            defaultValue: defaultValue2,
-            directives,
-          });
-        }
-        parseInterfaceTypeDefinition() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          this.expectKeyword("interface");
-          const name2 = this.parseName();
-          const interfaces = this.parseImplementsInterfaces();
-          const directives = this.parseConstDirectives();
-          const fields = this.parseFieldsDefinition();
-          return this.node(start2, {
-            kind: Kind.INTERFACE_TYPE_DEFINITION,
-            description,
-            name: name2,
-            interfaces,
-            directives,
-            fields,
-          });
-        }
-        parseUnionTypeDefinition() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          this.expectKeyword("union");
-          const name2 = this.parseName();
-          const directives = this.parseConstDirectives();
-          const types = this.parseUnionMemberTypes();
-          return this.node(start2, {
-            kind: Kind.UNION_TYPE_DEFINITION,
-            description,
-            name: name2,
-            directives,
-            types,
-          });
-        }
-        parseUnionMemberTypes() {
-          return this.expectOptionalToken(TokenKind.EQUALS)
-            ? this.delimitedMany(TokenKind.PIPE, this.parseNamedType)
-            : [];
-        }
-        parseEnumTypeDefinition() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          this.expectKeyword("enum");
-          const name2 = this.parseName();
-          const directives = this.parseConstDirectives();
-          const values = this.parseEnumValuesDefinition();
-          return this.node(start2, {
-            kind: Kind.ENUM_TYPE_DEFINITION,
-            description,
-            name: name2,
-            directives,
-            values,
-          });
-        }
-        parseEnumValuesDefinition() {
-          return this.optionalMany(
-            TokenKind.BRACE_L,
-            this.parseEnumValueDefinition,
-            TokenKind.BRACE_R
-          );
-        }
-        parseEnumValueDefinition() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          const name2 = this.parseEnumValueName();
-          const directives = this.parseConstDirectives();
-          return this.node(start2, {
-            kind: Kind.ENUM_VALUE_DEFINITION,
-            description,
-            name: name2,
-            directives,
-          });
-        }
-        parseEnumValueName() {
-          if (
-            this._lexer.token.value === "true" ||
-            this._lexer.token.value === "false" ||
-            this._lexer.token.value === "null"
-          ) {
-            throw syntaxError$1(
-              this._lexer.source,
-              this._lexer.token.start,
-              `${getTokenDesc(
-                this._lexer.token
-              )} is reserved and cannot be used for an enum value.`
-            );
-          }
-          return this.parseName();
-        }
-        parseInputObjectTypeDefinition() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          this.expectKeyword("input");
-          const name2 = this.parseName();
-          const directives = this.parseConstDirectives();
-          const fields = this.parseInputFieldsDefinition();
-          return this.node(start2, {
-            kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
-            description,
-            name: name2,
-            directives,
-            fields,
-          });
-        }
-        parseInputFieldsDefinition() {
-          return this.optionalMany(
-            TokenKind.BRACE_L,
-            this.parseInputValueDef,
-            TokenKind.BRACE_R
-          );
-        }
-        parseTypeSystemExtension() {
-          const keywordToken = this._lexer.lookahead();
-          if (keywordToken.kind === TokenKind.NAME) {
-            switch (keywordToken.value) {
-              case "schema":
-                return this.parseSchemaExtension();
-              case "scalar":
-                return this.parseScalarTypeExtension();
-              case "type":
-                return this.parseObjectTypeExtension();
-              case "interface":
-                return this.parseInterfaceTypeExtension();
-              case "union":
-                return this.parseUnionTypeExtension();
-              case "enum":
-                return this.parseEnumTypeExtension();
-              case "input":
-                return this.parseInputObjectTypeExtension();
-            }
-          }
-          throw this.unexpected(keywordToken);
-        }
-        parseSchemaExtension() {
-          const start2 = this._lexer.token;
-          this.expectKeyword("extend");
-          this.expectKeyword("schema");
-          const directives = this.parseConstDirectives();
-          const operationTypes = this.optionalMany(
-            TokenKind.BRACE_L,
-            this.parseOperationTypeDefinition,
-            TokenKind.BRACE_R
-          );
-          if (directives.length === 0 && operationTypes.length === 0) {
-            throw this.unexpected();
-          }
-          return this.node(start2, {
-            kind: Kind.SCHEMA_EXTENSION,
-            directives,
-            operationTypes,
-          });
-        }
-        parseScalarTypeExtension() {
-          const start2 = this._lexer.token;
-          this.expectKeyword("extend");
-          this.expectKeyword("scalar");
-          const name2 = this.parseName();
-          const directives = this.parseConstDirectives();
-          if (directives.length === 0) {
-            throw this.unexpected();
-          }
-          return this.node(start2, {
-            kind: Kind.SCALAR_TYPE_EXTENSION,
-            name: name2,
-            directives,
-          });
-        }
-        parseObjectTypeExtension() {
-          const start2 = this._lexer.token;
-          this.expectKeyword("extend");
-          this.expectKeyword("type");
-          const name2 = this.parseName();
-          const interfaces = this.parseImplementsInterfaces();
-          const directives = this.parseConstDirectives();
-          const fields = this.parseFieldsDefinition();
-          if (
-            interfaces.length === 0 &&
-            directives.length === 0 &&
-            fields.length === 0
-          ) {
-            throw this.unexpected();
-          }
-          return this.node(start2, {
-            kind: Kind.OBJECT_TYPE_EXTENSION,
-            name: name2,
-            interfaces,
-            directives,
-            fields,
-          });
-        }
-        parseInterfaceTypeExtension() {
-          const start2 = this._lexer.token;
-          this.expectKeyword("extend");
-          this.expectKeyword("interface");
-          const name2 = this.parseName();
-          const interfaces = this.parseImplementsInterfaces();
-          const directives = this.parseConstDirectives();
-          const fields = this.parseFieldsDefinition();
-          if (
-            interfaces.length === 0 &&
-            directives.length === 0 &&
-            fields.length === 0
-          ) {
-            throw this.unexpected();
-          }
-          return this.node(start2, {
-            kind: Kind.INTERFACE_TYPE_EXTENSION,
-            name: name2,
-            interfaces,
-            directives,
-            fields,
-          });
-        }
-        parseUnionTypeExtension() {
-          const start2 = this._lexer.token;
-          this.expectKeyword("extend");
-          this.expectKeyword("union");
-          const name2 = this.parseName();
-          const directives = this.parseConstDirectives();
-          const types = this.parseUnionMemberTypes();
-          if (directives.length === 0 && types.length === 0) {
-            throw this.unexpected();
-          }
-          return this.node(start2, {
-            kind: Kind.UNION_TYPE_EXTENSION,
-            name: name2,
-            directives,
-            types,
-          });
-        }
-        parseEnumTypeExtension() {
-          const start2 = this._lexer.token;
-          this.expectKeyword("extend");
-          this.expectKeyword("enum");
-          const name2 = this.parseName();
-          const directives = this.parseConstDirectives();
-          const values = this.parseEnumValuesDefinition();
-          if (directives.length === 0 && values.length === 0) {
-            throw this.unexpected();
-          }
-          return this.node(start2, {
-            kind: Kind.ENUM_TYPE_EXTENSION,
-            name: name2,
-            directives,
-            values,
-          });
-        }
-        parseInputObjectTypeExtension() {
-          const start2 = this._lexer.token;
-          this.expectKeyword("extend");
-          this.expectKeyword("input");
-          const name2 = this.parseName();
-          const directives = this.parseConstDirectives();
-          const fields = this.parseInputFieldsDefinition();
-          if (directives.length === 0 && fields.length === 0) {
-            throw this.unexpected();
-          }
-          return this.node(start2, {
-            kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,
-            name: name2,
-            directives,
-            fields,
-          });
-        }
-        parseDirectiveDefinition() {
-          const start2 = this._lexer.token;
-          const description = this.parseDescription();
-          this.expectKeyword("directive");
-          this.expectToken(TokenKind.AT);
-          const name2 = this.parseName();
-          const args = this.parseArgumentDefs();
-          const repeatable = this.expectOptionalKeyword("repeatable");
-          this.expectKeyword("on");
-          const locations = this.parseDirectiveLocations();
-          return this.node(start2, {
-            kind: Kind.DIRECTIVE_DEFINITION,
-            description,
-            name: name2,
-            arguments: args,
-            repeatable,
-            locations,
-          });
-        }
-        parseDirectiveLocations() {
-          return this.delimitedMany(
-            TokenKind.PIPE,
-            this.parseDirectiveLocation
-          );
-        }
-        parseDirectiveLocation() {
-          const start2 = this._lexer.token;
-          const name2 = this.parseName();
-          if (
-            Object.prototype.hasOwnProperty.call(DirectiveLocation, name2.value)
-          ) {
-            return name2;
-          }
-          throw this.unexpected(start2);
-        }
-        node(startToken, node) {
-          var _this$_options2;
-          if (
-            ((_this$_options2 = this._options) === null ||
-            _this$_options2 === void 0
-              ? void 0
-              : _this$_options2.noLocation) !== true
-          ) {
-            node.loc = new Location$1(
-              startToken,
-              this._lexer.lastToken,
-              this._lexer.source
-            );
-          }
-          return node;
-        }
-        peek(kind2) {
-          return this._lexer.token.kind === kind2;
-        }
-        expectToken(kind2) {
-          const token2 = this._lexer.token;
-          if (token2.kind === kind2) {
-            this._lexer.advance();
-            return token2;
-          }
-          throw syntaxError$1(
-            this._lexer.source,
-            token2.start,
-            `Expected ${getTokenKindDesc(kind2)}, found ${getTokenDesc(
-              token2
-            )}.`
-          );
-        }
-        expectOptionalToken(kind2) {
-          const token2 = this._lexer.token;
-          if (token2.kind === kind2) {
-            this._lexer.advance();
-            return true;
-          }
-          return false;
-        }
-        expectKeyword(value) {
-          const token2 = this._lexer.token;
-          if (token2.kind === TokenKind.NAME && token2.value === value) {
-            this._lexer.advance();
-          } else {
-            throw syntaxError$1(
-              this._lexer.source,
-              token2.start,
-              `Expected "${value}", found ${getTokenDesc(token2)}.`
-            );
-          }
-        }
-        expectOptionalKeyword(value) {
-          const token2 = this._lexer.token;
-          if (token2.kind === TokenKind.NAME && token2.value === value) {
-            this._lexer.advance();
-            return true;
-          }
-          return false;
-        }
-        unexpected(atToken) {
-          const token2 =
-            atToken !== null && atToken !== void 0
-              ? atToken
-              : this._lexer.token;
-          return syntaxError$1(
-            this._lexer.source,
-            token2.start,
-            `Unexpected ${getTokenDesc(token2)}.`
-          );
-        }
-        any(openKind, parseFn, closeKind) {
-          this.expectToken(openKind);
-          const nodes = [];
-          while (!this.expectOptionalToken(closeKind)) {
-            nodes.push(parseFn.call(this));
-          }
-          return nodes;
-        }
-        optionalMany(openKind, parseFn, closeKind) {
-          if (this.expectOptionalToken(openKind)) {
-            const nodes = [];
-            do {
-              nodes.push(parseFn.call(this));
-            } while (!this.expectOptionalToken(closeKind));
-            return nodes;
-          }
-          return [];
-        }
-        many(openKind, parseFn, closeKind) {
-          this.expectToken(openKind);
-          const nodes = [];
-          do {
-            nodes.push(parseFn.call(this));
-          } while (!this.expectOptionalToken(closeKind));
-          return nodes;
-        }
-        delimitedMany(delimiterKind, parseFn) {
-          this.expectOptionalToken(delimiterKind);
-          const nodes = [];
-          do {
-            nodes.push(parseFn.call(this));
-          } while (this.expectOptionalToken(delimiterKind));
-          return nodes;
-        }
-      }
-      function getTokenDesc(token2) {
-        const value = token2.value;
-        return (
-          getTokenKindDesc(token2.kind) + (value != null ? ` "${value}"` : "")
-        );
-      }
-      function getTokenKindDesc(kind2) {
-        return isPunctuatorTokenKind(kind2) ? `"${kind2}"` : kind2;
-      }
-      const MAX_SUGGESTIONS$1 = 5;
-      function didYouMean$1(firstArg, secondArg) {
-        const [subMessage, suggestionsArg] = secondArg
-          ? [firstArg, secondArg]
-          : [void 0, firstArg];
-        let message = " Did you mean ";
-        if (subMessage) {
-          message += subMessage + " ";
-        }
-        const suggestions = suggestionsArg.map((x2) => `"${x2}"`);
-        switch (suggestions.length) {
-          case 0:
-            return "";
-          case 1:
-            return message + suggestions[0] + "?";
-          case 2:
-            return message + suggestions[0] + " or " + suggestions[1] + "?";
-        }
-        const selected = suggestions.slice(0, MAX_SUGGESTIONS$1);
-        const lastItem = selected.pop();
-        return message + selected.join(", ") + ", or " + lastItem + "?";
-      }
-      function identityFunc(x2) {
-        return x2;
-      }
-      function keyMap$1(list3, keyFn) {
-        const result2 = /* @__PURE__ */ Object.create(null);
-        for (const item of list3) {
-          result2[keyFn(item)] = item;
-        }
-        return result2;
-      }
-      function keyValMap(list3, keyFn, valFn) {
-        const result2 = /* @__PURE__ */ Object.create(null);
-        for (const item of list3) {
-          result2[keyFn(item)] = valFn(item);
-        }
-        return result2;
-      }
-      function mapValue(map2, fn) {
-        const result2 = /* @__PURE__ */ Object.create(null);
-        for (const key of Object.keys(map2)) {
-          result2[key] = fn(map2[key], key);
-        }
-        return result2;
-      }
-      function naturalCompare$1(aStr, bStr) {
-        let aIndex = 0;
-        let bIndex = 0;
-        while (aIndex < aStr.length && bIndex < bStr.length) {
-          let aChar = aStr.charCodeAt(aIndex);
-          let bChar = bStr.charCodeAt(bIndex);
-          if (isDigit$1(aChar) && isDigit$1(bChar)) {
-            let aNum = 0;
-            do {
-              ++aIndex;
-              aNum = aNum * 10 + aChar - DIGIT_0$1;
-              aChar = aStr.charCodeAt(aIndex);
-            } while (isDigit$1(aChar) && aNum > 0);
-            let bNum = 0;
-            do {
-              ++bIndex;
-              bNum = bNum * 10 + bChar - DIGIT_0$1;
-              bChar = bStr.charCodeAt(bIndex);
-            } while (isDigit$1(bChar) && bNum > 0);
-            if (aNum < bNum) {
-              return -1;
-            }
-            if (aNum > bNum) {
-              return 1;
-            }
-          } else {
-            if (aChar < bChar) {
-              return -1;
-            }
-            if (aChar > bChar) {
-              return 1;
-            }
-            ++aIndex;
-            ++bIndex;
-          }
-        }
-        return aStr.length - bStr.length;
-      }
-      const DIGIT_0$1 = 48;
-      const DIGIT_9$1 = 57;
-      function isDigit$1(code3) {
-        return !isNaN(code3) && DIGIT_0$1 <= code3 && code3 <= DIGIT_9$1;
-      }
-      function suggestionList$1(input, options) {
-        const optionsByDistance = /* @__PURE__ */ Object.create(null);
-        const lexicalDistance2 = new LexicalDistance$1(input);
-        const threshold = Math.floor(input.length * 0.4) + 1;
-        for (const option of options) {
-          const distance = lexicalDistance2.measure(option, threshold);
-          if (distance !== void 0) {
-            optionsByDistance[option] = distance;
-          }
-        }
-        return Object.keys(optionsByDistance).sort((a, b) => {
-          const distanceDiff = optionsByDistance[a] - optionsByDistance[b];
-          return distanceDiff !== 0 ? distanceDiff : naturalCompare$1(a, b);
-        });
-      }
-      class LexicalDistance$1 {
-        constructor(input) {
-          this._input = input;
-          this._inputLowerCase = input.toLowerCase();
-          this._inputArray = stringToArray$1(this._inputLowerCase);
-          this._rows = [
-            new Array(input.length + 1).fill(0),
-            new Array(input.length + 1).fill(0),
-            new Array(input.length + 1).fill(0),
-          ];
-        }
-        measure(option, threshold) {
-          if (this._input === option) {
-            return 0;
-          }
-          const optionLowerCase = option.toLowerCase();
-          if (this._inputLowerCase === optionLowerCase) {
-            return 1;
-          }
-          let a = stringToArray$1(optionLowerCase);
-          let b = this._inputArray;
-          if (a.length < b.length) {
-            const tmp = a;
-            a = b;
-            b = tmp;
-          }
-          const aLength = a.length;
-          const bLength = b.length;
-          if (aLength - bLength > threshold) {
-            return void 0;
-          }
-          const rows = this._rows;
-          for (let j = 0; j <= bLength; j++) {
-            rows[0][j] = j;
-          }
-          for (let i = 1; i <= aLength; i++) {
-            const upRow = rows[(i - 1) % 3];
-            const currentRow = rows[i % 3];
-            let smallestCell = (currentRow[0] = i);
-            for (let j = 1; j <= bLength; j++) {
-              const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-              let currentCell = Math.min(
-                upRow[j] + 1,
-                currentRow[j - 1] + 1,
-                upRow[j - 1] + cost
-              );
-              if (
-                i > 1 &&
-                j > 1 &&
-                a[i - 1] === b[j - 2] &&
-                a[i - 2] === b[j - 1]
-              ) {
-                const doubleDiagonalCell = rows[(i - 2) % 3][j - 2];
-                currentCell = Math.min(currentCell, doubleDiagonalCell + 1);
-              }
-              if (currentCell < smallestCell) {
-                smallestCell = currentCell;
-              }
-              currentRow[j] = currentCell;
-            }
-            if (smallestCell > threshold) {
-              return void 0;
-            }
-          }
-          const distance = rows[aLength % 3][bLength];
-          return distance <= threshold ? distance : void 0;
-        }
-      }
-      function stringToArray$1(str) {
-        const strLength = str.length;
-        const array = new Array(strLength);
-        for (let i = 0; i < strLength; ++i) {
-          array[i] = str.charCodeAt(i);
-        }
-        return array;
-      }
-      function toObjMap(obj) {
-        if (obj == null) {
-          return /* @__PURE__ */ Object.create(null);
-        }
-        if (Object.getPrototypeOf(obj) === null) {
-          return obj;
-        }
-        const map2 = /* @__PURE__ */ Object.create(null);
-        for (const [key, value] of Object.entries(obj)) {
-          map2[key] = value;
-        }
-        return map2;
-      }
-      function printString(str) {
-        return `"${str.replace(escapedRegExp, escapedReplacer)}"`;
-      }
-      const escapedRegExp = /[\x00-\x1f\x22\x5c\x7f-\x9f]/g;
-      function escapedReplacer(str) {
-        return escapeSequences[str.charCodeAt(0)];
-      }
-      const escapeSequences = [
-        "\\u0000",
-        "\\u0001",
-        "\\u0002",
-        "\\u0003",
-        "\\u0004",
-        "\\u0005",
-        "\\u0006",
-        "\\u0007",
-        "\\b",
-        "\\t",
-        "\\n",
-        "\\u000B",
-        "\\f",
-        "\\r",
-        "\\u000E",
-        "\\u000F",
-        "\\u0010",
-        "\\u0011",
-        "\\u0012",
-        "\\u0013",
-        "\\u0014",
-        "\\u0015",
-        "\\u0016",
-        "\\u0017",
-        "\\u0018",
-        "\\u0019",
-        "\\u001A",
-        "\\u001B",
-        "\\u001C",
-        "\\u001D",
-        "\\u001E",
-        "\\u001F",
-        "",
-        "",
-        '\\"',
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "\\\\",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "",
-        "\\u007F",
-        "\\u0080",
-        "\\u0081",
-        "\\u0082",
-        "\\u0083",
-        "\\u0084",
-        "\\u0085",
-        "\\u0086",
-        "\\u0087",
-        "\\u0088",
-        "\\u0089",
-        "\\u008A",
-        "\\u008B",
-        "\\u008C",
-        "\\u008D",
-        "\\u008E",
-        "\\u008F",
-        "\\u0090",
-        "\\u0091",
-        "\\u0092",
-        "\\u0093",
-        "\\u0094",
-        "\\u0095",
-        "\\u0096",
-        "\\u0097",
-        "\\u0098",
-        "\\u0099",
-        "\\u009A",
-        "\\u009B",
-        "\\u009C",
-        "\\u009D",
-        "\\u009E",
-        "\\u009F",
-      ];
-      const BREAK = Object.freeze({});
-      function visit(root2, visitor, visitorKeys = QueryDocumentKeys) {
-        const enterLeaveMap = /* @__PURE__ */ new Map();
-        for (const kind2 of Object.values(Kind)) {
-          enterLeaveMap.set(kind2, getEnterLeaveForKind(visitor, kind2));
-        }
-        let stack = void 0;
-        let inArray = Array.isArray(root2);
-        let keys = [root2];
-        let index = -1;
-        let edits = [];
-        let node = root2;
-        let key = void 0;
-        let parent = void 0;
-        const path = [];
-        const ancestors = [];
-        do {
-          index++;
-          const isLeaving = index === keys.length;
-          const isEdited = isLeaving && edits.length !== 0;
-          if (isLeaving) {
-            key = ancestors.length === 0 ? void 0 : path[path.length - 1];
-            node = parent;
-            parent = ancestors.pop();
-            if (isEdited) {
-              if (inArray) {
-                node = node.slice();
-                let editOffset = 0;
-                for (const [editKey, editValue] of edits) {
-                  const arrayKey = editKey - editOffset;
-                  if (editValue === null) {
-                    node.splice(arrayKey, 1);
-                    editOffset++;
-                  } else {
-                    node[arrayKey] = editValue;
-                  }
-                }
-              } else {
-                node = Object.defineProperties(
-                  {},
-                  Object.getOwnPropertyDescriptors(node)
-                );
-                for (const [editKey, editValue] of edits) {
-                  node[editKey] = editValue;
-                }
-              }
-            }
-            index = stack.index;
-            keys = stack.keys;
-            edits = stack.edits;
-            inArray = stack.inArray;
-            stack = stack.prev;
-          } else if (parent) {
-            key = inArray ? index : keys[index];
-            node = parent[key];
-            if (node === null || node === void 0) {
-              continue;
-            }
-            path.push(key);
-          }
-          let result2;
-          if (!Array.isArray(node)) {
-            var _enterLeaveMap$get, _enterLeaveMap$get2;
-            isNode(node) ||
-              devAssert$1(false, `Invalid AST Node: ${inspect$2(node)}.`);
-            const visitFn = isLeaving
-              ? (_enterLeaveMap$get = enterLeaveMap.get(node.kind)) === null ||
-                _enterLeaveMap$get === void 0
-                ? void 0
-                : _enterLeaveMap$get.leave
-              : (_enterLeaveMap$get2 = enterLeaveMap.get(node.kind)) === null ||
-                _enterLeaveMap$get2 === void 0
-              ? void 0
-              : _enterLeaveMap$get2.enter;
-            result2 =
-              visitFn === null || visitFn === void 0
-                ? void 0
-                : visitFn.call(visitor, node, key, parent, path, ancestors);
-            if (result2 === BREAK) {
-              break;
-            }
-            if (result2 === false) {
-              if (!isLeaving) {
-                path.pop();
-                continue;
-              }
-            } else if (result2 !== void 0) {
-              edits.push([key, result2]);
-              if (!isLeaving) {
-                if (isNode(result2)) {
-                  node = result2;
-                } else {
-                  path.pop();
-                  continue;
-                }
-              }
-            }
-          }
-          if (result2 === void 0 && isEdited) {
-            edits.push([key, node]);
-          }
-          if (isLeaving) {
-            path.pop();
-          } else {
-            var _node$kind;
-            stack = {
-              inArray,
-              index,
-              keys,
-              edits,
-              prev: stack,
-            };
-            inArray = Array.isArray(node);
-            keys = inArray
-              ? node
-              : (_node$kind = visitorKeys[node.kind]) !== null &&
-                _node$kind !== void 0
-              ? _node$kind
-              : [];
-            index = -1;
-            edits = [];
-            if (parent) {
-              ancestors.push(parent);
-            }
-            parent = node;
-          }
-        } while (stack !== void 0);
-        if (edits.length !== 0) {
-          return edits[edits.length - 1][1];
-        }
-        return root2;
-      }
-      function visitInParallel(visitors) {
-        const skipping = new Array(visitors.length).fill(null);
-        const mergedVisitor = /* @__PURE__ */ Object.create(null);
-        for (const kind2 of Object.values(Kind)) {
-          let hasVisitor = false;
-          const enterList = new Array(visitors.length).fill(void 0);
-          const leaveList = new Array(visitors.length).fill(void 0);
-          for (let i = 0; i < visitors.length; ++i) {
-            const { enter, leave } = getEnterLeaveForKind(visitors[i], kind2);
-            hasVisitor || (hasVisitor = enter != null || leave != null);
-            enterList[i] = enter;
-            leaveList[i] = leave;
-          }
-          if (!hasVisitor) {
-            continue;
-          }
-          const mergedEnterLeave = {
-            enter(...args) {
-              const node = args[0];
-              for (let i = 0; i < visitors.length; i++) {
-                if (skipping[i] === null) {
-                  var _enterList$i;
-                  const result2 =
-                    (_enterList$i = enterList[i]) === null ||
-                    _enterList$i === void 0
-                      ? void 0
-                      : _enterList$i.apply(visitors[i], args);
-                  if (result2 === false) {
-                    skipping[i] = node;
-                  } else if (result2 === BREAK) {
-                    skipping[i] = BREAK;
-                  } else if (result2 !== void 0) {
-                    return result2;
-                  }
-                }
-              }
-            },
-            leave(...args) {
-              const node = args[0];
-              for (let i = 0; i < visitors.length; i++) {
-                if (skipping[i] === null) {
-                  var _leaveList$i;
-                  const result2 =
-                    (_leaveList$i = leaveList[i]) === null ||
-                    _leaveList$i === void 0
-                      ? void 0
-                      : _leaveList$i.apply(visitors[i], args);
-                  if (result2 === BREAK) {
-                    skipping[i] = BREAK;
-                  } else if (result2 !== void 0 && result2 !== false) {
-                    return result2;
-                  }
-                } else if (skipping[i] === node) {
-                  skipping[i] = null;
-                }
-              }
-            },
-          };
-          mergedVisitor[kind2] = mergedEnterLeave;
-        }
-        return mergedVisitor;
-      }
-      function getEnterLeaveForKind(visitor, kind2) {
-        const kindVisitor = visitor[kind2];
-        if (typeof kindVisitor === "object") {
-          return kindVisitor;
-        } else if (typeof kindVisitor === "function") {
-          return {
-            enter: kindVisitor,
-            leave: void 0,
-          };
-        }
-        return {
-          enter: visitor.enter,
-          leave: visitor.leave,
-        };
-      }
-      function getVisitFn(visitor, kind2, isLeaving) {
-        const { enter, leave } = getEnterLeaveForKind(visitor, kind2);
-        return isLeaving ? leave : enter;
-      }
-      function print(ast2) {
-        return visit(ast2, printDocASTReducer$1);
-      }
-      const MAX_LINE_LENGTH$1 = 80;
-      const printDocASTReducer$1 = {
-        Name: {
-          leave: (node) => node.value,
-        },
-        Variable: {
-          leave: (node) => "$" + node.name,
-        },
-        Document: {
-          leave: (node) => join$1(node.definitions, "\n\n"),
-        },
-        OperationDefinition: {
-          leave(node) {
-            const varDefs = wrap$1(
-              "(",
-              join$1(node.variableDefinitions, ", "),
-              ")"
-            );
-            const prefix = join$1(
-              [
-                node.operation,
-                join$1([node.name, varDefs]),
-                join$1(node.directives, " "),
-              ],
-              " "
-            );
-            return (prefix === "query" ? "" : prefix + " ") + node.selectionSet;
-          },
-        },
-        VariableDefinition: {
-          leave: ({
-            variable,
-            type: type2,
-            defaultValue: defaultValue2,
-            directives,
-          }) =>
-            variable +
-            ": " +
-            type2 +
-            wrap$1(" = ", defaultValue2) +
-            wrap$1(" ", join$1(directives, " ")),
-        },
-        SelectionSet: {
-          leave: ({ selections }) => block$3(selections),
-        },
-        Field: {
-          leave({
-            alias,
-            name: name2,
-            arguments: args,
-            directives,
-            selectionSet,
-          }) {
-            const prefix = wrap$1("", alias, ": ") + name2;
-            let argsLine = prefix + wrap$1("(", join$1(args, ", "), ")");
-            if (argsLine.length > MAX_LINE_LENGTH$1) {
-              argsLine =
-                prefix + wrap$1("(\n", indent$4(join$1(args, "\n")), "\n)");
-            }
-            return join$1(
-              [argsLine, join$1(directives, " "), selectionSet],
-              " "
-            );
-          },
-        },
-        Argument: {
-          leave: ({ name: name2, value }) => name2 + ": " + value,
-        },
-        FragmentSpread: {
-          leave: ({ name: name2, directives }) =>
-            "..." + name2 + wrap$1(" ", join$1(directives, " ")),
-        },
-        InlineFragment: {
-          leave: ({ typeCondition, directives, selectionSet }) =>
-            join$1(
-              [
-                "...",
-                wrap$1("on ", typeCondition),
-                join$1(directives, " "),
-                selectionSet,
-              ],
-              " "
-            ),
-        },
-        FragmentDefinition: {
-          leave: ({
-            name: name2,
-            typeCondition,
-            variableDefinitions,
-            directives,
-            selectionSet,
-          }) =>
-            `fragment ${name2}${wrap$1(
-              "(",
-              join$1(variableDefinitions, ", "),
-              ")"
-            )} on ${typeCondition} ${wrap$1(
-              "",
-              join$1(directives, " "),
-              " "
-            )}` + selectionSet,
-        },
-        IntValue: {
-          leave: ({ value }) => value,
-        },
-        FloatValue: {
-          leave: ({ value }) => value,
-        },
-        StringValue: {
-          leave: ({ value, block: isBlockString }) =>
-            isBlockString ? printBlockString$1(value) : printString(value),
-        },
-        BooleanValue: {
-          leave: ({ value }) => (value ? "true" : "false"),
-        },
-        NullValue: {
-          leave: () => "null",
-        },
-        EnumValue: {
-          leave: ({ value }) => value,
-        },
-        ListValue: {
-          leave: ({ values }) => "[" + join$1(values, ", ") + "]",
-        },
-        ObjectValue: {
-          leave: ({ fields }) => "{" + join$1(fields, ", ") + "}",
-        },
-        ObjectField: {
-          leave: ({ name: name2, value }) => name2 + ": " + value,
-        },
-        Directive: {
-          leave: ({ name: name2, arguments: args }) =>
-            "@" + name2 + wrap$1("(", join$1(args, ", "), ")"),
-        },
-        NamedType: {
-          leave: ({ name: name2 }) => name2,
-        },
-        ListType: {
-          leave: ({ type: type2 }) => "[" + type2 + "]",
-        },
-        NonNullType: {
-          leave: ({ type: type2 }) => type2 + "!",
-        },
-        SchemaDefinition: {
-          leave: ({ description, directives, operationTypes }) =>
-            wrap$1("", description, "\n") +
-            join$1(
-              ["schema", join$1(directives, " "), block$3(operationTypes)],
-              " "
-            ),
-        },
-        OperationTypeDefinition: {
-          leave: ({ operation, type: type2 }) => operation + ": " + type2,
-        },
-        ScalarTypeDefinition: {
-          leave: ({ description, name: name2, directives }) =>
-            wrap$1("", description, "\n") +
-            join$1(["scalar", name2, join$1(directives, " ")], " "),
-        },
-        ObjectTypeDefinition: {
-          leave: ({
-            description,
-            name: name2,
-            interfaces,
-            directives,
-            fields,
-          }) =>
-            wrap$1("", description, "\n") +
-            join$1(
-              [
-                "type",
-                name2,
-                wrap$1("implements ", join$1(interfaces, " & ")),
-                join$1(directives, " "),
-                block$3(fields),
-              ],
-              " "
-            ),
-        },
-        FieldDefinition: {
-          leave: ({
-            description,
-            name: name2,
-            arguments: args,
-            type: type2,
-            directives,
-          }) =>
-            wrap$1("", description, "\n") +
-            name2 +
-            (hasMultilineItems$1(args)
-              ? wrap$1("(\n", indent$4(join$1(args, "\n")), "\n)")
-              : wrap$1("(", join$1(args, ", "), ")")) +
-            ": " +
-            type2 +
-            wrap$1(" ", join$1(directives, " ")),
-        },
-        InputValueDefinition: {
-          leave: ({
-            description,
-            name: name2,
-            type: type2,
-            defaultValue: defaultValue2,
-            directives,
-          }) =>
-            wrap$1("", description, "\n") +
-            join$1(
-              [
-                name2 + ": " + type2,
-                wrap$1("= ", defaultValue2),
-                join$1(directives, " "),
-              ],
-              " "
-            ),
-        },
-        InterfaceTypeDefinition: {
-          leave: ({
-            description,
-            name: name2,
-            interfaces,
-            directives,
-            fields,
-          }) =>
-            wrap$1("", description, "\n") +
-            join$1(
-              [
-                "interface",
-                name2,
-                wrap$1("implements ", join$1(interfaces, " & ")),
-                join$1(directives, " "),
-                block$3(fields),
-              ],
-              " "
-            ),
-        },
-        UnionTypeDefinition: {
-          leave: ({ description, name: name2, directives, types }) =>
-            wrap$1("", description, "\n") +
-            join$1(
-              [
-                "union",
-                name2,
-                join$1(directives, " "),
-                wrap$1("= ", join$1(types, " | ")),
-              ],
-              " "
-            ),
-        },
-        EnumTypeDefinition: {
-          leave: ({ description, name: name2, directives, values }) =>
-            wrap$1("", description, "\n") +
-            join$1(
-              ["enum", name2, join$1(directives, " "), block$3(values)],
-              " "
-            ),
-        },
-        EnumValueDefinition: {
-          leave: ({ description, name: name2, directives }) =>
-            wrap$1("", description, "\n") +
-            join$1([name2, join$1(directives, " ")], " "),
-        },
-        InputObjectTypeDefinition: {
-          leave: ({ description, name: name2, directives, fields }) =>
-            wrap$1("", description, "\n") +
-            join$1(
-              ["input", name2, join$1(directives, " "), block$3(fields)],
-              " "
-            ),
-        },
-        DirectiveDefinition: {
-          leave: ({
-            description,
-            name: name2,
-            arguments: args,
-            repeatable,
-            locations,
-          }) =>
-            wrap$1("", description, "\n") +
-            "directive @" +
-            name2 +
-            (hasMultilineItems$1(args)
-              ? wrap$1("(\n", indent$4(join$1(args, "\n")), "\n)")
-              : wrap$1("(", join$1(args, ", "), ")")) +
-            (repeatable ? " repeatable" : "") +
-            " on " +
-            join$1(locations, " | "),
-        },
-        SchemaExtension: {
-          leave: ({ directives, operationTypes }) =>
-            join$1(
-              [
-                "extend schema",
-                join$1(directives, " "),
-                block$3(operationTypes),
-              ],
-              " "
-            ),
-        },
-        ScalarTypeExtension: {
-          leave: ({ name: name2, directives }) =>
-            join$1(["extend scalar", name2, join$1(directives, " ")], " "),
-        },
-        ObjectTypeExtension: {
-          leave: ({ name: name2, interfaces, directives, fields }) =>
-            join$1(
-              [
-                "extend type",
-                name2,
-                wrap$1("implements ", join$1(interfaces, " & ")),
-                join$1(directives, " "),
-                block$3(fields),
-              ],
-              " "
-            ),
-        },
-        InterfaceTypeExtension: {
-          leave: ({ name: name2, interfaces, directives, fields }) =>
-            join$1(
-              [
-                "extend interface",
-                name2,
-                wrap$1("implements ", join$1(interfaces, " & ")),
-                join$1(directives, " "),
-                block$3(fields),
-              ],
-              " "
-            ),
-        },
-        UnionTypeExtension: {
-          leave: ({ name: name2, directives, types }) =>
-            join$1(
-              [
-                "extend union",
-                name2,
-                join$1(directives, " "),
-                wrap$1("= ", join$1(types, " | ")),
-              ],
-              " "
-            ),
-        },
-        EnumTypeExtension: {
-          leave: ({ name: name2, directives, values }) =>
-            join$1(
-              ["extend enum", name2, join$1(directives, " "), block$3(values)],
-              " "
-            ),
-        },
-        InputObjectTypeExtension: {
-          leave: ({ name: name2, directives, fields }) =>
-            join$1(
-              ["extend input", name2, join$1(directives, " "), block$3(fields)],
-              " "
-            ),
-        },
-      };
-      function join$1(maybeArray, separator2 = "") {
-        var _maybeArray$filter$jo;
-        return (_maybeArray$filter$jo =
-          maybeArray === null || maybeArray === void 0
-            ? void 0
-            : maybeArray.filter((x2) => x2).join(separator2)) !== null &&
-          _maybeArray$filter$jo !== void 0
-          ? _maybeArray$filter$jo
-          : "";
-      }
-      function block$3(array) {
-        return wrap$1("{\n", indent$4(join$1(array, "\n")), "\n}");
-      }
-      function wrap$1(start2, maybeString, end2 = "") {
-        return maybeString != null && maybeString !== ""
-          ? start2 + maybeString + end2
-          : "";
-      }
-      function indent$4(str) {
-        return wrap$1("  ", str.replace(/\n/g, "\n  "));
-      }
-      function hasMultilineItems$1(maybeArray) {
-        var _maybeArray$some;
-        return (_maybeArray$some =
-          maybeArray === null || maybeArray === void 0
-            ? void 0
-            : maybeArray.some((str) => str.includes("\n"))) !== null &&
-          _maybeArray$some !== void 0
-          ? _maybeArray$some
-          : false;
-      }
-      var printer = /* @__PURE__ */ Object.freeze({
-        __proto__: null,
-        [Symbol.toStringTag]: "Module",
-        print,
-      });
-      function valueFromASTUntyped(valueNode, variables) {
-        switch (valueNode.kind) {
-          case Kind.NULL:
-            return null;
-          case Kind.INT:
-            return parseInt(valueNode.value, 10);
-          case Kind.FLOAT:
-            return parseFloat(valueNode.value);
-          case Kind.STRING:
-          case Kind.ENUM:
-          case Kind.BOOLEAN:
-            return valueNode.value;
-          case Kind.LIST:
-            return valueNode.values.map((node) =>
-              valueFromASTUntyped(node, variables)
-            );
-          case Kind.OBJECT:
-            return keyValMap(
-              valueNode.fields,
-              (field) => field.name.value,
-              (field) => valueFromASTUntyped(field.value, variables)
-            );
-          case Kind.VARIABLE:
-            return variables === null || variables === void 0
-              ? void 0
-              : variables[valueNode.name.value];
-        }
-      }
-      function assertName(name2) {
-        name2 != null || devAssert$1(false, "Must provide name.");
-        typeof name2 === "string" ||
-          devAssert$1(false, "Expected name to be a string.");
-        if (name2.length === 0) {
-          throw new GraphQLError("Expected name to be a non-empty string.");
-        }
-        for (let i = 1; i < name2.length; ++i) {
-          if (!isNameContinue(name2.charCodeAt(i))) {
-            throw new GraphQLError(
-              `Names must only contain [_a-zA-Z0-9] but "${name2}" does not.`
-            );
-          }
-        }
-        if (!isNameStart(name2.charCodeAt(0))) {
-          throw new GraphQLError(
-            `Names must start with [_a-zA-Z] but "${name2}" does not.`
-          );
-        }
-        return name2;
-      }
-      function assertEnumValueName(name2) {
-        if (name2 === "true" || name2 === "false" || name2 === "null") {
-          throw new GraphQLError(`Enum values cannot be named: ${name2}`);
-        }
-        return assertName(name2);
-      }
-      function isType(type2) {
-        return (
-          isScalarType(type2) ||
-          isObjectType(type2) ||
-          isInterfaceType(type2) ||
-          isUnionType(type2) ||
-          isEnumType(type2) ||
-          isInputObjectType(type2) ||
-          isListType(type2) ||
-          isNonNullType(type2)
-        );
-      }
-      function assertType(type2) {
-        if (!isType(type2)) {
-          throw new Error(`Expected ${inspect$2(type2)} to be a GraphQL type.`);
-        }
-        return type2;
-      }
-      function isScalarType(type2) {
-        return instanceOf(type2, GraphQLScalarType);
-      }
-      function assertScalarType(type2) {
-        if (!isScalarType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL Scalar type.`
-          );
-        }
-        return type2;
-      }
-      function isObjectType(type2) {
-        return instanceOf(type2, GraphQLObjectType);
-      }
-      function assertObjectType(type2) {
-        if (!isObjectType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL Object type.`
-          );
-        }
-        return type2;
-      }
-      function isInterfaceType(type2) {
-        return instanceOf(type2, GraphQLInterfaceType);
-      }
-      function assertInterfaceType(type2) {
-        if (!isInterfaceType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL Interface type.`
-          );
-        }
-        return type2;
-      }
-      function isUnionType(type2) {
-        return instanceOf(type2, GraphQLUnionType);
-      }
-      function assertUnionType(type2) {
-        if (!isUnionType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL Union type.`
-          );
-        }
-        return type2;
-      }
-      function isEnumType(type2) {
-        return instanceOf(type2, GraphQLEnumType);
-      }
-      function assertEnumType(type2) {
-        if (!isEnumType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL Enum type.`
-          );
-        }
-        return type2;
-      }
-      function isInputObjectType(type2) {
-        return instanceOf(type2, GraphQLInputObjectType);
-      }
-      function assertInputObjectType(type2) {
-        if (!isInputObjectType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL Input Object type.`
-          );
-        }
-        return type2;
-      }
-      function isListType(type2) {
-        return instanceOf(type2, GraphQLList);
-      }
-      function assertListType(type2) {
-        if (!isListType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL List type.`
-          );
-        }
-        return type2;
-      }
-      function isNonNullType(type2) {
-        return instanceOf(type2, GraphQLNonNull);
-      }
-      function assertNonNullType(type2) {
-        if (!isNonNullType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL Non-Null type.`
-          );
-        }
-        return type2;
-      }
-      function isInputType(type2) {
-        return (
-          isScalarType(type2) ||
-          isEnumType(type2) ||
-          isInputObjectType(type2) ||
-          (isWrappingType(type2) && isInputType(type2.ofType))
-        );
-      }
-      function assertInputType(type2) {
-        if (!isInputType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL input type.`
-          );
-        }
-        return type2;
-      }
-      function isOutputType(type2) {
-        return (
-          isScalarType(type2) ||
-          isObjectType(type2) ||
-          isInterfaceType(type2) ||
-          isUnionType(type2) ||
-          isEnumType(type2) ||
-          (isWrappingType(type2) && isOutputType(type2.ofType))
-        );
-      }
-      function assertOutputType(type2) {
-        if (!isOutputType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL output type.`
-          );
-        }
-        return type2;
-      }
-      function isLeafType(type2) {
-        return isScalarType(type2) || isEnumType(type2);
-      }
-      function assertLeafType(type2) {
-        if (!isLeafType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL leaf type.`
-          );
-        }
-        return type2;
-      }
-      function isCompositeType(type2) {
-        return (
-          isObjectType(type2) || isInterfaceType(type2) || isUnionType(type2)
-        );
-      }
-      function assertCompositeType(type2) {
-        if (!isCompositeType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL composite type.`
-          );
-        }
-        return type2;
-      }
-      function isAbstractType(type2) {
-        return isInterfaceType(type2) || isUnionType(type2);
-      }
-      function assertAbstractType(type2) {
-        if (!isAbstractType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL abstract type.`
-          );
-        }
-        return type2;
-      }
-      class GraphQLList {
-        constructor(ofType) {
-          isType(ofType) ||
-            devAssert$1(
-              false,
-              `Expected ${inspect$2(ofType)} to be a GraphQL type.`
-            );
-          this.ofType = ofType;
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLList";
-        }
-        toString() {
-          return "[" + String(this.ofType) + "]";
-        }
-        toJSON() {
-          return this.toString();
-        }
-      }
-      class GraphQLNonNull {
-        constructor(ofType) {
-          isNullableType(ofType) ||
-            devAssert$1(
-              false,
-              `Expected ${inspect$2(ofType)} to be a GraphQL nullable type.`
-            );
-          this.ofType = ofType;
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLNonNull";
-        }
-        toString() {
-          return String(this.ofType) + "!";
-        }
-        toJSON() {
-          return this.toString();
-        }
-      }
-      function isWrappingType(type2) {
-        return isListType(type2) || isNonNullType(type2);
-      }
-      function assertWrappingType(type2) {
-        if (!isWrappingType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL wrapping type.`
-          );
-        }
-        return type2;
-      }
-      function isNullableType(type2) {
-        return isType(type2) && !isNonNullType(type2);
-      }
-      function assertNullableType(type2) {
-        if (!isNullableType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL nullable type.`
-          );
-        }
-        return type2;
-      }
-      function getNullableType(type2) {
-        if (type2) {
-          return isNonNullType(type2) ? type2.ofType : type2;
-        }
-      }
-      function isNamedType(type2) {
-        return (
-          isScalarType(type2) ||
-          isObjectType(type2) ||
-          isInterfaceType(type2) ||
-          isUnionType(type2) ||
-          isEnumType(type2) ||
-          isInputObjectType(type2)
-        );
-      }
-      function assertNamedType(type2) {
-        if (!isNamedType(type2)) {
-          throw new Error(
-            `Expected ${inspect$2(type2)} to be a GraphQL named type.`
-          );
-        }
-        return type2;
-      }
-      function getNamedType(type2) {
-        if (type2) {
-          let unwrappedType = type2;
-          while (isWrappingType(unwrappedType)) {
-            unwrappedType = unwrappedType.ofType;
-          }
-          return unwrappedType;
-        }
-      }
-      function resolveReadonlyArrayThunk(thunk) {
-        return typeof thunk === "function" ? thunk() : thunk;
-      }
-      function resolveObjMapThunk(thunk) {
-        return typeof thunk === "function" ? thunk() : thunk;
-      }
-      class GraphQLScalarType {
-        constructor(config2) {
-          var _config$parseValue,
-            _config$serialize,
-            _config$parseLiteral,
-            _config$extensionASTN;
-          const parseValue2 =
-            (_config$parseValue = config2.parseValue) !== null &&
-            _config$parseValue !== void 0
-              ? _config$parseValue
-              : identityFunc;
-          this.name = assertName(config2.name);
-          this.description = config2.description;
-          this.specifiedByURL = config2.specifiedByURL;
-          this.serialize =
-            (_config$serialize = config2.serialize) !== null &&
-            _config$serialize !== void 0
-              ? _config$serialize
-              : identityFunc;
-          this.parseValue = parseValue2;
-          this.parseLiteral =
-            (_config$parseLiteral = config2.parseLiteral) !== null &&
-            _config$parseLiteral !== void 0
-              ? _config$parseLiteral
-              : (node, variables) =>
-                  parseValue2(valueFromASTUntyped(node, variables));
-          this.extensions = toObjMap(config2.extensions);
-          this.astNode = config2.astNode;
-          this.extensionASTNodes =
-            (_config$extensionASTN = config2.extensionASTNodes) !== null &&
-            _config$extensionASTN !== void 0
-              ? _config$extensionASTN
-              : [];
-          config2.specifiedByURL == null ||
-            typeof config2.specifiedByURL === "string" ||
-            devAssert$1(
-              false,
-              `${
-                this.name
-              } must provide "specifiedByURL" as a string, but got: ${inspect$2(
-                config2.specifiedByURL
-              )}.`
-            );
-          config2.serialize == null ||
-            typeof config2.serialize === "function" ||
-            devAssert$1(
-              false,
-              `${this.name} must provide "serialize" function. If this custom Scalar is also used as an input type, ensure "parseValue" and "parseLiteral" functions are also provided.`
-            );
-          if (config2.parseLiteral) {
-            (typeof config2.parseValue === "function" &&
-              typeof config2.parseLiteral === "function") ||
-              devAssert$1(
-                false,
-                `${this.name} must provide both "parseValue" and "parseLiteral" functions.`
-              );
-          }
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLScalarType";
-        }
-        toConfig() {
-          return {
-            name: this.name,
-            description: this.description,
-            specifiedByURL: this.specifiedByURL,
-            serialize: this.serialize,
-            parseValue: this.parseValue,
-            parseLiteral: this.parseLiteral,
-            extensions: this.extensions,
-            astNode: this.astNode,
-            extensionASTNodes: this.extensionASTNodes,
-          };
-        }
-        toString() {
-          return this.name;
-        }
-        toJSON() {
-          return this.toString();
-        }
-      }
-      class GraphQLObjectType {
-        constructor(config2) {
-          var _config$extensionASTN2;
-          this.name = assertName(config2.name);
-          this.description = config2.description;
-          this.isTypeOf = config2.isTypeOf;
-          this.extensions = toObjMap(config2.extensions);
-          this.astNode = config2.astNode;
-          this.extensionASTNodes =
-            (_config$extensionASTN2 = config2.extensionASTNodes) !== null &&
-            _config$extensionASTN2 !== void 0
-              ? _config$extensionASTN2
-              : [];
-          this._fields = () => defineFieldMap(config2);
-          this._interfaces = () => defineInterfaces(config2);
-          config2.isTypeOf == null ||
-            typeof config2.isTypeOf === "function" ||
-            devAssert$1(
-              false,
-              `${
-                this.name
-              } must provide "isTypeOf" as a function, but got: ${inspect$2(
-                config2.isTypeOf
-              )}.`
-            );
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLObjectType";
-        }
-        getFields() {
-          if (typeof this._fields === "function") {
-            this._fields = this._fields();
-          }
-          return this._fields;
-        }
-        getInterfaces() {
-          if (typeof this._interfaces === "function") {
-            this._interfaces = this._interfaces();
-          }
-          return this._interfaces;
-        }
-        toConfig() {
-          return {
-            name: this.name,
-            description: this.description,
-            interfaces: this.getInterfaces(),
-            fields: fieldsToFieldsConfig(this.getFields()),
-            isTypeOf: this.isTypeOf,
-            extensions: this.extensions,
-            astNode: this.astNode,
-            extensionASTNodes: this.extensionASTNodes,
-          };
-        }
-        toString() {
-          return this.name;
-        }
-        toJSON() {
-          return this.toString();
-        }
-      }
-      function defineInterfaces(config2) {
-        var _config$interfaces;
-        const interfaces = resolveReadonlyArrayThunk(
-          (_config$interfaces = config2.interfaces) !== null &&
-            _config$interfaces !== void 0
-            ? _config$interfaces
-            : []
-        );
-        Array.isArray(interfaces) ||
-          devAssert$1(
-            false,
-            `${config2.name} interfaces must be an Array or a function which returns an Array.`
-          );
-        return interfaces;
-      }
-      function defineFieldMap(config2) {
-        const fieldMap = resolveObjMapThunk(config2.fields);
-        isPlainObj(fieldMap) ||
-          devAssert$1(
-            false,
-            `${config2.name} fields must be an object with field names as keys or a function which returns such an object.`
-          );
-        return mapValue(fieldMap, (fieldConfig, fieldName) => {
-          var _fieldConfig$args;
-          isPlainObj(fieldConfig) ||
-            devAssert$1(
-              false,
-              `${config2.name}.${fieldName} field config must be an object.`
-            );
-          fieldConfig.resolve == null ||
-            typeof fieldConfig.resolve === "function" ||
-            devAssert$1(
-              false,
-              `${
-                config2.name
-              }.${fieldName} field resolver must be a function if provided, but got: ${inspect$2(
-                fieldConfig.resolve
-              )}.`
-            );
-          const argsConfig =
-            (_fieldConfig$args = fieldConfig.args) !== null &&
-            _fieldConfig$args !== void 0
-              ? _fieldConfig$args
-              : {};
-          isPlainObj(argsConfig) ||
-            devAssert$1(
-              false,
-              `${config2.name}.${fieldName} args must be an object with argument names as keys.`
-            );
-          return {
-            name: assertName(fieldName),
-            description: fieldConfig.description,
-            type: fieldConfig.type,
-            args: defineArguments(argsConfig),
-            resolve: fieldConfig.resolve,
-            subscribe: fieldConfig.subscribe,
-            deprecationReason: fieldConfig.deprecationReason,
-            extensions: toObjMap(fieldConfig.extensions),
-            astNode: fieldConfig.astNode,
-          };
-        });
-      }
-      function defineArguments(config2) {
-        return Object.entries(config2).map(([argName, argConfig]) => ({
-          name: assertName(argName),
-          description: argConfig.description,
-          type: argConfig.type,
-          defaultValue: argConfig.defaultValue,
-          deprecationReason: argConfig.deprecationReason,
-          extensions: toObjMap(argConfig.extensions),
-          astNode: argConfig.astNode,
-        }));
-      }
-      function isPlainObj(obj) {
-        return isObjectLike$1(obj) && !Array.isArray(obj);
-      }
-      function fieldsToFieldsConfig(fields) {
-        return mapValue(fields, (field) => ({
-          description: field.description,
-          type: field.type,
-          args: argsToArgsConfig(field.args),
-          resolve: field.resolve,
-          subscribe: field.subscribe,
-          deprecationReason: field.deprecationReason,
-          extensions: field.extensions,
-          astNode: field.astNode,
-        }));
-      }
-      function argsToArgsConfig(args) {
-        return keyValMap(
-          args,
-          (arg) => arg.name,
-          (arg) => ({
-            description: arg.description,
-            type: arg.type,
-            defaultValue: arg.defaultValue,
-            deprecationReason: arg.deprecationReason,
-            extensions: arg.extensions,
-            astNode: arg.astNode,
-          })
-        );
-      }
-      function isRequiredArgument$1(arg) {
-        return isNonNullType(arg.type) && arg.defaultValue === void 0;
-      }
-      class GraphQLInterfaceType {
-        constructor(config2) {
-          var _config$extensionASTN3;
-          this.name = assertName(config2.name);
-          this.description = config2.description;
-          this.resolveType = config2.resolveType;
-          this.extensions = toObjMap(config2.extensions);
-          this.astNode = config2.astNode;
-          this.extensionASTNodes =
-            (_config$extensionASTN3 = config2.extensionASTNodes) !== null &&
-            _config$extensionASTN3 !== void 0
-              ? _config$extensionASTN3
-              : [];
-          this._fields = defineFieldMap.bind(void 0, config2);
-          this._interfaces = defineInterfaces.bind(void 0, config2);
-          config2.resolveType == null ||
-            typeof config2.resolveType === "function" ||
-            devAssert$1(
-              false,
-              `${
-                this.name
-              } must provide "resolveType" as a function, but got: ${inspect$2(
-                config2.resolveType
-              )}.`
-            );
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLInterfaceType";
-        }
-        getFields() {
-          if (typeof this._fields === "function") {
-            this._fields = this._fields();
-          }
-          return this._fields;
-        }
-        getInterfaces() {
-          if (typeof this._interfaces === "function") {
-            this._interfaces = this._interfaces();
-          }
-          return this._interfaces;
-        }
-        toConfig() {
-          return {
-            name: this.name,
-            description: this.description,
-            interfaces: this.getInterfaces(),
-            fields: fieldsToFieldsConfig(this.getFields()),
-            resolveType: this.resolveType,
-            extensions: this.extensions,
-            astNode: this.astNode,
-            extensionASTNodes: this.extensionASTNodes,
-          };
-        }
-        toString() {
-          return this.name;
-        }
-        toJSON() {
-          return this.toString();
-        }
-      }
-      class GraphQLUnionType {
-        constructor(config2) {
-          var _config$extensionASTN4;
-          this.name = assertName(config2.name);
-          this.description = config2.description;
-          this.resolveType = config2.resolveType;
-          this.extensions = toObjMap(config2.extensions);
-          this.astNode = config2.astNode;
-          this.extensionASTNodes =
-            (_config$extensionASTN4 = config2.extensionASTNodes) !== null &&
-            _config$extensionASTN4 !== void 0
-              ? _config$extensionASTN4
-              : [];
-          this._types = defineTypes.bind(void 0, config2);
-          config2.resolveType == null ||
-            typeof config2.resolveType === "function" ||
-            devAssert$1(
-              false,
-              `${
-                this.name
-              } must provide "resolveType" as a function, but got: ${inspect$2(
-                config2.resolveType
-              )}.`
-            );
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLUnionType";
-        }
-        getTypes() {
-          if (typeof this._types === "function") {
-            this._types = this._types();
-          }
-          return this._types;
-        }
-        toConfig() {
-          return {
-            name: this.name,
-            description: this.description,
-            types: this.getTypes(),
-            resolveType: this.resolveType,
-            extensions: this.extensions,
-            astNode: this.astNode,
-            extensionASTNodes: this.extensionASTNodes,
-          };
-        }
-        toString() {
-          return this.name;
-        }
-        toJSON() {
-          return this.toString();
-        }
-      }
-      function defineTypes(config2) {
-        const types = resolveReadonlyArrayThunk(config2.types);
-        Array.isArray(types) ||
-          devAssert$1(
-            false,
-            `Must provide Array of types or a function which returns such an array for Union ${config2.name}.`
-          );
-        return types;
-      }
-      class GraphQLEnumType {
-        constructor(config2) {
-          var _config$extensionASTN5;
-          this.name = assertName(config2.name);
-          this.description = config2.description;
-          this.extensions = toObjMap(config2.extensions);
-          this.astNode = config2.astNode;
-          this.extensionASTNodes =
-            (_config$extensionASTN5 = config2.extensionASTNodes) !== null &&
-            _config$extensionASTN5 !== void 0
-              ? _config$extensionASTN5
-              : [];
-          this._values = defineEnumValues(this.name, config2.values);
-          this._valueLookup = new Map(
-            this._values.map((enumValue) => [enumValue.value, enumValue])
-          );
-          this._nameLookup = keyMap$1(this._values, (value) => value.name);
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLEnumType";
-        }
-        getValues() {
-          return this._values;
-        }
-        getValue(name2) {
-          return this._nameLookup[name2];
-        }
-        serialize(outputValue) {
-          const enumValue = this._valueLookup.get(outputValue);
-          if (enumValue === void 0) {
-            throw new GraphQLError(
-              `Enum "${this.name}" cannot represent value: ${inspect$2(
-                outputValue
-              )}`
-            );
-          }
-          return enumValue.name;
-        }
-        parseValue(inputValue) {
-          if (typeof inputValue !== "string") {
-            const valueStr = inspect$2(inputValue);
-            throw new GraphQLError(
-              `Enum "${this.name}" cannot represent non-string value: ${valueStr}.` +
-                didYouMeanEnumValue(this, valueStr)
-            );
-          }
-          const enumValue = this.getValue(inputValue);
-          if (enumValue == null) {
-            throw new GraphQLError(
-              `Value "${inputValue}" does not exist in "${this.name}" enum.` +
-                didYouMeanEnumValue(this, inputValue)
-            );
-          }
-          return enumValue.value;
-        }
-        parseLiteral(valueNode, _variables) {
-          if (valueNode.kind !== Kind.ENUM) {
-            const valueStr = print(valueNode);
-            throw new GraphQLError(
-              `Enum "${this.name}" cannot represent non-enum value: ${valueStr}.` +
-                didYouMeanEnumValue(this, valueStr),
-              {
-                nodes: valueNode,
-              }
-            );
-          }
-          const enumValue = this.getValue(valueNode.value);
-          if (enumValue == null) {
-            const valueStr = print(valueNode);
-            throw new GraphQLError(
-              `Value "${valueStr}" does not exist in "${this.name}" enum.` +
-                didYouMeanEnumValue(this, valueStr),
-              {
-                nodes: valueNode,
-              }
-            );
-          }
-          return enumValue.value;
-        }
-        toConfig() {
-          const values = keyValMap(
-            this.getValues(),
-            (value) => value.name,
-            (value) => ({
-              description: value.description,
-              value: value.value,
-              deprecationReason: value.deprecationReason,
-              extensions: value.extensions,
-              astNode: value.astNode,
-            })
-          );
-          return {
-            name: this.name,
-            description: this.description,
-            values,
-            extensions: this.extensions,
-            astNode: this.astNode,
-            extensionASTNodes: this.extensionASTNodes,
-          };
-        }
-        toString() {
-          return this.name;
-        }
-        toJSON() {
-          return this.toString();
-        }
-      }
-      function didYouMeanEnumValue(enumType, unknownValueStr) {
-        const allNames = enumType.getValues().map((value) => value.name);
-        const suggestedValues = suggestionList$1(unknownValueStr, allNames);
-        return didYouMean$1("the enum value", suggestedValues);
-      }
-      function defineEnumValues(typeName, valueMap) {
-        isPlainObj(valueMap) ||
-          devAssert$1(
-            false,
-            `${typeName} values must be an object with value names as keys.`
-          );
-        return Object.entries(valueMap).map(([valueName, valueConfig]) => {
-          isPlainObj(valueConfig) ||
-            devAssert$1(
-              false,
-              `${typeName}.${valueName} must refer to an object with a "value" key representing an internal value but got: ${inspect$2(
-                valueConfig
-              )}.`
-            );
-          return {
-            name: assertEnumValueName(valueName),
-            description: valueConfig.description,
-            value: valueConfig.value !== void 0 ? valueConfig.value : valueName,
-            deprecationReason: valueConfig.deprecationReason,
-            extensions: toObjMap(valueConfig.extensions),
-            astNode: valueConfig.astNode,
-          };
-        });
-      }
-      class GraphQLInputObjectType {
-        constructor(config2) {
-          var _config$extensionASTN6;
-          this.name = assertName(config2.name);
-          this.description = config2.description;
-          this.extensions = toObjMap(config2.extensions);
-          this.astNode = config2.astNode;
-          this.extensionASTNodes =
-            (_config$extensionASTN6 = config2.extensionASTNodes) !== null &&
-            _config$extensionASTN6 !== void 0
-              ? _config$extensionASTN6
-              : [];
-          this._fields = defineInputFieldMap.bind(void 0, config2);
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLInputObjectType";
-        }
-        getFields() {
-          if (typeof this._fields === "function") {
-            this._fields = this._fields();
-          }
-          return this._fields;
-        }
-        toConfig() {
-          const fields = mapValue(this.getFields(), (field) => ({
-            description: field.description,
-            type: field.type,
-            defaultValue: field.defaultValue,
-            deprecationReason: field.deprecationReason,
-            extensions: field.extensions,
-            astNode: field.astNode,
-          }));
-          return {
-            name: this.name,
-            description: this.description,
-            fields,
-            extensions: this.extensions,
-            astNode: this.astNode,
-            extensionASTNodes: this.extensionASTNodes,
-          };
-        }
-        toString() {
-          return this.name;
-        }
-        toJSON() {
-          return this.toString();
-        }
-      }
-      function defineInputFieldMap(config2) {
-        const fieldMap = resolveObjMapThunk(config2.fields);
-        isPlainObj(fieldMap) ||
-          devAssert$1(
-            false,
-            `${config2.name} fields must be an object with field names as keys or a function which returns such an object.`
-          );
-        return mapValue(fieldMap, (fieldConfig, fieldName) => {
-          !("resolve" in fieldConfig) ||
-            devAssert$1(
-              false,
-              `${config2.name}.${fieldName} field has a resolve property, but Input Types cannot define resolvers.`
-            );
-          return {
-            name: assertName(fieldName),
-            description: fieldConfig.description,
-            type: fieldConfig.type,
-            defaultValue: fieldConfig.defaultValue,
-            deprecationReason: fieldConfig.deprecationReason,
-            extensions: toObjMap(fieldConfig.extensions),
-            astNode: fieldConfig.astNode,
-          };
-        });
-      }
-      function isRequiredInputField(field) {
-        return isNonNullType(field.type) && field.defaultValue === void 0;
-      }
-      function isEqualType(typeA, typeB) {
-        if (typeA === typeB) {
-          return true;
-        }
-        if (isNonNullType(typeA) && isNonNullType(typeB)) {
-          return isEqualType(typeA.ofType, typeB.ofType);
-        }
-        if (isListType(typeA) && isListType(typeB)) {
-          return isEqualType(typeA.ofType, typeB.ofType);
-        }
-        return false;
-      }
-      function isTypeSubTypeOf(schema, maybeSubType, superType) {
-        if (maybeSubType === superType) {
-          return true;
-        }
-        if (isNonNullType(superType)) {
-          if (isNonNullType(maybeSubType)) {
-            return isTypeSubTypeOf(
-              schema,
-              maybeSubType.ofType,
-              superType.ofType
-            );
-          }
-          return false;
-        }
-        if (isNonNullType(maybeSubType)) {
-          return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
-        }
-        if (isListType(superType)) {
-          if (isListType(maybeSubType)) {
-            return isTypeSubTypeOf(
-              schema,
-              maybeSubType.ofType,
-              superType.ofType
-            );
-          }
-          return false;
-        }
-        if (isListType(maybeSubType)) {
-          return false;
-        }
-        return (
-          isAbstractType(superType) &&
-          (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&
-          schema.isSubType(superType, maybeSubType)
-        );
-      }
-      function doTypesOverlap(schema, typeA, typeB) {
-        if (typeA === typeB) {
-          return true;
-        }
-        if (isAbstractType(typeA)) {
-          if (isAbstractType(typeB)) {
-            return schema
-              .getPossibleTypes(typeA)
-              .some((type2) => schema.isSubType(typeB, type2));
-          }
-          return schema.isSubType(typeA, typeB);
-        }
-        if (isAbstractType(typeB)) {
-          return schema.isSubType(typeB, typeA);
-        }
-        return false;
-      }
-      const GRAPHQL_MAX_INT = 2147483647;
-      const GRAPHQL_MIN_INT = -2147483648;
-      const GraphQLInt = new GraphQLScalarType({
-        name: "Int",
-        description:
-          "The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.",
-        serialize(outputValue) {
-          const coercedValue = serializeObject(outputValue);
-          if (typeof coercedValue === "boolean") {
-            return coercedValue ? 1 : 0;
-          }
-          let num2 = coercedValue;
-          if (typeof coercedValue === "string" && coercedValue !== "") {
-            num2 = Number(coercedValue);
-          }
-          if (typeof num2 !== "number" || !Number.isInteger(num2)) {
-            throw new GraphQLError(
-              `Int cannot represent non-integer value: ${inspect$2(
-                coercedValue
-              )}`
-            );
-          }
-          if (num2 > GRAPHQL_MAX_INT || num2 < GRAPHQL_MIN_INT) {
-            throw new GraphQLError(
-              "Int cannot represent non 32-bit signed integer value: " +
-                inspect$2(coercedValue)
-            );
-          }
-          return num2;
-        },
-        parseValue(inputValue) {
-          if (typeof inputValue !== "number" || !Number.isInteger(inputValue)) {
-            throw new GraphQLError(
-              `Int cannot represent non-integer value: ${inspect$2(inputValue)}`
-            );
-          }
-          if (inputValue > GRAPHQL_MAX_INT || inputValue < GRAPHQL_MIN_INT) {
-            throw new GraphQLError(
-              `Int cannot represent non 32-bit signed integer value: ${inputValue}`
-            );
-          }
-          return inputValue;
-        },
-        parseLiteral(valueNode) {
-          if (valueNode.kind !== Kind.INT) {
-            throw new GraphQLError(
-              `Int cannot represent non-integer value: ${print(valueNode)}`,
-              {
-                nodes: valueNode,
-              }
-            );
-          }
-          const num2 = parseInt(valueNode.value, 10);
-          if (num2 > GRAPHQL_MAX_INT || num2 < GRAPHQL_MIN_INT) {
-            throw new GraphQLError(
-              `Int cannot represent non 32-bit signed integer value: ${valueNode.value}`,
-              {
-                nodes: valueNode,
-              }
-            );
-          }
-          return num2;
-        },
-      });
-      const GraphQLFloat = new GraphQLScalarType({
-        name: "Float",
-        description:
-          "The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point).",
-        serialize(outputValue) {
-          const coercedValue = serializeObject(outputValue);
-          if (typeof coercedValue === "boolean") {
-            return coercedValue ? 1 : 0;
-          }
-          let num2 = coercedValue;
-          if (typeof coercedValue === "string" && coercedValue !== "") {
-            num2 = Number(coercedValue);
-          }
-          if (typeof num2 !== "number" || !Number.isFinite(num2)) {
-            throw new GraphQLError(
-              `Float cannot represent non numeric value: ${inspect$2(
-                coercedValue
-              )}`
-            );
-          }
-          return num2;
-        },
-        parseValue(inputValue) {
-          if (typeof inputValue !== "number" || !Number.isFinite(inputValue)) {
-            throw new GraphQLError(
-              `Float cannot represent non numeric value: ${inspect$2(
-                inputValue
-              )}`
-            );
-          }
-          return inputValue;
-        },
-        parseLiteral(valueNode) {
-          if (valueNode.kind !== Kind.FLOAT && valueNode.kind !== Kind.INT) {
-            throw new GraphQLError(
-              `Float cannot represent non numeric value: ${print(valueNode)}`,
-              valueNode
-            );
-          }
-          return parseFloat(valueNode.value);
-        },
-      });
-      const GraphQLString = new GraphQLScalarType({
-        name: "String",
-        description:
-          "The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.",
-        serialize(outputValue) {
-          const coercedValue = serializeObject(outputValue);
-          if (typeof coercedValue === "string") {
-            return coercedValue;
-          }
-          if (typeof coercedValue === "boolean") {
-            return coercedValue ? "true" : "false";
-          }
-          if (
-            typeof coercedValue === "number" &&
-            Number.isFinite(coercedValue)
-          ) {
-            return coercedValue.toString();
-          }
-          throw new GraphQLError(
-            `String cannot represent value: ${inspect$2(outputValue)}`
-          );
-        },
-        parseValue(inputValue) {
-          if (typeof inputValue !== "string") {
-            throw new GraphQLError(
-              `String cannot represent a non string value: ${inspect$2(
-                inputValue
-              )}`
-            );
-          }
-          return inputValue;
-        },
-        parseLiteral(valueNode) {
-          if (valueNode.kind !== Kind.STRING) {
-            throw new GraphQLError(
-              `String cannot represent a non string value: ${print(valueNode)}`,
-              {
-                nodes: valueNode,
-              }
-            );
-          }
-          return valueNode.value;
-        },
-      });
-      const GraphQLBoolean = new GraphQLScalarType({
-        name: "Boolean",
-        description: "The `Boolean` scalar type represents `true` or `false`.",
-        serialize(outputValue) {
-          const coercedValue = serializeObject(outputValue);
-          if (typeof coercedValue === "boolean") {
-            return coercedValue;
-          }
-          if (Number.isFinite(coercedValue)) {
-            return coercedValue !== 0;
-          }
-          throw new GraphQLError(
-            `Boolean cannot represent a non boolean value: ${inspect$2(
-              coercedValue
-            )}`
-          );
-        },
-        parseValue(inputValue) {
-          if (typeof inputValue !== "boolean") {
-            throw new GraphQLError(
-              `Boolean cannot represent a non boolean value: ${inspect$2(
-                inputValue
-              )}`
-            );
-          }
-          return inputValue;
-        },
-        parseLiteral(valueNode) {
-          if (valueNode.kind !== Kind.BOOLEAN) {
-            throw new GraphQLError(
-              `Boolean cannot represent a non boolean value: ${print(
-                valueNode
-              )}`,
-              {
-                nodes: valueNode,
-              }
-            );
-          }
-          return valueNode.value;
-        },
-      });
-      const GraphQLID = new GraphQLScalarType({
-        name: "ID",
-        description:
-          'The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `"4"`) or integer (such as `4`) input value will be accepted as an ID.',
-        serialize(outputValue) {
-          const coercedValue = serializeObject(outputValue);
-          if (typeof coercedValue === "string") {
-            return coercedValue;
-          }
-          if (Number.isInteger(coercedValue)) {
-            return String(coercedValue);
-          }
-          throw new GraphQLError(
-            `ID cannot represent value: ${inspect$2(outputValue)}`
-          );
-        },
-        parseValue(inputValue) {
-          if (typeof inputValue === "string") {
-            return inputValue;
-          }
-          if (typeof inputValue === "number" && Number.isInteger(inputValue)) {
-            return inputValue.toString();
-          }
-          throw new GraphQLError(
-            `ID cannot represent value: ${inspect$2(inputValue)}`
-          );
-        },
-        parseLiteral(valueNode) {
-          if (valueNode.kind !== Kind.STRING && valueNode.kind !== Kind.INT) {
-            throw new GraphQLError(
-              "ID cannot represent a non-string and non-integer value: " +
-                print(valueNode),
-              {
-                nodes: valueNode,
-              }
-            );
-          }
-          return valueNode.value;
-        },
-      });
-      const specifiedScalarTypes = Object.freeze([
-        GraphQLString,
-        GraphQLInt,
-        GraphQLFloat,
-        GraphQLBoolean,
-        GraphQLID,
-      ]);
-      function isSpecifiedScalarType(type2) {
-        return specifiedScalarTypes.some(
-          ({ name: name2 }) => type2.name === name2
-        );
-      }
-      function serializeObject(outputValue) {
-        if (isObjectLike$1(outputValue)) {
-          if (typeof outputValue.valueOf === "function") {
-            const valueOfResult = outputValue.valueOf();
-            if (!isObjectLike$1(valueOfResult)) {
-              return valueOfResult;
-            }
-          }
-          if (typeof outputValue.toJSON === "function") {
-            return outputValue.toJSON();
-          }
-        }
-        return outputValue;
-      }
-      function isDirective(directive) {
-        return instanceOf(directive, GraphQLDirective);
-      }
-      function assertDirective(directive) {
-        if (!isDirective(directive)) {
-          throw new Error(
-            `Expected ${inspect$2(directive)} to be a GraphQL directive.`
-          );
-        }
-        return directive;
-      }
-      class GraphQLDirective {
-        constructor(config2) {
-          var _config$isRepeatable, _config$args;
-          this.name = assertName(config2.name);
-          this.description = config2.description;
-          this.locations = config2.locations;
-          this.isRepeatable =
-            (_config$isRepeatable = config2.isRepeatable) !== null &&
-            _config$isRepeatable !== void 0
-              ? _config$isRepeatable
-              : false;
-          this.extensions = toObjMap(config2.extensions);
-          this.astNode = config2.astNode;
-          Array.isArray(config2.locations) ||
-            devAssert$1(false, `@${config2.name} locations must be an Array.`);
-          const args =
-            (_config$args = config2.args) !== null && _config$args !== void 0
-              ? _config$args
-              : {};
-          (isObjectLike$1(args) && !Array.isArray(args)) ||
-            devAssert$1(
-              false,
-              `@${config2.name} args must be an object with argument names as keys.`
-            );
-          this.args = defineArguments(args);
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLDirective";
-        }
-        toConfig() {
-          return {
-            name: this.name,
-            description: this.description,
-            locations: this.locations,
-            args: argsToArgsConfig(this.args),
-            isRepeatable: this.isRepeatable,
-            extensions: this.extensions,
-            astNode: this.astNode,
-          };
-        }
-        toString() {
-          return "@" + this.name;
-        }
-        toJSON() {
-          return this.toString();
-        }
-      }
-      const GraphQLIncludeDirective = new GraphQLDirective({
-        name: "include",
-        description:
-          "Directs the executor to include this field or fragment only when the `if` argument is true.",
-        locations: [
-          DirectiveLocation.FIELD,
-          DirectiveLocation.FRAGMENT_SPREAD,
-          DirectiveLocation.INLINE_FRAGMENT,
-        ],
-        args: {
-          if: {
-            type: new GraphQLNonNull(GraphQLBoolean),
-            description: "Included when true.",
-          },
-        },
-      });
-      const GraphQLSkipDirective = new GraphQLDirective({
-        name: "skip",
-        description:
-          "Directs the executor to skip this field or fragment when the `if` argument is true.",
-        locations: [
-          DirectiveLocation.FIELD,
-          DirectiveLocation.FRAGMENT_SPREAD,
-          DirectiveLocation.INLINE_FRAGMENT,
-        ],
-        args: {
-          if: {
-            type: new GraphQLNonNull(GraphQLBoolean),
-            description: "Skipped when true.",
-          },
-        },
-      });
-      const DEFAULT_DEPRECATION_REASON = "No longer supported";
-      const GraphQLDeprecatedDirective = new GraphQLDirective({
-        name: "deprecated",
-        description:
-          "Marks an element of a GraphQL schema as no longer supported.",
-        locations: [
-          DirectiveLocation.FIELD_DEFINITION,
-          DirectiveLocation.ARGUMENT_DEFINITION,
-          DirectiveLocation.INPUT_FIELD_DEFINITION,
-          DirectiveLocation.ENUM_VALUE,
-        ],
-        args: {
-          reason: {
-            type: GraphQLString,
-            description:
-              "Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted using the Markdown syntax, as specified by [CommonMark](https://commonmark.org/).",
-            defaultValue: DEFAULT_DEPRECATION_REASON,
-          },
-        },
-      });
-      const GraphQLSpecifiedByDirective = new GraphQLDirective({
-        name: "specifiedBy",
-        description:
-          "Exposes a URL that specifies the behavior of this scalar.",
-        locations: [DirectiveLocation.SCALAR],
-        args: {
-          url: {
-            type: new GraphQLNonNull(GraphQLString),
-            description: "The URL that specifies the behavior of this scalar.",
-          },
-        },
-      });
-      const specifiedDirectives = Object.freeze([
-        GraphQLIncludeDirective,
-        GraphQLSkipDirective,
-        GraphQLDeprecatedDirective,
-        GraphQLSpecifiedByDirective,
-      ]);
-      function isSpecifiedDirective(directive) {
-        return specifiedDirectives.some(
-          ({ name: name2 }) => name2 === directive.name
-        );
-      }
-      function isIterableObject$1(maybeIterable) {
-        return (
-          typeof maybeIterable === "object" &&
-          typeof (maybeIterable === null || maybeIterable === void 0
-            ? void 0
-            : maybeIterable[Symbol.iterator]) === "function"
-        );
-      }
-      function astFromValue(value, type2) {
-        if (isNonNullType(type2)) {
-          const astValue = astFromValue(value, type2.ofType);
-          if (
-            (astValue === null || astValue === void 0
-              ? void 0
-              : astValue.kind) === Kind.NULL
-          ) {
-            return null;
-          }
-          return astValue;
-        }
-        if (value === null) {
-          return {
-            kind: Kind.NULL,
-          };
-        }
-        if (value === void 0) {
-          return null;
-        }
-        if (isListType(type2)) {
-          const itemType = type2.ofType;
-          if (isIterableObject$1(value)) {
-            const valuesNodes = [];
-            for (const item of value) {
-              const itemNode = astFromValue(item, itemType);
-              if (itemNode != null) {
-                valuesNodes.push(itemNode);
-              }
-            }
-            return {
-              kind: Kind.LIST,
-              values: valuesNodes,
-            };
-          }
-          return astFromValue(value, itemType);
-        }
-        if (isInputObjectType(type2)) {
-          if (!isObjectLike$1(value)) {
-            return null;
-          }
-          const fieldNodes = [];
-          for (const field of Object.values(type2.getFields())) {
-            const fieldValue = astFromValue(value[field.name], field.type);
-            if (fieldValue) {
-              fieldNodes.push({
-                kind: Kind.OBJECT_FIELD,
-                name: {
-                  kind: Kind.NAME,
-                  value: field.name,
-                },
-                value: fieldValue,
-              });
-            }
-          }
-          return {
-            kind: Kind.OBJECT,
-            fields: fieldNodes,
-          };
-        }
-        if (isLeafType(type2)) {
-          const serialized = type2.serialize(value);
-          if (serialized == null) {
-            return null;
-          }
-          if (typeof serialized === "boolean") {
-            return {
-              kind: Kind.BOOLEAN,
-              value: serialized,
-            };
-          }
-          if (typeof serialized === "number" && Number.isFinite(serialized)) {
-            const stringNum = String(serialized);
-            return integerStringRegExp.test(stringNum)
-              ? {
-                  kind: Kind.INT,
-                  value: stringNum,
-                }
-              : {
-                  kind: Kind.FLOAT,
-                  value: stringNum,
-                };
-          }
-          if (typeof serialized === "string") {
-            if (isEnumType(type2)) {
-              return {
-                kind: Kind.ENUM,
-                value: serialized,
-              };
-            }
-            if (type2 === GraphQLID && integerStringRegExp.test(serialized)) {
-              return {
-                kind: Kind.INT,
-                value: serialized,
-              };
-            }
-            return {
-              kind: Kind.STRING,
-              value: serialized,
-            };
-          }
-          throw new TypeError(
-            `Cannot convert value to AST: ${inspect$2(serialized)}.`
-          );
-        }
-        invariant$2(false, "Unexpected input type: " + inspect$2(type2));
-      }
-      const integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;
-      const __Schema$1 = new GraphQLObjectType({
-        name: "__Schema",
-        description:
-          "A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations.",
-        fields: () => ({
-          description: {
-            type: GraphQLString,
-            resolve: (schema) => schema.description,
-          },
-          types: {
-            description: "A list of all types supported by this server.",
-            type: new GraphQLNonNull(
-              new GraphQLList(new GraphQLNonNull(__Type$1))
-            ),
-            resolve(schema) {
-              return Object.values(schema.getTypeMap());
-            },
-          },
-          queryType: {
-            description: "The type that query operations will be rooted at.",
-            type: new GraphQLNonNull(__Type$1),
-            resolve: (schema) => schema.getQueryType(),
-          },
-          mutationType: {
-            description:
-              "If this server supports mutation, the type that mutation operations will be rooted at.",
-            type: __Type$1,
-            resolve: (schema) => schema.getMutationType(),
-          },
-          subscriptionType: {
-            description:
-              "If this server support subscription, the type that subscription operations will be rooted at.",
-            type: __Type$1,
-            resolve: (schema) => schema.getSubscriptionType(),
-          },
-          directives: {
-            description: "A list of all directives supported by this server.",
-            type: new GraphQLNonNull(
-              new GraphQLList(new GraphQLNonNull(__Directive$1))
-            ),
-            resolve: (schema) => schema.getDirectives(),
-          },
-        }),
-      });
-      const __Directive$1 = new GraphQLObjectType({
-        name: "__Directive",
-        description:
-          "A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.\n\nIn some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor.",
-        fields: () => ({
-          name: {
-            type: new GraphQLNonNull(GraphQLString),
-            resolve: (directive) => directive.name,
-          },
-          description: {
-            type: GraphQLString,
-            resolve: (directive) => directive.description,
-          },
-          isRepeatable: {
-            type: new GraphQLNonNull(GraphQLBoolean),
-            resolve: (directive) => directive.isRepeatable,
-          },
-          locations: {
-            type: new GraphQLNonNull(
-              new GraphQLList(new GraphQLNonNull(__DirectiveLocation))
-            ),
-            resolve: (directive) => directive.locations,
-          },
-          args: {
-            type: new GraphQLNonNull(
-              new GraphQLList(new GraphQLNonNull(__InputValue$1))
-            ),
-            args: {
-              includeDeprecated: {
-                type: GraphQLBoolean,
-                defaultValue: false,
-              },
-            },
-            resolve(field, { includeDeprecated }) {
-              return includeDeprecated
-                ? field.args
-                : field.args.filter((arg) => arg.deprecationReason == null);
-            },
-          },
-        }),
-      });
-      const __DirectiveLocation = new GraphQLEnumType({
-        name: "__DirectiveLocation",
-        description:
-          "A Directive can be adjacent to many parts of the GraphQL language, a __DirectiveLocation describes one such possible adjacencies.",
-        values: {
-          QUERY: {
-            value: DirectiveLocation.QUERY,
-            description: "Location adjacent to a query operation.",
-          },
-          MUTATION: {
-            value: DirectiveLocation.MUTATION,
-            description: "Location adjacent to a mutation operation.",
-          },
-          SUBSCRIPTION: {
-            value: DirectiveLocation.SUBSCRIPTION,
-            description: "Location adjacent to a subscription operation.",
-          },
-          FIELD: {
-            value: DirectiveLocation.FIELD,
-            description: "Location adjacent to a field.",
-          },
-          FRAGMENT_DEFINITION: {
-            value: DirectiveLocation.FRAGMENT_DEFINITION,
-            description: "Location adjacent to a fragment definition.",
-          },
-          FRAGMENT_SPREAD: {
-            value: DirectiveLocation.FRAGMENT_SPREAD,
-            description: "Location adjacent to a fragment spread.",
-          },
-          INLINE_FRAGMENT: {
-            value: DirectiveLocation.INLINE_FRAGMENT,
-            description: "Location adjacent to an inline fragment.",
-          },
-          VARIABLE_DEFINITION: {
-            value: DirectiveLocation.VARIABLE_DEFINITION,
-            description: "Location adjacent to a variable definition.",
-          },
-          SCHEMA: {
-            value: DirectiveLocation.SCHEMA,
-            description: "Location adjacent to a schema definition.",
-          },
-          SCALAR: {
-            value: DirectiveLocation.SCALAR,
-            description: "Location adjacent to a scalar definition.",
-          },
-          OBJECT: {
-            value: DirectiveLocation.OBJECT,
-            description: "Location adjacent to an object type definition.",
-          },
-          FIELD_DEFINITION: {
-            value: DirectiveLocation.FIELD_DEFINITION,
-            description: "Location adjacent to a field definition.",
-          },
-          ARGUMENT_DEFINITION: {
-            value: DirectiveLocation.ARGUMENT_DEFINITION,
-            description: "Location adjacent to an argument definition.",
-          },
-          INTERFACE: {
-            value: DirectiveLocation.INTERFACE,
-            description: "Location adjacent to an interface definition.",
-          },
-          UNION: {
-            value: DirectiveLocation.UNION,
-            description: "Location adjacent to a union definition.",
-          },
-          ENUM: {
-            value: DirectiveLocation.ENUM,
-            description: "Location adjacent to an enum definition.",
-          },
-          ENUM_VALUE: {
-            value: DirectiveLocation.ENUM_VALUE,
-            description: "Location adjacent to an enum value definition.",
-          },
-          INPUT_OBJECT: {
-            value: DirectiveLocation.INPUT_OBJECT,
-            description:
-              "Location adjacent to an input object type definition.",
-          },
-          INPUT_FIELD_DEFINITION: {
-            value: DirectiveLocation.INPUT_FIELD_DEFINITION,
-            description:
-              "Location adjacent to an input object field definition.",
-          },
-        },
-      });
-      const __Type$1 = new GraphQLObjectType({
-        name: "__Type",
-        description:
-          "The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum.\n\nDepending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name, description and optional `specifiedByURL`, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types.",
-        fields: () => ({
-          kind: {
-            type: new GraphQLNonNull(__TypeKind),
-            resolve(type2) {
-              if (isScalarType(type2)) {
-                return TypeKind.SCALAR;
-              }
-              if (isObjectType(type2)) {
-                return TypeKind.OBJECT;
-              }
-              if (isInterfaceType(type2)) {
-                return TypeKind.INTERFACE;
-              }
-              if (isUnionType(type2)) {
-                return TypeKind.UNION;
-              }
-              if (isEnumType(type2)) {
-                return TypeKind.ENUM;
-              }
-              if (isInputObjectType(type2)) {
-                return TypeKind.INPUT_OBJECT;
-              }
-              if (isListType(type2)) {
-                return TypeKind.LIST;
-              }
-              if (isNonNullType(type2)) {
-                return TypeKind.NON_NULL;
-              }
-              invariant$2(false, `Unexpected type: "${inspect$2(type2)}".`);
-            },
-          },
-          name: {
-            type: GraphQLString,
-            resolve: (type2) => ("name" in type2 ? type2.name : void 0),
-          },
-          description: {
-            type: GraphQLString,
-            resolve: (type2) =>
-              "description" in type2 ? type2.description : void 0,
-          },
-          specifiedByURL: {
-            type: GraphQLString,
-            resolve: (obj) =>
-              "specifiedByURL" in obj ? obj.specifiedByURL : void 0,
-          },
-          fields: {
-            type: new GraphQLList(new GraphQLNonNull(__Field$1)),
-            args: {
-              includeDeprecated: {
-                type: GraphQLBoolean,
-                defaultValue: false,
-              },
-            },
-            resolve(type2, { includeDeprecated }) {
-              if (isObjectType(type2) || isInterfaceType(type2)) {
-                const fields = Object.values(type2.getFields());
-                return includeDeprecated
-                  ? fields
-                  : fields.filter((field) => field.deprecationReason == null);
-              }
-            },
-          },
-          interfaces: {
-            type: new GraphQLList(new GraphQLNonNull(__Type$1)),
-            resolve(type2) {
-              if (isObjectType(type2) || isInterfaceType(type2)) {
-                return type2.getInterfaces();
-              }
-            },
-          },
-          possibleTypes: {
-            type: new GraphQLList(new GraphQLNonNull(__Type$1)),
-            resolve(type2, _args, _context, { schema }) {
-              if (isAbstractType(type2)) {
-                return schema.getPossibleTypes(type2);
-              }
-            },
-          },
-          enumValues: {
-            type: new GraphQLList(new GraphQLNonNull(__EnumValue)),
-            args: {
-              includeDeprecated: {
-                type: GraphQLBoolean,
-                defaultValue: false,
-              },
-            },
-            resolve(type2, { includeDeprecated }) {
-              if (isEnumType(type2)) {
-                const values = type2.getValues();
-                return includeDeprecated
-                  ? values
-                  : values.filter((field) => field.deprecationReason == null);
-              }
-            },
-          },
-          inputFields: {
-            type: new GraphQLList(new GraphQLNonNull(__InputValue$1)),
-            args: {
-              includeDeprecated: {
-                type: GraphQLBoolean,
-                defaultValue: false,
-              },
-            },
-            resolve(type2, { includeDeprecated }) {
-              if (isInputObjectType(type2)) {
-                const values = Object.values(type2.getFields());
-                return includeDeprecated
-                  ? values
-                  : values.filter((field) => field.deprecationReason == null);
-              }
-            },
-          },
-          ofType: {
-            type: __Type$1,
-            resolve: (type2) => ("ofType" in type2 ? type2.ofType : void 0),
-          },
-        }),
-      });
-      const __Field$1 = new GraphQLObjectType({
-        name: "__Field",
-        description:
-          "Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type.",
-        fields: () => ({
-          name: {
-            type: new GraphQLNonNull(GraphQLString),
-            resolve: (field) => field.name,
-          },
-          description: {
-            type: GraphQLString,
-            resolve: (field) => field.description,
-          },
-          args: {
-            type: new GraphQLNonNull(
-              new GraphQLList(new GraphQLNonNull(__InputValue$1))
-            ),
-            args: {
-              includeDeprecated: {
-                type: GraphQLBoolean,
-                defaultValue: false,
-              },
-            },
-            resolve(field, { includeDeprecated }) {
-              return includeDeprecated
-                ? field.args
-                : field.args.filter((arg) => arg.deprecationReason == null);
-            },
-          },
-          type: {
-            type: new GraphQLNonNull(__Type$1),
-            resolve: (field) => field.type,
-          },
-          isDeprecated: {
-            type: new GraphQLNonNull(GraphQLBoolean),
-            resolve: (field) => field.deprecationReason != null,
-          },
-          deprecationReason: {
-            type: GraphQLString,
-            resolve: (field) => field.deprecationReason,
-          },
-        }),
-      });
-      const __InputValue$1 = new GraphQLObjectType({
-        name: "__InputValue",
-        description:
-          "Arguments provided to Fields or Directives and the input fields of an InputObject are represented as Input Values which describe their type and optionally a default value.",
-        fields: () => ({
-          name: {
-            type: new GraphQLNonNull(GraphQLString),
-            resolve: (inputValue) => inputValue.name,
-          },
-          description: {
-            type: GraphQLString,
-            resolve: (inputValue) => inputValue.description,
-          },
-          type: {
-            type: new GraphQLNonNull(__Type$1),
-            resolve: (inputValue) => inputValue.type,
-          },
-          defaultValue: {
-            type: GraphQLString,
-            description:
-              "A GraphQL-formatted string representing the default value for this input value.",
-            resolve(inputValue) {
-              const { type: type2, defaultValue: defaultValue2 } = inputValue;
-              const valueAST = astFromValue(defaultValue2, type2);
-              return valueAST ? print(valueAST) : null;
-            },
-          },
-          isDeprecated: {
-            type: new GraphQLNonNull(GraphQLBoolean),
-            resolve: (field) => field.deprecationReason != null,
-          },
-          deprecationReason: {
-            type: GraphQLString,
-            resolve: (obj) => obj.deprecationReason,
-          },
-        }),
-      });
-      const __EnumValue = new GraphQLObjectType({
-        name: "__EnumValue",
-        description:
-          "One possible value for a given Enum. Enum values are unique values, not a placeholder for a string or numeric value. However an Enum value is returned in a JSON response as a string.",
-        fields: () => ({
-          name: {
-            type: new GraphQLNonNull(GraphQLString),
-            resolve: (enumValue) => enumValue.name,
-          },
-          description: {
-            type: GraphQLString,
-            resolve: (enumValue) => enumValue.description,
-          },
-          isDeprecated: {
-            type: new GraphQLNonNull(GraphQLBoolean),
-            resolve: (enumValue) => enumValue.deprecationReason != null,
-          },
-          deprecationReason: {
-            type: GraphQLString,
-            resolve: (enumValue) => enumValue.deprecationReason,
-          },
-        }),
-      });
-      let TypeKind;
-      (function (TypeKind2) {
-        TypeKind2["SCALAR"] = "SCALAR";
-        TypeKind2["OBJECT"] = "OBJECT";
-        TypeKind2["INTERFACE"] = "INTERFACE";
-        TypeKind2["UNION"] = "UNION";
-        TypeKind2["ENUM"] = "ENUM";
-        TypeKind2["INPUT_OBJECT"] = "INPUT_OBJECT";
-        TypeKind2["LIST"] = "LIST";
-        TypeKind2["NON_NULL"] = "NON_NULL";
-      })(TypeKind || (TypeKind = {}));
-      const __TypeKind = new GraphQLEnumType({
-        name: "__TypeKind",
-        description:
-          "An enum describing what kind of type a given `__Type` is.",
-        values: {
-          SCALAR: {
-            value: TypeKind.SCALAR,
-            description: "Indicates this type is a scalar.",
-          },
-          OBJECT: {
-            value: TypeKind.OBJECT,
-            description:
-              "Indicates this type is an object. `fields` and `interfaces` are valid fields.",
-          },
-          INTERFACE: {
-            value: TypeKind.INTERFACE,
-            description:
-              "Indicates this type is an interface. `fields`, `interfaces`, and `possibleTypes` are valid fields.",
-          },
-          UNION: {
-            value: TypeKind.UNION,
-            description:
-              "Indicates this type is a union. `possibleTypes` is a valid field.",
-          },
-          ENUM: {
-            value: TypeKind.ENUM,
-            description:
-              "Indicates this type is an enum. `enumValues` is a valid field.",
-          },
-          INPUT_OBJECT: {
-            value: TypeKind.INPUT_OBJECT,
-            description:
-              "Indicates this type is an input object. `inputFields` is a valid field.",
-          },
-          LIST: {
-            value: TypeKind.LIST,
-            description:
-              "Indicates this type is a list. `ofType` is a valid field.",
-          },
-          NON_NULL: {
-            value: TypeKind.NON_NULL,
-            description:
-              "Indicates this type is a non-null. `ofType` is a valid field.",
-          },
-        },
-      });
-      const SchemaMetaFieldDef$1 = {
-        name: "__schema",
-        type: new GraphQLNonNull(__Schema$1),
-        description: "Access the current type schema of this server.",
-        args: [],
-        resolve: (_source, _args, _context, { schema }) => schema,
-        deprecationReason: void 0,
-        extensions: /* @__PURE__ */ Object.create(null),
-        astNode: void 0,
-      };
-      const TypeMetaFieldDef$1 = {
-        name: "__type",
-        type: __Type$1,
-        description: "Request the type information of a single type.",
-        args: [
-          {
-            name: "name",
-            description: void 0,
-            type: new GraphQLNonNull(GraphQLString),
-            defaultValue: void 0,
-            deprecationReason: void 0,
-            extensions: /* @__PURE__ */ Object.create(null),
-            astNode: void 0,
-          },
-        ],
-        resolve: (_source, { name: name2 }, _context, { schema }) =>
-          schema.getType(name2),
-        deprecationReason: void 0,
-        extensions: /* @__PURE__ */ Object.create(null),
-        astNode: void 0,
-      };
-      const TypeNameMetaFieldDef = {
-        name: "__typename",
-        type: new GraphQLNonNull(GraphQLString),
-        description: "The name of the current Object type at runtime.",
-        args: [],
-        resolve: (_source, _args, _context, { parentType }) => parentType.name,
-        deprecationReason: void 0,
-        extensions: /* @__PURE__ */ Object.create(null),
-        astNode: void 0,
-      };
-      const introspectionTypes$1 = Object.freeze([
-        __Schema$1,
-        __Directive$1,
-        __DirectiveLocation,
-        __Type$1,
-        __Field$1,
-        __InputValue$1,
-        __EnumValue,
-        __TypeKind,
-      ]);
-      function isIntrospectionType(type2) {
-        return introspectionTypes$1.some(
-          ({ name: name2 }) => type2.name === name2
-        );
-      }
-      var introspection = /* @__PURE__ */ Object.freeze({
-        __proto__: null,
-        [Symbol.toStringTag]: "Module",
-        __Schema: __Schema$1,
-        __Directive: __Directive$1,
-        __DirectiveLocation,
-        __Type: __Type$1,
-        __Field: __Field$1,
-        __InputValue: __InputValue$1,
-        __EnumValue,
-        get TypeKind() {
-          return TypeKind;
-        },
-        __TypeKind,
-        SchemaMetaFieldDef: SchemaMetaFieldDef$1,
-        TypeMetaFieldDef: TypeMetaFieldDef$1,
-        TypeNameMetaFieldDef,
-        introspectionTypes: introspectionTypes$1,
-        isIntrospectionType,
-      });
-      function isSchema(schema) {
-        return instanceOf(schema, GraphQLSchema);
-      }
-      function assertSchema(schema) {
-        if (!isSchema(schema)) {
-          throw new Error(
-            `Expected ${inspect$2(schema)} to be a GraphQL schema.`
-          );
-        }
-        return schema;
-      }
-      class GraphQLSchema {
-        constructor(config2) {
-          var _config$extensionASTN, _config$directives;
-          this.__validationErrors = config2.assumeValid === true ? [] : void 0;
-          isObjectLike$1(config2) ||
-            devAssert$1(false, "Must provide configuration object.");
-          !config2.types ||
-            Array.isArray(config2.types) ||
-            devAssert$1(
-              false,
-              `"types" must be Array if provided but got: ${inspect$2(
-                config2.types
-              )}.`
-            );
-          !config2.directives ||
-            Array.isArray(config2.directives) ||
-            devAssert$1(
-              false,
-              `"directives" must be Array if provided but got: ${inspect$2(
-                config2.directives
-              )}.`
-            );
-          this.description = config2.description;
-          this.extensions = toObjMap(config2.extensions);
-          this.astNode = config2.astNode;
-          this.extensionASTNodes =
-            (_config$extensionASTN = config2.extensionASTNodes) !== null &&
-            _config$extensionASTN !== void 0
-              ? _config$extensionASTN
-              : [];
-          this._queryType = config2.query;
-          this._mutationType = config2.mutation;
-          this._subscriptionType = config2.subscription;
-          this._directives =
-            (_config$directives = config2.directives) !== null &&
-            _config$directives !== void 0
-              ? _config$directives
-              : specifiedDirectives;
-          const allReferencedTypes = new Set(config2.types);
-          if (config2.types != null) {
-            for (const type2 of config2.types) {
-              allReferencedTypes.delete(type2);
-              collectReferencedTypes(type2, allReferencedTypes);
-            }
-          }
-          if (this._queryType != null) {
-            collectReferencedTypes(this._queryType, allReferencedTypes);
-          }
-          if (this._mutationType != null) {
-            collectReferencedTypes(this._mutationType, allReferencedTypes);
-          }
-          if (this._subscriptionType != null) {
-            collectReferencedTypes(this._subscriptionType, allReferencedTypes);
-          }
-          for (const directive of this._directives) {
-            if (isDirective(directive)) {
-              for (const arg of directive.args) {
-                collectReferencedTypes(arg.type, allReferencedTypes);
-              }
-            }
-          }
-          collectReferencedTypes(__Schema$1, allReferencedTypes);
-          this._typeMap = /* @__PURE__ */ Object.create(null);
-          this._subTypeMap = /* @__PURE__ */ Object.create(null);
-          this._implementationsMap = /* @__PURE__ */ Object.create(null);
-          for (const namedType of allReferencedTypes) {
-            if (namedType == null) {
-              continue;
-            }
-            const typeName = namedType.name;
-            typeName ||
-              devAssert$1(
-                false,
-                "One of the provided types for building the Schema is missing a name."
-              );
-            if (this._typeMap[typeName] !== void 0) {
-              throw new Error(
-                `Schema must contain uniquely named types but contains multiple types named "${typeName}".`
-              );
-            }
-            this._typeMap[typeName] = namedType;
-            if (isInterfaceType(namedType)) {
-              for (const iface of namedType.getInterfaces()) {
-                if (isInterfaceType(iface)) {
-                  let implementations = this._implementationsMap[iface.name];
-                  if (implementations === void 0) {
-                    implementations = this._implementationsMap[iface.name] = {
-                      objects: [],
-                      interfaces: [],
-                    };
-                  }
-                  implementations.interfaces.push(namedType);
-                }
-              }
-            } else if (isObjectType(namedType)) {
-              for (const iface of namedType.getInterfaces()) {
-                if (isInterfaceType(iface)) {
-                  let implementations = this._implementationsMap[iface.name];
-                  if (implementations === void 0) {
-                    implementations = this._implementationsMap[iface.name] = {
-                      objects: [],
-                      interfaces: [],
-                    };
-                  }
-                  implementations.objects.push(namedType);
-                }
-              }
-            }
-          }
-        }
-        get [Symbol.toStringTag]() {
-          return "GraphQLSchema";
-        }
-        getQueryType() {
-          return this._queryType;
-        }
-        getMutationType() {
-          return this._mutationType;
-        }
-        getSubscriptionType() {
-          return this._subscriptionType;
-        }
-        getRootType(operation) {
-          switch (operation) {
-            case OperationTypeNode.QUERY:
-              return this.getQueryType();
-            case OperationTypeNode.MUTATION:
-              return this.getMutationType();
-            case OperationTypeNode.SUBSCRIPTION:
-              return this.getSubscriptionType();
-          }
-        }
-        getTypeMap() {
-          return this._typeMap;
-        }
-        getType(name2) {
-          return this.getTypeMap()[name2];
-        }
-        getPossibleTypes(abstractType) {
-          return isUnionType(abstractType)
-            ? abstractType.getTypes()
-            : this.getImplementations(abstractType).objects;
-        }
-        getImplementations(interfaceType) {
-          const implementations = this._implementationsMap[interfaceType.name];
-          return implementations !== null && implementations !== void 0
-            ? implementations
-            : {
-                objects: [],
-                interfaces: [],
-              };
-        }
-        isSubType(abstractType, maybeSubType) {
-          let map2 = this._subTypeMap[abstractType.name];
-          if (map2 === void 0) {
-            map2 = /* @__PURE__ */ Object.create(null);
-            if (isUnionType(abstractType)) {
-              for (const type2 of abstractType.getTypes()) {
-                map2[type2.name] = true;
-              }
-            } else {
-              const implementations = this.getImplementations(abstractType);
-              for (const type2 of implementations.objects) {
-                map2[type2.name] = true;
-              }
-              for (const type2 of implementations.interfaces) {
-                map2[type2.name] = true;
-              }
-            }
-            this._subTypeMap[abstractType.name] = map2;
-          }
-          return map2[maybeSubType.name] !== void 0;
-        }
-        getDirectives() {
-          return this._directives;
-        }
-        getDirective(name2) {
-          return this.getDirectives().find(
-            (directive) => directive.name === name2
-          );
-        }
-        toConfig() {
-          return {
-            description: this.description,
-            query: this.getQueryType(),
-            mutation: this.getMutationType(),
-            subscription: this.getSubscriptionType(),
-            types: Object.values(this.getTypeMap()),
-            directives: this.getDirectives(),
-            extensions: this.extensions,
-            astNode: this.astNode,
-            extensionASTNodes: this.extensionASTNodes,
-            assumeValid: this.__validationErrors !== void 0,
-          };
-        }
-      }
-      function collectReferencedTypes(type2, typeSet) {
-        const namedType = getNamedType(type2);
-        if (!typeSet.has(namedType)) {
-          typeSet.add(namedType);
-          if (isUnionType(namedType)) {
-            for (const memberType of namedType.getTypes()) {
-              collectReferencedTypes(memberType, typeSet);
-            }
-          } else if (isObjectType(namedType) || isInterfaceType(namedType)) {
-            for (const interfaceType of namedType.getInterfaces()) {
-              collectReferencedTypes(interfaceType, typeSet);
-            }
-            for (const field of Object.values(namedType.getFields())) {
-              collectReferencedTypes(field.type, typeSet);
-              for (const arg of field.args) {
-                collectReferencedTypes(arg.type, typeSet);
-              }
-            }
-          } else if (isInputObjectType(namedType)) {
-            for (const field of Object.values(namedType.getFields())) {
-              collectReferencedTypes(field.type, typeSet);
-            }
-          }
-        }
-        return typeSet;
-      }
-      function validateSchema(schema) {
-        assertSchema(schema);
-        if (schema.__validationErrors) {
-          return schema.__validationErrors;
-        }
-        const context = new SchemaValidationContext(schema);
-        validateRootTypes(context);
-        validateDirectives(context);
-        validateTypes$1(context);
-        const errors2 = context.getErrors();
-        schema.__validationErrors = errors2;
-        return errors2;
-      }
-      function assertValidSchema(schema) {
-        const errors2 = validateSchema(schema);
-        if (errors2.length !== 0) {
-          throw new Error(errors2.map((error2) => error2.message).join("\n\n"));
-        }
-      }
-      class SchemaValidationContext {
-        constructor(schema) {
-          this._errors = [];
-          this.schema = schema;
-        }
-        reportError(message, nodes) {
-          const _nodes = Array.isArray(nodes) ? nodes.filter(Boolean) : nodes;
-          this._errors.push(
-            new GraphQLError(message, {
-              nodes: _nodes,
-            })
-          );
-        }
-        getErrors() {
-          return this._errors;
-        }
-      }
-      function validateRootTypes(context) {
-        const schema = context.schema;
-        const queryType = schema.getQueryType();
-        if (!queryType) {
-          context.reportError(
-            "Query root type must be provided.",
-            schema.astNode
-          );
-        } else if (!isObjectType(queryType)) {
-          var _getOperationTypeNode;
-          context.reportError(
-            `Query root type must be Object type, it cannot be ${inspect$2(
-              queryType
-            )}.`,
-            (_getOperationTypeNode = getOperationTypeNode(
-              schema,
-              OperationTypeNode.QUERY
-            )) !== null && _getOperationTypeNode !== void 0
-              ? _getOperationTypeNode
-              : queryType.astNode
-          );
-        }
-        const mutationType = schema.getMutationType();
-        if (mutationType && !isObjectType(mutationType)) {
-          var _getOperationTypeNode2;
-          context.reportError(
-            `Mutation root type must be Object type if provided, it cannot be ${inspect$2(
-              mutationType
-            )}.`,
-            (_getOperationTypeNode2 = getOperationTypeNode(
-              schema,
-              OperationTypeNode.MUTATION
-            )) !== null && _getOperationTypeNode2 !== void 0
-              ? _getOperationTypeNode2
-              : mutationType.astNode
-          );
-        }
-        const subscriptionType = schema.getSubscriptionType();
-        if (subscriptionType && !isObjectType(subscriptionType)) {
-          var _getOperationTypeNode3;
-          context.reportError(
-            `Subscription root type must be Object type if provided, it cannot be ${inspect$2(
-              subscriptionType
-            )}.`,
-            (_getOperationTypeNode3 = getOperationTypeNode(
-              schema,
-              OperationTypeNode.SUBSCRIPTION
-            )) !== null && _getOperationTypeNode3 !== void 0
-              ? _getOperationTypeNode3
-              : subscriptionType.astNode
-          );
-        }
-      }
-      function getOperationTypeNode(schema, operation) {
-        var _flatMap$find;
-        return (_flatMap$find = [schema.astNode, ...schema.extensionASTNodes]
-          .flatMap((schemaNode) => {
-            var _schemaNode$operation;
-            return (_schemaNode$operation =
-              schemaNode === null || schemaNode === void 0
-                ? void 0
-                : schemaNode.operationTypes) !== null &&
-              _schemaNode$operation !== void 0
-              ? _schemaNode$operation
-              : [];
-          })
-          .find((operationNode) => operationNode.operation === operation)) ===
-          null || _flatMap$find === void 0
-          ? void 0
-          : _flatMap$find.type;
-      }
-      function validateDirectives(context) {
-        for (const directive of context.schema.getDirectives()) {
-          if (!isDirective(directive)) {
-            context.reportError(
-              `Expected directive but got: ${inspect$2(directive)}.`,
-              directive === null || directive === void 0
-                ? void 0
-                : directive.astNode
-            );
-            continue;
-          }
-          validateName(context, directive);
-          for (const arg of directive.args) {
-            validateName(context, arg);
-            if (!isInputType(arg.type)) {
-              context.reportError(
-                `The type of @${directive.name}(${
-                  arg.name
-                }:) must be Input Type but got: ${inspect$2(arg.type)}.`,
-                arg.astNode
-              );
-            }
-            if (isRequiredArgument$1(arg) && arg.deprecationReason != null) {
-              var _arg$astNode;
-              context.reportError(
-                `Required argument @${directive.name}(${arg.name}:) cannot be deprecated.`,
-                [
-                  getDeprecatedDirectiveNode(arg.astNode),
-                  (_arg$astNode = arg.astNode) === null ||
-                  _arg$astNode === void 0
-                    ? void 0
-                    : _arg$astNode.type,
-                ]
-              );
-            }
-          }
-        }
-      }
-      function validateName(context, node) {
-        if (node.name.startsWith("__")) {
-          context.reportError(
-            `Name "${node.name}" must not begin with "__", which is reserved by GraphQL introspection.`,
-            node.astNode
-          );
-        }
-      }
-      function validateTypes$1(context) {
-        const validateInputObjectCircularRefs =
-          createInputObjectCircularRefsValidator(context);
-        const typeMap = context.schema.getTypeMap();
-        for (const type2 of Object.values(typeMap)) {
-          if (!isNamedType(type2)) {
-            context.reportError(
-              `Expected GraphQL named type but got: ${inspect$2(type2)}.`,
-              type2.astNode
-            );
-            continue;
-          }
-          if (!isIntrospectionType(type2)) {
-            validateName(context, type2);
-          }
-          if (isObjectType(type2)) {
-            validateFields(context, type2);
-            validateInterfaces(context, type2);
-          } else if (isInterfaceType(type2)) {
-            validateFields(context, type2);
-            validateInterfaces(context, type2);
-          } else if (isUnionType(type2)) {
-            validateUnionMembers(context, type2);
-          } else if (isEnumType(type2)) {
-            validateEnumValues(context, type2);
-          } else if (isInputObjectType(type2)) {
-            validateInputFields(context, type2);
-            validateInputObjectCircularRefs(type2);
-          }
-        }
-      }
-      function validateFields(context, type2) {
-        const fields = Object.values(type2.getFields());
-        if (fields.length === 0) {
-          context.reportError(
-            `Type ${type2.name} must define one or more fields.`,
-            [type2.astNode, ...type2.extensionASTNodes]
-          );
-        }
-        for (const field of fields) {
-          validateName(context, field);
-          if (!isOutputType(field.type)) {
-            var _field$astNode;
-            context.reportError(
-              `The type of ${type2.name}.${
-                field.name
-              } must be Output Type but got: ${inspect$2(field.type)}.`,
-              (_field$astNode = field.astNode) === null ||
-                _field$astNode === void 0
-                ? void 0
-                : _field$astNode.type
-            );
-          }
-          for (const arg of field.args) {
-            const argName = arg.name;
-            validateName(context, arg);
-            if (!isInputType(arg.type)) {
-              var _arg$astNode2;
-              context.reportError(
-                `The type of ${type2.name}.${
-                  field.name
-                }(${argName}:) must be Input Type but got: ${inspect$2(
-                  arg.type
-                )}.`,
-                (_arg$astNode2 = arg.astNode) === null ||
-                  _arg$astNode2 === void 0
-                  ? void 0
-                  : _arg$astNode2.type
-              );
-            }
-            if (isRequiredArgument$1(arg) && arg.deprecationReason != null) {
-              var _arg$astNode3;
-              context.reportError(
-                `Required argument ${type2.name}.${field.name}(${argName}:) cannot be deprecated.`,
-                [
-                  getDeprecatedDirectiveNode(arg.astNode),
-                  (_arg$astNode3 = arg.astNode) === null ||
-                  _arg$astNode3 === void 0
-                    ? void 0
-                    : _arg$astNode3.type,
-                ]
-              );
-            }
-          }
-        }
-      }
-      function validateInterfaces(context, type2) {
-        const ifaceTypeNames = /* @__PURE__ */ Object.create(null);
-        for (const iface of type2.getInterfaces()) {
-          if (!isInterfaceType(iface)) {
-            context.reportError(
-              `Type ${inspect$2(
-                type2
-              )} must only implement Interface types, it cannot implement ${inspect$2(
-                iface
-              )}.`,
-              getAllImplementsInterfaceNodes(type2, iface)
-            );
-            continue;
-          }
-          if (type2 === iface) {
-            context.reportError(
-              `Type ${type2.name} cannot implement itself because it would create a circular reference.`,
-              getAllImplementsInterfaceNodes(type2, iface)
-            );
-            continue;
-          }
-          if (ifaceTypeNames[iface.name]) {
-            context.reportError(
-              `Type ${type2.name} can only implement ${iface.name} once.`,
-              getAllImplementsInterfaceNodes(type2, iface)
-            );
-            continue;
-          }
-          ifaceTypeNames[iface.name] = true;
-          validateTypeImplementsAncestors(context, type2, iface);
-          validateTypeImplementsInterface(context, type2, iface);
-        }
-      }
-      function validateTypeImplementsInterface(context, type2, iface) {
-        const typeFieldMap = type2.getFields();
-        for (const ifaceField of Object.values(iface.getFields())) {
-          const fieldName = ifaceField.name;
-          const typeField = typeFieldMap[fieldName];
-          if (!typeField) {
-            context.reportError(
-              `Interface field ${iface.name}.${fieldName} expected but ${type2.name} does not provide it.`,
-              [ifaceField.astNode, type2.astNode, ...type2.extensionASTNodes]
-            );
-            continue;
-          }
-          if (
-            !isTypeSubTypeOf(context.schema, typeField.type, ifaceField.type)
-          ) {
-            var _ifaceField$astNode, _typeField$astNode;
-            context.reportError(
-              `Interface field ${
-                iface.name
-              }.${fieldName} expects type ${inspect$2(ifaceField.type)} but ${
-                type2.name
-              }.${fieldName} is type ${inspect$2(typeField.type)}.`,
-              [
-                (_ifaceField$astNode = ifaceField.astNode) === null ||
-                _ifaceField$astNode === void 0
-                  ? void 0
-                  : _ifaceField$astNode.type,
-                (_typeField$astNode = typeField.astNode) === null ||
-                _typeField$astNode === void 0
-                  ? void 0
-                  : _typeField$astNode.type,
-              ]
-            );
-          }
-          for (const ifaceArg of ifaceField.args) {
-            const argName = ifaceArg.name;
-            const typeArg = typeField.args.find((arg) => arg.name === argName);
-            if (!typeArg) {
-              context.reportError(
-                `Interface field argument ${iface.name}.${fieldName}(${argName}:) expected but ${type2.name}.${fieldName} does not provide it.`,
-                [ifaceArg.astNode, typeField.astNode]
-              );
-              continue;
-            }
-            if (!isEqualType(ifaceArg.type, typeArg.type)) {
-              var _ifaceArg$astNode, _typeArg$astNode;
-              context.reportError(
-                `Interface field argument ${
-                  iface.name
-                }.${fieldName}(${argName}:) expects type ${inspect$2(
-                  ifaceArg.type
-                )} but ${
-                  type2.name
-                }.${fieldName}(${argName}:) is type ${inspect$2(
-                  typeArg.type
-                )}.`,
-                [
-                  (_ifaceArg$astNode = ifaceArg.astNode) === null ||
-                  _ifaceArg$astNode === void 0
-                    ? void 0
-                    : _ifaceArg$astNode.type,
-                  (_typeArg$astNode = typeArg.astNode) === null ||
-                  _typeArg$astNode === void 0
-                    ? void 0
-                    : _typeArg$astNode.type,
-                ]
-              );
-            }
-          }
-          for (const typeArg of typeField.args) {
-            const argName = typeArg.name;
-            const ifaceArg = ifaceField.args.find(
-              (arg) => arg.name === argName
-            );
-            if (!ifaceArg && isRequiredArgument$1(typeArg)) {
-              context.reportError(
-                `Object field ${type2.name}.${fieldName} includes required argument ${argName} that is missing from the Interface field ${iface.name}.${fieldName}.`,
-                [typeArg.astNode, ifaceField.astNode]
-              );
-            }
-          }
-        }
-      }
-      function validateTypeImplementsAncestors(context, type2, iface) {
-        const ifaceInterfaces = type2.getInterfaces();
-        for (const transitive of iface.getInterfaces()) {
-          if (!ifaceInterfaces.includes(transitive)) {
-            context.reportError(
-              transitive === type2
-                ? `Type ${type2.name} cannot implement ${iface.name} because it would create a circular reference.`
-                : `Type ${type2.name} must implement ${transitive.name} because it is implemented by ${iface.name}.`,
-              [
-                ...getAllImplementsInterfaceNodes(iface, transitive),
-                ...getAllImplementsInterfaceNodes(type2, iface),
-              ]
-            );
-          }
-        }
-      }
-      function validateUnionMembers(context, union2) {
-        const memberTypes = union2.getTypes();
-        if (memberTypes.length === 0) {
-          context.reportError(
-            `Union type ${union2.name} must define one or more member types.`,
-            [union2.astNode, ...union2.extensionASTNodes]
-          );
-        }
-        const includedTypeNames = /* @__PURE__ */ Object.create(null);
-        for (const memberType of memberTypes) {
-          if (includedTypeNames[memberType.name]) {
-            context.reportError(
-              `Union type ${union2.name} can only include type ${memberType.name} once.`,
-              getUnionMemberTypeNodes(union2, memberType.name)
-            );
-            continue;
-          }
-          includedTypeNames[memberType.name] = true;
-          if (!isObjectType(memberType)) {
-            context.reportError(
-              `Union type ${
-                union2.name
-              } can only include Object types, it cannot include ${inspect$2(
-                memberType
-              )}.`,
-              getUnionMemberTypeNodes(union2, String(memberType))
-            );
-          }
-        }
-      }
-      function validateEnumValues(context, enumType) {
-        const enumValues = enumType.getValues();
-        if (enumValues.length === 0) {
-          context.reportError(
-            `Enum type ${enumType.name} must define one or more values.`,
-            [enumType.astNode, ...enumType.extensionASTNodes]
-          );
-        }
-        for (const enumValue of enumValues) {
-          validateName(context, enumValue);
-        }
-      }
-      function validateInputFields(context, inputObj) {
-        const fields = Object.values(inputObj.getFields());
-        if (fields.length === 0) {
-          context.reportError(
-            `Input Object type ${inputObj.name} must define one or more fields.`,
-            [inputObj.astNode, ...inputObj.extensionASTNodes]
-          );
-        }
-        for (const field of fields) {
-          validateName(context, field);
-          if (!isInputType(field.type)) {
-            var _field$astNode2;
-            context.reportError(
-              `The type of ${inputObj.name}.${
-                field.name
-              } must be Input Type but got: ${inspect$2(field.type)}.`,
-              (_field$astNode2 = field.astNode) === null ||
-                _field$astNode2 === void 0
-                ? void 0
-                : _field$astNode2.type
-            );
-          }
-          if (isRequiredInputField(field) && field.deprecationReason != null) {
-            var _field$astNode3;
-            context.reportError(
-              `Required input field ${inputObj.name}.${field.name} cannot be deprecated.`,
-              [
-                getDeprecatedDirectiveNode(field.astNode),
-                (_field$astNode3 = field.astNode) === null ||
-                _field$astNode3 === void 0
-                  ? void 0
-                  : _field$astNode3.type,
-              ]
-            );
-          }
-        }
-      }
-      function createInputObjectCircularRefsValidator(context) {
-        const visitedTypes = /* @__PURE__ */ Object.create(null);
-        const fieldPath = [];
-        const fieldPathIndexByTypeName = /* @__PURE__ */ Object.create(null);
-        return detectCycleRecursive;
-        function detectCycleRecursive(inputObj) {
-          if (visitedTypes[inputObj.name]) {
-            return;
-          }
-          visitedTypes[inputObj.name] = true;
-          fieldPathIndexByTypeName[inputObj.name] = fieldPath.length;
-          const fields = Object.values(inputObj.getFields());
-          for (const field of fields) {
-            if (
-              isNonNullType(field.type) &&
-              isInputObjectType(field.type.ofType)
-            ) {
-              const fieldType = field.type.ofType;
-              const cycleIndex = fieldPathIndexByTypeName[fieldType.name];
-              fieldPath.push(field);
-              if (cycleIndex === void 0) {
-                detectCycleRecursive(fieldType);
-              } else {
-                const cyclePath = fieldPath.slice(cycleIndex);
-                const pathStr = cyclePath
-                  .map((fieldObj) => fieldObj.name)
-                  .join(".");
-                context.reportError(
-                  `Cannot reference Input Object "${fieldType.name}" within itself through a series of non-null fields: "${pathStr}".`,
-                  cyclePath.map((fieldObj) => fieldObj.astNode)
-                );
-              }
-              fieldPath.pop();
-            }
-          }
-          fieldPathIndexByTypeName[inputObj.name] = void 0;
-        }
-      }
-      function getAllImplementsInterfaceNodes(type2, iface) {
-        const { astNode, extensionASTNodes } = type2;
-        const nodes =
-          astNode != null ? [astNode, ...extensionASTNodes] : extensionASTNodes;
-        return nodes
-          .flatMap((typeNode) => {
-            var _typeNode$interfaces;
-            return (_typeNode$interfaces = typeNode.interfaces) !== null &&
-              _typeNode$interfaces !== void 0
-              ? _typeNode$interfaces
-              : [];
-          })
-          .filter((ifaceNode) => ifaceNode.name.value === iface.name);
-      }
-      function getUnionMemberTypeNodes(union2, typeName) {
-        const { astNode, extensionASTNodes } = union2;
-        const nodes =
-          astNode != null ? [astNode, ...extensionASTNodes] : extensionASTNodes;
-        return nodes
-          .flatMap((unionNode) => {
-            var _unionNode$types;
-            return (_unionNode$types = unionNode.types) !== null &&
-              _unionNode$types !== void 0
-              ? _unionNode$types
-              : [];
-          })
-          .filter((typeNode) => typeNode.name.value === typeName);
-      }
-      function getDeprecatedDirectiveNode(definitionNode) {
-        var _definitionNode$direc;
-        return definitionNode === null || definitionNode === void 0
-          ? void 0
-          : (_definitionNode$direc = definitionNode.directives) === null ||
-            _definitionNode$direc === void 0
-          ? void 0
-          : _definitionNode$direc.find(
-              (node) => node.name.value === GraphQLDeprecatedDirective.name
-            );
-      }
-      function typeFromAST(schema, typeNode) {
-        switch (typeNode.kind) {
-          case Kind.LIST_TYPE: {
-            const innerType = typeFromAST(schema, typeNode.type);
-            return innerType && new GraphQLList(innerType);
-          }
-          case Kind.NON_NULL_TYPE: {
-            const innerType = typeFromAST(schema, typeNode.type);
-            return innerType && new GraphQLNonNull(innerType);
-          }
-          case Kind.NAMED_TYPE:
-            return schema.getType(typeNode.name.value);
-        }
-      }
-      class TypeInfo {
-        constructor(schema, initialType, getFieldDefFn) {
-          this._schema = schema;
-          this._typeStack = [];
-          this._parentTypeStack = [];
-          this._inputTypeStack = [];
-          this._fieldDefStack = [];
-          this._defaultValueStack = [];
-          this._directive = null;
-          this._argument = null;
-          this._enumValue = null;
-          this._getFieldDef =
-            getFieldDefFn !== null && getFieldDefFn !== void 0
-              ? getFieldDefFn
-              : getFieldDef$3;
-          if (initialType) {
-            if (isInputType(initialType)) {
-              this._inputTypeStack.push(initialType);
-            }
-            if (isCompositeType(initialType)) {
-              this._parentTypeStack.push(initialType);
-            }
-            if (isOutputType(initialType)) {
-              this._typeStack.push(initialType);
-            }
-          }
-        }
-        get [Symbol.toStringTag]() {
-          return "TypeInfo";
-        }
-        getType() {
-          if (this._typeStack.length > 0) {
-            return this._typeStack[this._typeStack.length - 1];
-          }
-        }
-        getParentType() {
-          if (this._parentTypeStack.length > 0) {
-            return this._parentTypeStack[this._parentTypeStack.length - 1];
-          }
-        }
-        getInputType() {
-          if (this._inputTypeStack.length > 0) {
-            return this._inputTypeStack[this._inputTypeStack.length - 1];
-          }
-        }
-        getParentInputType() {
-          if (this._inputTypeStack.length > 1) {
-            return this._inputTypeStack[this._inputTypeStack.length - 2];
-          }
-        }
-        getFieldDef() {
-          if (this._fieldDefStack.length > 0) {
-            return this._fieldDefStack[this._fieldDefStack.length - 1];
-          }
-        }
-        getDefaultValue() {
-          if (this._defaultValueStack.length > 0) {
-            return this._defaultValueStack[this._defaultValueStack.length - 1];
-          }
-        }
-        getDirective() {
-          return this._directive;
-        }
-        getArgument() {
-          return this._argument;
-        }
-        getEnumValue() {
-          return this._enumValue;
-        }
-        enter(node) {
-          const schema = this._schema;
-          switch (node.kind) {
-            case Kind.SELECTION_SET: {
-              const namedType = getNamedType(this.getType());
-              this._parentTypeStack.push(
-                isCompositeType(namedType) ? namedType : void 0
-              );
-              break;
-            }
-            case Kind.FIELD: {
-              const parentType = this.getParentType();
-              let fieldDef;
-              let fieldType;
-              if (parentType) {
-                fieldDef = this._getFieldDef(schema, parentType, node);
-                if (fieldDef) {
-                  fieldType = fieldDef.type;
-                }
-              }
-              this._fieldDefStack.push(fieldDef);
-              this._typeStack.push(
-                isOutputType(fieldType) ? fieldType : void 0
-              );
-              break;
-            }
-            case Kind.DIRECTIVE:
-              this._directive = schema.getDirective(node.name.value);
-              break;
-            case Kind.OPERATION_DEFINITION: {
-              const rootType = schema.getRootType(node.operation);
-              this._typeStack.push(isObjectType(rootType) ? rootType : void 0);
-              break;
-            }
-            case Kind.INLINE_FRAGMENT:
-            case Kind.FRAGMENT_DEFINITION: {
-              const typeConditionAST = node.typeCondition;
-              const outputType = typeConditionAST
-                ? typeFromAST(schema, typeConditionAST)
-                : getNamedType(this.getType());
-              this._typeStack.push(
-                isOutputType(outputType) ? outputType : void 0
-              );
-              break;
-            }
-            case Kind.VARIABLE_DEFINITION: {
-              const inputType = typeFromAST(schema, node.type);
-              this._inputTypeStack.push(
-                isInputType(inputType) ? inputType : void 0
-              );
-              break;
-            }
-            case Kind.ARGUMENT: {
-              var _this$getDirective;
-              let argDef;
-              let argType;
-              const fieldOrDirective =
-                (_this$getDirective = this.getDirective()) !== null &&
-                _this$getDirective !== void 0
-                  ? _this$getDirective
-                  : this.getFieldDef();
-              if (fieldOrDirective) {
-                argDef = fieldOrDirective.args.find(
-                  (arg) => arg.name === node.name.value
-                );
-                if (argDef) {
-                  argType = argDef.type;
-                }
-              }
-              this._argument = argDef;
-              this._defaultValueStack.push(
-                argDef ? argDef.defaultValue : void 0
-              );
-              this._inputTypeStack.push(
-                isInputType(argType) ? argType : void 0
-              );
-              break;
-            }
-            case Kind.LIST: {
-              const listType = getNullableType(this.getInputType());
-              const itemType = isListType(listType)
-                ? listType.ofType
-                : listType;
-              this._defaultValueStack.push(void 0);
-              this._inputTypeStack.push(
-                isInputType(itemType) ? itemType : void 0
-              );
-              break;
-            }
-            case Kind.OBJECT_FIELD: {
-              const objectType = getNamedType(this.getInputType());
-              let inputFieldType;
-              let inputField;
-              if (isInputObjectType(objectType)) {
-                inputField = objectType.getFields()[node.name.value];
-                if (inputField) {
-                  inputFieldType = inputField.type;
-                }
-              }
-              this._defaultValueStack.push(
-                inputField ? inputField.defaultValue : void 0
-              );
-              this._inputTypeStack.push(
-                isInputType(inputFieldType) ? inputFieldType : void 0
-              );
-              break;
-            }
-            case Kind.ENUM: {
-              const enumType = getNamedType(this.getInputType());
-              let enumValue;
-              if (isEnumType(enumType)) {
-                enumValue = enumType.getValue(node.value);
-              }
-              this._enumValue = enumValue;
-              break;
-            }
-          }
-        }
-        leave(node) {
-          switch (node.kind) {
-            case Kind.SELECTION_SET:
-              this._parentTypeStack.pop();
-              break;
-            case Kind.FIELD:
-              this._fieldDefStack.pop();
-              this._typeStack.pop();
-              break;
-            case Kind.DIRECTIVE:
-              this._directive = null;
-              break;
-            case Kind.OPERATION_DEFINITION:
-            case Kind.INLINE_FRAGMENT:
-            case Kind.FRAGMENT_DEFINITION:
-              this._typeStack.pop();
-              break;
-            case Kind.VARIABLE_DEFINITION:
-              this._inputTypeStack.pop();
-              break;
-            case Kind.ARGUMENT:
-              this._argument = null;
-              this._defaultValueStack.pop();
-              this._inputTypeStack.pop();
-              break;
-            case Kind.LIST:
-            case Kind.OBJECT_FIELD:
-              this._defaultValueStack.pop();
-              this._inputTypeStack.pop();
-              break;
-            case Kind.ENUM:
-              this._enumValue = null;
-              break;
-          }
-        }
-      }
-      function getFieldDef$3(schema, parentType, fieldNode) {
-        const name2 = fieldNode.name.value;
-        if (
-          name2 === SchemaMetaFieldDef$1.name &&
-          schema.getQueryType() === parentType
-        ) {
-          return SchemaMetaFieldDef$1;
-        }
-        if (
-          name2 === TypeMetaFieldDef$1.name &&
-          schema.getQueryType() === parentType
-        ) {
-          return TypeMetaFieldDef$1;
-        }
-        if (
-          name2 === TypeNameMetaFieldDef.name &&
-          isCompositeType(parentType)
-        ) {
-          return TypeNameMetaFieldDef;
-        }
-        if (isObjectType(parentType) || isInterfaceType(parentType)) {
-          return parentType.getFields()[name2];
-        }
-      }
-      function visitWithTypeInfo(typeInfo, visitor) {
-        return {
-          enter(...args) {
-            const node = args[0];
-            typeInfo.enter(node);
-            const fn = getEnterLeaveForKind(visitor, node.kind).enter;
-            if (fn) {
-              const result2 = fn.apply(visitor, args);
-              if (result2 !== void 0) {
-                typeInfo.leave(node);
-                if (isNode(result2)) {
-                  typeInfo.enter(result2);
-                }
-              }
-              return result2;
-            }
-          },
-          leave(...args) {
-            const node = args[0];
-            const fn = getEnterLeaveForKind(visitor, node.kind).leave;
-            let result2;
-            if (fn) {
-              result2 = fn.apply(visitor, args);
-            }
-            typeInfo.leave(node);
-            return result2;
-          },
-        };
-      }
-      function isDefinitionNode(node) {
-        return (
-          isExecutableDefinitionNode(node) ||
-          isTypeSystemDefinitionNode(node) ||
-          isTypeSystemExtensionNode(node)
-        );
-      }
-      function isExecutableDefinitionNode(node) {
-        return (
-          node.kind === Kind.OPERATION_DEFINITION ||
-          node.kind === Kind.FRAGMENT_DEFINITION
-        );
-      }
-      function isSelectionNode(node) {
-        return (
-          node.kind === Kind.FIELD ||
-          node.kind === Kind.FRAGMENT_SPREAD ||
-          node.kind === Kind.INLINE_FRAGMENT
-        );
-      }
-      function isValueNode(node) {
-        return (
-          node.kind === Kind.VARIABLE ||
-          node.kind === Kind.INT ||
-          node.kind === Kind.FLOAT ||
-          node.kind === Kind.STRING ||
-          node.kind === Kind.BOOLEAN ||
-          node.kind === Kind.NULL ||
-          node.kind === Kind.ENUM ||
-          node.kind === Kind.LIST ||
-          node.kind === Kind.OBJECT
-        );
-      }
-      function isConstValueNode(node) {
-        return (
-          isValueNode(node) &&
-          (node.kind === Kind.LIST
-            ? node.values.some(isConstValueNode)
-            : node.kind === Kind.OBJECT
-            ? node.fields.some((field) => isConstValueNode(field.value))
-            : node.kind !== Kind.VARIABLE)
-        );
-      }
-      function isTypeNode(node) {
-        return (
-          node.kind === Kind.NAMED_TYPE ||
-          node.kind === Kind.LIST_TYPE ||
-          node.kind === Kind.NON_NULL_TYPE
-        );
-      }
-      function isTypeSystemDefinitionNode(node) {
-        return (
-          node.kind === Kind.SCHEMA_DEFINITION ||
-          isTypeDefinitionNode(node) ||
-          node.kind === Kind.DIRECTIVE_DEFINITION
-        );
-      }
-      function isTypeDefinitionNode(node) {
-        return (
-          node.kind === Kind.SCALAR_TYPE_DEFINITION ||
-          node.kind === Kind.OBJECT_TYPE_DEFINITION ||
-          node.kind === Kind.INTERFACE_TYPE_DEFINITION ||
-          node.kind === Kind.UNION_TYPE_DEFINITION ||
-          node.kind === Kind.ENUM_TYPE_DEFINITION ||
-          node.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION
-        );
-      }
-      function isTypeSystemExtensionNode(node) {
-        return node.kind === Kind.SCHEMA_EXTENSION || isTypeExtensionNode(node);
-      }
-      function isTypeExtensionNode(node) {
-        return (
-          node.kind === Kind.SCALAR_TYPE_EXTENSION ||
-          node.kind === Kind.OBJECT_TYPE_EXTENSION ||
-          node.kind === Kind.INTERFACE_TYPE_EXTENSION ||
-          node.kind === Kind.UNION_TYPE_EXTENSION ||
-          node.kind === Kind.ENUM_TYPE_EXTENSION ||
-          node.kind === Kind.INPUT_OBJECT_TYPE_EXTENSION
-        );
-      }
-      function ExecutableDefinitionsRule(context) {
-        return {
-          Document(node) {
-            for (const definition of node.definitions) {
-              if (!isExecutableDefinitionNode(definition)) {
-                const defName =
-                  definition.kind === Kind.SCHEMA_DEFINITION ||
-                  definition.kind === Kind.SCHEMA_EXTENSION
-                    ? "schema"
-                    : '"' + definition.name.value + '"';
-                context.reportError(
-                  new GraphQLError(
-                    `The ${defName} definition is not executable.`,
-                    {
-                      nodes: definition,
-                    }
-                  )
-                );
-              }
-            }
-            return false;
-          },
-        };
-      }
-      function FieldsOnCorrectTypeRule(context) {
-        return {
-          Field(node) {
-            const type2 = context.getParentType();
-            if (type2) {
-              const fieldDef = context.getFieldDef();
-              if (!fieldDef) {
-                const schema = context.getSchema();
-                const fieldName = node.name.value;
-                let suggestion = didYouMean$1(
-                  "to use an inline fragment on",
-                  getSuggestedTypeNames(schema, type2, fieldName)
-                );
-                if (suggestion === "") {
-                  suggestion = didYouMean$1(
-                    getSuggestedFieldNames(type2, fieldName)
-                  );
-                }
-                context.reportError(
-                  new GraphQLError(
-                    `Cannot query field "${fieldName}" on type "${type2.name}".` +
-                      suggestion,
-                    {
-                      nodes: node,
-                    }
-                  )
-                );
-              }
-            }
-          },
-        };
-      }
-      function getSuggestedTypeNames(schema, type2, fieldName) {
-        if (!isAbstractType(type2)) {
-          return [];
-        }
-        const suggestedTypes = /* @__PURE__ */ new Set();
-        const usageCount = /* @__PURE__ */ Object.create(null);
-        for (const possibleType of schema.getPossibleTypes(type2)) {
-          if (!possibleType.getFields()[fieldName]) {
-            continue;
-          }
-          suggestedTypes.add(possibleType);
-          usageCount[possibleType.name] = 1;
-          for (const possibleInterface of possibleType.getInterfaces()) {
-            var _usageCount$possibleI;
-            if (!possibleInterface.getFields()[fieldName]) {
-              continue;
-            }
-            suggestedTypes.add(possibleInterface);
-            usageCount[possibleInterface.name] =
-              ((_usageCount$possibleI = usageCount[possibleInterface.name]) !==
-                null && _usageCount$possibleI !== void 0
-                ? _usageCount$possibleI
-                : 0) + 1;
-          }
-        }
-        return [...suggestedTypes]
-          .sort((typeA, typeB) => {
-            const usageCountDiff =
-              usageCount[typeB.name] - usageCount[typeA.name];
-            if (usageCountDiff !== 0) {
-              return usageCountDiff;
-            }
-            if (isInterfaceType(typeA) && schema.isSubType(typeA, typeB)) {
-              return -1;
-            }
-            if (isInterfaceType(typeB) && schema.isSubType(typeB, typeA)) {
-              return 1;
-            }
-            return naturalCompare$1(typeA.name, typeB.name);
-          })
-          .map((x2) => x2.name);
-      }
-      function getSuggestedFieldNames(type2, fieldName) {
-        if (isObjectType(type2) || isInterfaceType(type2)) {
-          const possibleFieldNames = Object.keys(type2.getFields());
-          return suggestionList$1(fieldName, possibleFieldNames);
-        }
-        return [];
-      }
-      function FragmentsOnCompositeTypesRule(context) {
-        return {
-          InlineFragment(node) {
-            const typeCondition = node.typeCondition;
-            if (typeCondition) {
-              const type2 = typeFromAST(context.getSchema(), typeCondition);
-              if (type2 && !isCompositeType(type2)) {
-                const typeStr = print(typeCondition);
-                context.reportError(
-                  new GraphQLError(
-                    `Fragment cannot condition on non composite type "${typeStr}".`,
-                    {
-                      nodes: typeCondition,
-                    }
-                  )
-                );
-              }
-            }
-          },
-          FragmentDefinition(node) {
-            const type2 = typeFromAST(context.getSchema(), node.typeCondition);
-            if (type2 && !isCompositeType(type2)) {
-              const typeStr = print(node.typeCondition);
-              context.reportError(
-                new GraphQLError(
-                  `Fragment "${node.name.value}" cannot condition on non composite type "${typeStr}".`,
-                  {
-                    nodes: node.typeCondition,
-                  }
-                )
-              );
-            }
-          },
-        };
-      }
-      function KnownArgumentNamesRule(context) {
-        return __spreadProps(
-          __spreadValues({}, KnownArgumentNamesOnDirectivesRule(context)),
-          {
-            Argument(argNode) {
-              const argDef = context.getArgument();
-              const fieldDef = context.getFieldDef();
-              const parentType = context.getParentType();
-              if (!argDef && fieldDef && parentType) {
-                const argName = argNode.name.value;
-                const knownArgsNames = fieldDef.args.map((arg) => arg.name);
-                const suggestions = suggestionList$1(argName, knownArgsNames);
-                context.reportError(
-                  new GraphQLError(
-                    `Unknown argument "${argName}" on field "${parentType.name}.${fieldDef.name}".` +
-                      didYouMean$1(suggestions),
-                    {
-                      nodes: argNode,
-                    }
-                  )
-                );
-              }
-            },
-          }
-        );
-      }
-      function KnownArgumentNamesOnDirectivesRule(context) {
-        const directiveArgs = /* @__PURE__ */ Object.create(null);
-        const schema = context.getSchema();
-        const definedDirectives = schema
-          ? schema.getDirectives()
-          : specifiedDirectives;
-        for (const directive of definedDirectives) {
-          directiveArgs[directive.name] = directive.args.map((arg) => arg.name);
-        }
-        const astDefinitions = context.getDocument().definitions;
-        for (const def of astDefinitions) {
-          if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-            var _def$arguments;
-            const argsNodes =
-              (_def$arguments = def.arguments) !== null &&
-              _def$arguments !== void 0
-                ? _def$arguments
-                : [];
-            directiveArgs[def.name.value] = argsNodes.map(
-              (arg) => arg.name.value
-            );
-          }
-        }
-        return {
-          Directive(directiveNode) {
-            const directiveName = directiveNode.name.value;
-            const knownArgs = directiveArgs[directiveName];
-            if (directiveNode.arguments && knownArgs) {
-              for (const argNode of directiveNode.arguments) {
-                const argName = argNode.name.value;
-                if (!knownArgs.includes(argName)) {
-                  const suggestions = suggestionList$1(argName, knownArgs);
-                  context.reportError(
-                    new GraphQLError(
-                      `Unknown argument "${argName}" on directive "@${directiveName}".` +
-                        didYouMean$1(suggestions),
-                      {
-                        nodes: argNode,
-                      }
-                    )
-                  );
-                }
-              }
-            }
-            return false;
-          },
-        };
-      }
-      function KnownDirectivesRule(context) {
-        const locationsMap = /* @__PURE__ */ Object.create(null);
-        const schema = context.getSchema();
-        const definedDirectives = schema
-          ? schema.getDirectives()
-          : specifiedDirectives;
-        for (const directive of definedDirectives) {
-          locationsMap[directive.name] = directive.locations;
-        }
-        const astDefinitions = context.getDocument().definitions;
-        for (const def of astDefinitions) {
-          if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-            locationsMap[def.name.value] = def.locations.map(
-              (name2) => name2.value
-            );
-          }
-        }
-        return {
-          Directive(node, _key, _parent, _path, ancestors) {
-            const name2 = node.name.value;
-            const locations = locationsMap[name2];
-            if (!locations) {
-              context.reportError(
-                new GraphQLError(`Unknown directive "@${name2}".`, {
-                  nodes: node,
-                })
-              );
-              return;
-            }
-            const candidateLocation = getDirectiveLocationForASTPath(ancestors);
-            if (candidateLocation && !locations.includes(candidateLocation)) {
-              context.reportError(
-                new GraphQLError(
-                  `Directive "@${name2}" may not be used on ${candidateLocation}.`,
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-            }
-          },
-        };
-      }
-      function getDirectiveLocationForASTPath(ancestors) {
-        const appliedTo = ancestors[ancestors.length - 1];
-        "kind" in appliedTo || invariant$2(false);
-        switch (appliedTo.kind) {
-          case Kind.OPERATION_DEFINITION:
-            return getDirectiveLocationForOperation(appliedTo.operation);
-          case Kind.FIELD:
-            return DirectiveLocation.FIELD;
-          case Kind.FRAGMENT_SPREAD:
-            return DirectiveLocation.FRAGMENT_SPREAD;
-          case Kind.INLINE_FRAGMENT:
-            return DirectiveLocation.INLINE_FRAGMENT;
-          case Kind.FRAGMENT_DEFINITION:
-            return DirectiveLocation.FRAGMENT_DEFINITION;
-          case Kind.VARIABLE_DEFINITION:
-            return DirectiveLocation.VARIABLE_DEFINITION;
-          case Kind.SCHEMA_DEFINITION:
-          case Kind.SCHEMA_EXTENSION:
-            return DirectiveLocation.SCHEMA;
-          case Kind.SCALAR_TYPE_DEFINITION:
-          case Kind.SCALAR_TYPE_EXTENSION:
-            return DirectiveLocation.SCALAR;
-          case Kind.OBJECT_TYPE_DEFINITION:
-          case Kind.OBJECT_TYPE_EXTENSION:
-            return DirectiveLocation.OBJECT;
-          case Kind.FIELD_DEFINITION:
-            return DirectiveLocation.FIELD_DEFINITION;
-          case Kind.INTERFACE_TYPE_DEFINITION:
-          case Kind.INTERFACE_TYPE_EXTENSION:
-            return DirectiveLocation.INTERFACE;
-          case Kind.UNION_TYPE_DEFINITION:
-          case Kind.UNION_TYPE_EXTENSION:
-            return DirectiveLocation.UNION;
-          case Kind.ENUM_TYPE_DEFINITION:
-          case Kind.ENUM_TYPE_EXTENSION:
-            return DirectiveLocation.ENUM;
-          case Kind.ENUM_VALUE_DEFINITION:
-            return DirectiveLocation.ENUM_VALUE;
-          case Kind.INPUT_OBJECT_TYPE_DEFINITION:
-          case Kind.INPUT_OBJECT_TYPE_EXTENSION:
-            return DirectiveLocation.INPUT_OBJECT;
-          case Kind.INPUT_VALUE_DEFINITION: {
-            const parentNode = ancestors[ancestors.length - 3];
-            "kind" in parentNode || invariant$2(false);
-            return parentNode.kind === Kind.INPUT_OBJECT_TYPE_DEFINITION
-              ? DirectiveLocation.INPUT_FIELD_DEFINITION
-              : DirectiveLocation.ARGUMENT_DEFINITION;
-          }
-          default:
-            invariant$2(false, "Unexpected kind: " + inspect$2(appliedTo.kind));
-        }
-      }
-      function getDirectiveLocationForOperation(operation) {
-        switch (operation) {
-          case OperationTypeNode.QUERY:
-            return DirectiveLocation.QUERY;
-          case OperationTypeNode.MUTATION:
-            return DirectiveLocation.MUTATION;
-          case OperationTypeNode.SUBSCRIPTION:
-            return DirectiveLocation.SUBSCRIPTION;
-        }
-      }
-      function KnownFragmentNamesRule(context) {
-        return {
-          FragmentSpread(node) {
-            const fragmentName = node.name.value;
-            const fragment = context.getFragment(fragmentName);
-            if (!fragment) {
-              context.reportError(
-                new GraphQLError(`Unknown fragment "${fragmentName}".`, {
-                  nodes: node.name,
-                })
-              );
-            }
-          },
-        };
-      }
-      function KnownTypeNamesRule(context) {
-        const schema = context.getSchema();
-        const existingTypesMap = schema
-          ? schema.getTypeMap()
-          : /* @__PURE__ */ Object.create(null);
-        const definedTypes = /* @__PURE__ */ Object.create(null);
-        for (const def of context.getDocument().definitions) {
-          if (isTypeDefinitionNode(def)) {
-            definedTypes[def.name.value] = true;
-          }
-        }
-        const typeNames = [
-          ...Object.keys(existingTypesMap),
-          ...Object.keys(definedTypes),
-        ];
-        return {
-          NamedType(node, _1, parent, _2, ancestors) {
-            const typeName = node.name.value;
-            if (!existingTypesMap[typeName] && !definedTypes[typeName]) {
-              var _ancestors$;
-              const definitionNode =
-                (_ancestors$ = ancestors[2]) !== null && _ancestors$ !== void 0
-                  ? _ancestors$
-                  : parent;
-              const isSDL = definitionNode != null && isSDLNode(definitionNode);
-              if (isSDL && standardTypeNames.includes(typeName)) {
-                return;
-              }
-              const suggestedTypes = suggestionList$1(
-                typeName,
-                isSDL ? standardTypeNames.concat(typeNames) : typeNames
-              );
-              context.reportError(
-                new GraphQLError(
-                  `Unknown type "${typeName}".` + didYouMean$1(suggestedTypes),
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-            }
-          },
-        };
-      }
-      const standardTypeNames = [
-        ...specifiedScalarTypes,
-        ...introspectionTypes$1,
-      ].map((type2) => type2.name);
-      function isSDLNode(value) {
-        return (
-          "kind" in value &&
-          (isTypeSystemDefinitionNode(value) ||
-            isTypeSystemExtensionNode(value))
-        );
-      }
-      function LoneAnonymousOperationRule(context) {
-        let operationCount = 0;
-        return {
-          Document(node) {
-            operationCount = node.definitions.filter(
-              (definition) => definition.kind === Kind.OPERATION_DEFINITION
-            ).length;
-          },
-          OperationDefinition(node) {
-            if (!node.name && operationCount > 1) {
-              context.reportError(
-                new GraphQLError(
-                  "This anonymous operation must be the only defined operation.",
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-            }
-          },
-        };
-      }
-      function LoneSchemaDefinitionRule(context) {
-        var _ref, _ref2, _oldSchema$astNode;
-        const oldSchema = context.getSchema();
-        const alreadyDefined =
-          (_ref =
-            (_ref2 =
-              (_oldSchema$astNode =
-                oldSchema === null || oldSchema === void 0
-                  ? void 0
-                  : oldSchema.astNode) !== null && _oldSchema$astNode !== void 0
-                ? _oldSchema$astNode
-                : oldSchema === null || oldSchema === void 0
-                ? void 0
-                : oldSchema.getQueryType()) !== null && _ref2 !== void 0
-              ? _ref2
-              : oldSchema === null || oldSchema === void 0
-              ? void 0
-              : oldSchema.getMutationType()) !== null && _ref !== void 0
-            ? _ref
-            : oldSchema === null || oldSchema === void 0
-            ? void 0
-            : oldSchema.getSubscriptionType();
-        let schemaDefinitionsCount = 0;
-        return {
-          SchemaDefinition(node) {
-            if (alreadyDefined) {
-              context.reportError(
-                new GraphQLError(
-                  "Cannot define a new schema within a schema extension.",
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-              return;
-            }
-            if (schemaDefinitionsCount > 0) {
-              context.reportError(
-                new GraphQLError("Must provide only one schema definition.", {
-                  nodes: node,
-                })
-              );
-            }
-            ++schemaDefinitionsCount;
-          },
-        };
-      }
-      function NoFragmentCyclesRule(context) {
-        const visitedFrags = /* @__PURE__ */ Object.create(null);
-        const spreadPath = [];
-        const spreadPathIndexByName = /* @__PURE__ */ Object.create(null);
-        return {
-          OperationDefinition: () => false,
-          FragmentDefinition(node) {
-            detectCycleRecursive(node);
-            return false;
-          },
-        };
-        function detectCycleRecursive(fragment) {
-          if (visitedFrags[fragment.name.value]) {
-            return;
-          }
-          const fragmentName = fragment.name.value;
-          visitedFrags[fragmentName] = true;
-          const spreadNodes = context.getFragmentSpreads(fragment.selectionSet);
-          if (spreadNodes.length === 0) {
-            return;
-          }
-          spreadPathIndexByName[fragmentName] = spreadPath.length;
-          for (const spreadNode of spreadNodes) {
-            const spreadName = spreadNode.name.value;
-            const cycleIndex = spreadPathIndexByName[spreadName];
-            spreadPath.push(spreadNode);
-            if (cycleIndex === void 0) {
-              const spreadFragment = context.getFragment(spreadName);
-              if (spreadFragment) {
-                detectCycleRecursive(spreadFragment);
-              }
-            } else {
-              const cyclePath = spreadPath.slice(cycleIndex);
-              const viaPath = cyclePath
-                .slice(0, -1)
-                .map((s) => '"' + s.name.value + '"')
-                .join(", ");
-              context.reportError(
-                new GraphQLError(
-                  `Cannot spread fragment "${spreadName}" within itself` +
-                    (viaPath !== "" ? ` via ${viaPath}.` : "."),
-                  {
-                    nodes: cyclePath,
-                  }
-                )
-              );
-            }
-            spreadPath.pop();
-          }
-          spreadPathIndexByName[fragmentName] = void 0;
-        }
-      }
-      function NoUndefinedVariablesRule(context) {
-        let variableNameDefined = /* @__PURE__ */ Object.create(null);
-        return {
-          OperationDefinition: {
-            enter() {
-              variableNameDefined = /* @__PURE__ */ Object.create(null);
-            },
-            leave(operation) {
-              const usages = context.getRecursiveVariableUsages(operation);
-              for (const { node } of usages) {
-                const varName = node.name.value;
-                if (variableNameDefined[varName] !== true) {
-                  context.reportError(
-                    new GraphQLError(
-                      operation.name
-                        ? `Variable "$${varName}" is not defined by operation "${operation.name.value}".`
-                        : `Variable "$${varName}" is not defined.`,
-                      {
-                        nodes: [node, operation],
-                      }
-                    )
-                  );
-                }
-              }
-            },
-          },
-          VariableDefinition(node) {
-            variableNameDefined[node.variable.name.value] = true;
-          },
-        };
-      }
-      function NoUnusedFragmentsRule(context) {
-        const operationDefs = [];
-        const fragmentDefs = [];
-        return {
-          OperationDefinition(node) {
-            operationDefs.push(node);
-            return false;
-          },
-          FragmentDefinition(node) {
-            fragmentDefs.push(node);
-            return false;
-          },
-          Document: {
-            leave() {
-              const fragmentNameUsed = /* @__PURE__ */ Object.create(null);
-              for (const operation of operationDefs) {
-                for (const fragment of context.getRecursivelyReferencedFragments(
-                  operation
-                )) {
-                  fragmentNameUsed[fragment.name.value] = true;
-                }
-              }
-              for (const fragmentDef of fragmentDefs) {
-                const fragName = fragmentDef.name.value;
-                if (fragmentNameUsed[fragName] !== true) {
-                  context.reportError(
-                    new GraphQLError(`Fragment "${fragName}" is never used.`, {
-                      nodes: fragmentDef,
-                    })
-                  );
-                }
-              }
-            },
-          },
-        };
-      }
-      function NoUnusedVariablesRule(context) {
-        let variableDefs = [];
-        return {
-          OperationDefinition: {
-            enter() {
-              variableDefs = [];
-            },
-            leave(operation) {
-              const variableNameUsed = /* @__PURE__ */ Object.create(null);
-              const usages = context.getRecursiveVariableUsages(operation);
-              for (const { node } of usages) {
-                variableNameUsed[node.name.value] = true;
-              }
-              for (const variableDef of variableDefs) {
-                const variableName = variableDef.variable.name.value;
-                if (variableNameUsed[variableName] !== true) {
-                  context.reportError(
-                    new GraphQLError(
-                      operation.name
-                        ? `Variable "$${variableName}" is never used in operation "${operation.name.value}".`
-                        : `Variable "$${variableName}" is never used.`,
-                      {
-                        nodes: variableDef,
-                      }
-                    )
-                  );
-                }
-              }
-            },
-          },
-          VariableDefinition(def) {
-            variableDefs.push(def);
-          },
-        };
-      }
-      function sortValueNode(valueNode) {
-        switch (valueNode.kind) {
-          case Kind.OBJECT:
-            return __spreadProps(__spreadValues({}, valueNode), {
-              fields: sortFields(valueNode.fields),
-            });
-          case Kind.LIST:
-            return __spreadProps(__spreadValues({}, valueNode), {
-              values: valueNode.values.map(sortValueNode),
-            });
-          case Kind.INT:
-          case Kind.FLOAT:
-          case Kind.STRING:
-          case Kind.BOOLEAN:
-          case Kind.NULL:
-          case Kind.ENUM:
-          case Kind.VARIABLE:
-            return valueNode;
-        }
-      }
-      function sortFields(fields) {
-        return fields
-          .map((fieldNode) =>
-            __spreadProps(__spreadValues({}, fieldNode), {
-              value: sortValueNode(fieldNode.value),
-            })
-          )
-          .sort((fieldA, fieldB) =>
-            naturalCompare$1(fieldA.name.value, fieldB.name.value)
-          );
-      }
-      function reasonMessage(reason) {
-        if (Array.isArray(reason)) {
-          return reason
-            .map(
-              ([responseName, subReason]) =>
-                `subfields "${responseName}" conflict because ` +
-                reasonMessage(subReason)
-            )
-            .join(" and ");
-        }
-        return reason;
-      }
-      function OverlappingFieldsCanBeMergedRule(context) {
-        const comparedFragmentPairs = new PairSet();
-        const cachedFieldsAndFragmentNames = /* @__PURE__ */ new Map();
-        return {
-          SelectionSet(selectionSet) {
-            const conflicts = findConflictsWithinSelectionSet(
-              context,
-              cachedFieldsAndFragmentNames,
-              comparedFragmentPairs,
-              context.getParentType(),
-              selectionSet
-            );
-            for (const [
-              [responseName, reason],
-              fields1,
-              fields2,
-            ] of conflicts) {
-              const reasonMsg = reasonMessage(reason);
-              context.reportError(
-                new GraphQLError(
-                  `Fields "${responseName}" conflict because ${reasonMsg}. Use different aliases on the fields to fetch both if this was intentional.`,
-                  {
-                    nodes: fields1.concat(fields2),
-                  }
-                )
-              );
-            }
-          },
-        };
-      }
-      function findConflictsWithinSelectionSet(
-        context,
-        cachedFieldsAndFragmentNames,
-        comparedFragmentPairs,
-        parentType,
-        selectionSet
-      ) {
-        const conflicts = [];
-        const [fieldMap, fragmentNames] = getFieldsAndFragmentNames(
-          context,
-          cachedFieldsAndFragmentNames,
-          parentType,
-          selectionSet
-        );
-        collectConflictsWithin(
-          context,
-          conflicts,
-          cachedFieldsAndFragmentNames,
-          comparedFragmentPairs,
-          fieldMap
-        );
-        if (fragmentNames.length !== 0) {
-          for (let i = 0; i < fragmentNames.length; i++) {
-            collectConflictsBetweenFieldsAndFragment(
-              context,
-              conflicts,
-              cachedFieldsAndFragmentNames,
-              comparedFragmentPairs,
-              false,
-              fieldMap,
-              fragmentNames[i]
-            );
-            for (let j = i + 1; j < fragmentNames.length; j++) {
-              collectConflictsBetweenFragments(
-                context,
-                conflicts,
-                cachedFieldsAndFragmentNames,
-                comparedFragmentPairs,
-                false,
-                fragmentNames[i],
-                fragmentNames[j]
-              );
-            }
-          }
-        }
-        return conflicts;
-      }
-      function collectConflictsBetweenFieldsAndFragment(
-        context,
-        conflicts,
-        cachedFieldsAndFragmentNames,
-        comparedFragmentPairs,
-        areMutuallyExclusive,
-        fieldMap,
-        fragmentName
-      ) {
-        const fragment = context.getFragment(fragmentName);
-        if (!fragment) {
-          return;
-        }
-        const [fieldMap2, referencedFragmentNames] =
-          getReferencedFieldsAndFragmentNames(
-            context,
-            cachedFieldsAndFragmentNames,
-            fragment
-          );
-        if (fieldMap === fieldMap2) {
-          return;
-        }
-        collectConflictsBetween(
-          context,
-          conflicts,
-          cachedFieldsAndFragmentNames,
-          comparedFragmentPairs,
-          areMutuallyExclusive,
-          fieldMap,
-          fieldMap2
-        );
-        for (const referencedFragmentName of referencedFragmentNames) {
-          if (
-            comparedFragmentPairs.has(
-              referencedFragmentName,
-              fragmentName,
-              areMutuallyExclusive
-            )
-          ) {
-            continue;
-          }
-          comparedFragmentPairs.add(
-            referencedFragmentName,
-            fragmentName,
-            areMutuallyExclusive
-          );
-          collectConflictsBetweenFieldsAndFragment(
-            context,
-            conflicts,
-            cachedFieldsAndFragmentNames,
-            comparedFragmentPairs,
-            areMutuallyExclusive,
-            fieldMap,
-            referencedFragmentName
-          );
-        }
-      }
-      function collectConflictsBetweenFragments(
-        context,
-        conflicts,
-        cachedFieldsAndFragmentNames,
-        comparedFragmentPairs,
-        areMutuallyExclusive,
-        fragmentName1,
-        fragmentName2
-      ) {
-        if (fragmentName1 === fragmentName2) {
-          return;
-        }
-        if (
-          comparedFragmentPairs.has(
-            fragmentName1,
-            fragmentName2,
-            areMutuallyExclusive
-          )
-        ) {
-          return;
-        }
-        comparedFragmentPairs.add(
-          fragmentName1,
-          fragmentName2,
-          areMutuallyExclusive
-        );
-        const fragment1 = context.getFragment(fragmentName1);
-        const fragment2 = context.getFragment(fragmentName2);
-        if (!fragment1 || !fragment2) {
-          return;
-        }
-        const [fieldMap1, referencedFragmentNames1] =
-          getReferencedFieldsAndFragmentNames(
-            context,
-            cachedFieldsAndFragmentNames,
-            fragment1
-          );
-        const [fieldMap2, referencedFragmentNames2] =
-          getReferencedFieldsAndFragmentNames(
-            context,
-            cachedFieldsAndFragmentNames,
-            fragment2
-          );
-        collectConflictsBetween(
-          context,
-          conflicts,
-          cachedFieldsAndFragmentNames,
-          comparedFragmentPairs,
-          areMutuallyExclusive,
-          fieldMap1,
-          fieldMap2
-        );
-        for (const referencedFragmentName2 of referencedFragmentNames2) {
-          collectConflictsBetweenFragments(
-            context,
-            conflicts,
-            cachedFieldsAndFragmentNames,
-            comparedFragmentPairs,
-            areMutuallyExclusive,
-            fragmentName1,
-            referencedFragmentName2
-          );
-        }
-        for (const referencedFragmentName1 of referencedFragmentNames1) {
-          collectConflictsBetweenFragments(
-            context,
-            conflicts,
-            cachedFieldsAndFragmentNames,
-            comparedFragmentPairs,
-            areMutuallyExclusive,
-            referencedFragmentName1,
-            fragmentName2
-          );
-        }
-      }
-      function findConflictsBetweenSubSelectionSets(
-        context,
-        cachedFieldsAndFragmentNames,
-        comparedFragmentPairs,
-        areMutuallyExclusive,
-        parentType1,
-        selectionSet1,
-        parentType2,
-        selectionSet2
-      ) {
-        const conflicts = [];
-        const [fieldMap1, fragmentNames1] = getFieldsAndFragmentNames(
-          context,
-          cachedFieldsAndFragmentNames,
-          parentType1,
-          selectionSet1
-        );
-        const [fieldMap2, fragmentNames2] = getFieldsAndFragmentNames(
-          context,
-          cachedFieldsAndFragmentNames,
-          parentType2,
-          selectionSet2
-        );
-        collectConflictsBetween(
-          context,
-          conflicts,
-          cachedFieldsAndFragmentNames,
-          comparedFragmentPairs,
-          areMutuallyExclusive,
-          fieldMap1,
-          fieldMap2
-        );
-        for (const fragmentName2 of fragmentNames2) {
-          collectConflictsBetweenFieldsAndFragment(
-            context,
-            conflicts,
-            cachedFieldsAndFragmentNames,
-            comparedFragmentPairs,
-            areMutuallyExclusive,
-            fieldMap1,
-            fragmentName2
-          );
-        }
-        for (const fragmentName1 of fragmentNames1) {
-          collectConflictsBetweenFieldsAndFragment(
-            context,
-            conflicts,
-            cachedFieldsAndFragmentNames,
-            comparedFragmentPairs,
-            areMutuallyExclusive,
-            fieldMap2,
-            fragmentName1
-          );
-        }
-        for (const fragmentName1 of fragmentNames1) {
-          for (const fragmentName2 of fragmentNames2) {
-            collectConflictsBetweenFragments(
-              context,
-              conflicts,
-              cachedFieldsAndFragmentNames,
-              comparedFragmentPairs,
-              areMutuallyExclusive,
-              fragmentName1,
-              fragmentName2
-            );
-          }
-        }
-        return conflicts;
-      }
-      function collectConflictsWithin(
-        context,
-        conflicts,
-        cachedFieldsAndFragmentNames,
-        comparedFragmentPairs,
-        fieldMap
-      ) {
-        for (const [responseName, fields] of Object.entries(fieldMap)) {
-          if (fields.length > 1) {
-            for (let i = 0; i < fields.length; i++) {
-              for (let j = i + 1; j < fields.length; j++) {
-                const conflict = findConflict(
-                  context,
-                  cachedFieldsAndFragmentNames,
-                  comparedFragmentPairs,
-                  false,
-                  responseName,
-                  fields[i],
-                  fields[j]
-                );
-                if (conflict) {
-                  conflicts.push(conflict);
-                }
-              }
-            }
-          }
-        }
-      }
-      function collectConflictsBetween(
-        context,
-        conflicts,
-        cachedFieldsAndFragmentNames,
-        comparedFragmentPairs,
-        parentFieldsAreMutuallyExclusive,
-        fieldMap1,
-        fieldMap2
-      ) {
-        for (const [responseName, fields1] of Object.entries(fieldMap1)) {
-          const fields2 = fieldMap2[responseName];
-          if (fields2) {
-            for (const field1 of fields1) {
-              for (const field2 of fields2) {
-                const conflict = findConflict(
-                  context,
-                  cachedFieldsAndFragmentNames,
-                  comparedFragmentPairs,
-                  parentFieldsAreMutuallyExclusive,
-                  responseName,
-                  field1,
-                  field2
-                );
-                if (conflict) {
-                  conflicts.push(conflict);
-                }
-              }
-            }
-          }
-        }
-      }
-      function findConflict(
-        context,
-        cachedFieldsAndFragmentNames,
-        comparedFragmentPairs,
-        parentFieldsAreMutuallyExclusive,
-        responseName,
-        field1,
-        field2
-      ) {
-        const [parentType1, node1, def1] = field1;
-        const [parentType2, node2, def2] = field2;
-        const areMutuallyExclusive =
-          parentFieldsAreMutuallyExclusive ||
-          (parentType1 !== parentType2 &&
-            isObjectType(parentType1) &&
-            isObjectType(parentType2));
-        if (!areMutuallyExclusive) {
-          const name1 = node1.name.value;
-          const name2 = node2.name.value;
-          if (name1 !== name2) {
-            return [
-              [responseName, `"${name1}" and "${name2}" are different fields`],
-              [node1],
-              [node2],
-            ];
-          }
-          if (stringifyArguments(node1) !== stringifyArguments(node2)) {
-            return [
-              [responseName, "they have differing arguments"],
-              [node1],
-              [node2],
-            ];
-          }
-        }
-        const type1 = def1 === null || def1 === void 0 ? void 0 : def1.type;
-        const type2 = def2 === null || def2 === void 0 ? void 0 : def2.type;
-        if (type1 && type2 && doTypesConflict(type1, type2)) {
-          return [
-            [
-              responseName,
-              `they return conflicting types "${inspect$2(
-                type1
-              )}" and "${inspect$2(type2)}"`,
-            ],
-            [node1],
-            [node2],
-          ];
-        }
-        const selectionSet1 = node1.selectionSet;
-        const selectionSet2 = node2.selectionSet;
-        if (selectionSet1 && selectionSet2) {
-          const conflicts = findConflictsBetweenSubSelectionSets(
-            context,
-            cachedFieldsAndFragmentNames,
-            comparedFragmentPairs,
-            areMutuallyExclusive,
-            getNamedType(type1),
-            selectionSet1,
-            getNamedType(type2),
-            selectionSet2
-          );
-          return subfieldConflicts(conflicts, responseName, node1, node2);
-        }
-      }
-      function stringifyArguments(fieldNode) {
-        var _fieldNode$arguments;
-        const args =
-          (_fieldNode$arguments = fieldNode.arguments) !== null &&
-          _fieldNode$arguments !== void 0
-            ? _fieldNode$arguments
-            : [];
-        const inputObjectWithArgs = {
-          kind: Kind.OBJECT,
-          fields: args.map((argNode) => ({
-            kind: Kind.OBJECT_FIELD,
-            name: argNode.name,
-            value: argNode.value,
-          })),
-        };
-        return print(sortValueNode(inputObjectWithArgs));
-      }
-      function doTypesConflict(type1, type2) {
-        if (isListType(type1)) {
-          return isListType(type2)
-            ? doTypesConflict(type1.ofType, type2.ofType)
-            : true;
-        }
-        if (isListType(type2)) {
-          return true;
-        }
-        if (isNonNullType(type1)) {
-          return isNonNullType(type2)
-            ? doTypesConflict(type1.ofType, type2.ofType)
-            : true;
-        }
-        if (isNonNullType(type2)) {
-          return true;
-        }
-        if (isLeafType(type1) || isLeafType(type2)) {
-          return type1 !== type2;
-        }
-        return false;
-      }
-      function getFieldsAndFragmentNames(
-        context,
-        cachedFieldsAndFragmentNames,
-        parentType,
-        selectionSet
-      ) {
-        const cached = cachedFieldsAndFragmentNames.get(selectionSet);
-        if (cached) {
-          return cached;
-        }
-        const nodeAndDefs = /* @__PURE__ */ Object.create(null);
-        const fragmentNames = /* @__PURE__ */ Object.create(null);
-        _collectFieldsAndFragmentNames(
-          context,
-          parentType,
-          selectionSet,
-          nodeAndDefs,
-          fragmentNames
-        );
-        const result2 = [nodeAndDefs, Object.keys(fragmentNames)];
-        cachedFieldsAndFragmentNames.set(selectionSet, result2);
-        return result2;
-      }
-      function getReferencedFieldsAndFragmentNames(
-        context,
-        cachedFieldsAndFragmentNames,
-        fragment
-      ) {
-        const cached = cachedFieldsAndFragmentNames.get(fragment.selectionSet);
-        if (cached) {
-          return cached;
-        }
-        const fragmentType = typeFromAST(
-          context.getSchema(),
-          fragment.typeCondition
-        );
-        return getFieldsAndFragmentNames(
-          context,
-          cachedFieldsAndFragmentNames,
-          fragmentType,
-          fragment.selectionSet
-        );
-      }
-      function _collectFieldsAndFragmentNames(
-        context,
-        parentType,
-        selectionSet,
-        nodeAndDefs,
-        fragmentNames
-      ) {
-        for (const selection of selectionSet.selections) {
-          switch (selection.kind) {
-            case Kind.FIELD: {
-              const fieldName = selection.name.value;
-              let fieldDef;
-              if (isObjectType(parentType) || isInterfaceType(parentType)) {
-                fieldDef = parentType.getFields()[fieldName];
-              }
-              const responseName = selection.alias
-                ? selection.alias.value
-                : fieldName;
-              if (!nodeAndDefs[responseName]) {
-                nodeAndDefs[responseName] = [];
-              }
-              nodeAndDefs[responseName].push([parentType, selection, fieldDef]);
-              break;
-            }
-            case Kind.FRAGMENT_SPREAD:
-              fragmentNames[selection.name.value] = true;
-              break;
-            case Kind.INLINE_FRAGMENT: {
-              const typeCondition = selection.typeCondition;
-              const inlineFragmentType = typeCondition
-                ? typeFromAST(context.getSchema(), typeCondition)
-                : parentType;
-              _collectFieldsAndFragmentNames(
-                context,
-                inlineFragmentType,
-                selection.selectionSet,
-                nodeAndDefs,
-                fragmentNames
-              );
-              break;
-            }
-          }
-        }
-      }
-      function subfieldConflicts(conflicts, responseName, node1, node2) {
-        if (conflicts.length > 0) {
-          return [
-            [responseName, conflicts.map(([reason]) => reason)],
-            [node1, ...conflicts.map(([, fields1]) => fields1).flat()],
-            [node2, ...conflicts.map(([, , fields2]) => fields2).flat()],
-          ];
-        }
-      }
-      class PairSet {
-        constructor() {
-          this._data = /* @__PURE__ */ new Map();
-        }
-        has(a, b, areMutuallyExclusive) {
-          var _this$_data$get;
-          const [key1, key2] = a < b ? [a, b] : [b, a];
-          const result2 =
-            (_this$_data$get = this._data.get(key1)) === null ||
-            _this$_data$get === void 0
-              ? void 0
-              : _this$_data$get.get(key2);
-          if (result2 === void 0) {
-            return false;
-          }
-          return areMutuallyExclusive ? true : areMutuallyExclusive === result2;
-        }
-        add(a, b, areMutuallyExclusive) {
-          const [key1, key2] = a < b ? [a, b] : [b, a];
-          const map2 = this._data.get(key1);
-          if (map2 === void 0) {
-            this._data.set(
-              key1,
-              /* @__PURE__ */ new Map([[key2, areMutuallyExclusive]])
-            );
-          } else {
-            map2.set(key2, areMutuallyExclusive);
-          }
-        }
-      }
-      function PossibleFragmentSpreadsRule(context) {
-        return {
-          InlineFragment(node) {
-            const fragType = context.getType();
-            const parentType = context.getParentType();
-            if (
-              isCompositeType(fragType) &&
-              isCompositeType(parentType) &&
-              !doTypesOverlap(context.getSchema(), fragType, parentType)
-            ) {
-              const parentTypeStr = inspect$2(parentType);
-              const fragTypeStr = inspect$2(fragType);
-              context.reportError(
-                new GraphQLError(
-                  `Fragment cannot be spread here as objects of type "${parentTypeStr}" can never be of type "${fragTypeStr}".`,
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-            }
-          },
-          FragmentSpread(node) {
-            const fragName = node.name.value;
-            const fragType = getFragmentType(context, fragName);
-            const parentType = context.getParentType();
-            if (
-              fragType &&
-              parentType &&
-              !doTypesOverlap(context.getSchema(), fragType, parentType)
-            ) {
-              const parentTypeStr = inspect$2(parentType);
-              const fragTypeStr = inspect$2(fragType);
-              context.reportError(
-                new GraphQLError(
-                  `Fragment "${fragName}" cannot be spread here as objects of type "${parentTypeStr}" can never be of type "${fragTypeStr}".`,
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-            }
-          },
-        };
-      }
-      function getFragmentType(context, name2) {
-        const frag = context.getFragment(name2);
-        if (frag) {
-          const type2 = typeFromAST(context.getSchema(), frag.typeCondition);
-          if (isCompositeType(type2)) {
-            return type2;
-          }
-        }
-      }
-      function PossibleTypeExtensionsRule(context) {
-        const schema = context.getSchema();
-        const definedTypes = /* @__PURE__ */ Object.create(null);
-        for (const def of context.getDocument().definitions) {
-          if (isTypeDefinitionNode(def)) {
-            definedTypes[def.name.value] = def;
-          }
-        }
-        return {
-          ScalarTypeExtension: checkExtension,
-          ObjectTypeExtension: checkExtension,
-          InterfaceTypeExtension: checkExtension,
-          UnionTypeExtension: checkExtension,
-          EnumTypeExtension: checkExtension,
-          InputObjectTypeExtension: checkExtension,
-        };
-        function checkExtension(node) {
-          const typeName = node.name.value;
-          const defNode = definedTypes[typeName];
-          const existingType =
-            schema === null || schema === void 0
-              ? void 0
-              : schema.getType(typeName);
-          let expectedKind;
-          if (defNode) {
-            expectedKind = defKindToExtKind[defNode.kind];
-          } else if (existingType) {
-            expectedKind = typeToExtKind(existingType);
-          }
-          if (expectedKind) {
-            if (expectedKind !== node.kind) {
-              const kindStr = extensionKindToTypeName(node.kind);
-              context.reportError(
-                new GraphQLError(
-                  `Cannot extend non-${kindStr} type "${typeName}".`,
-                  {
-                    nodes: defNode ? [defNode, node] : node,
-                  }
-                )
-              );
-            }
-          } else {
-            const allTypeNames = Object.keys(
-              __spreadValues(
-                __spreadValues({}, definedTypes),
-                schema === null || schema === void 0
-                  ? void 0
-                  : schema.getTypeMap()
-              )
-            );
-            const suggestedTypes = suggestionList$1(typeName, allTypeNames);
-            context.reportError(
-              new GraphQLError(
-                `Cannot extend type "${typeName}" because it is not defined.` +
-                  didYouMean$1(suggestedTypes),
-                {
-                  nodes: node.name,
-                }
-              )
-            );
-          }
-        }
-      }
-      const defKindToExtKind = {
-        [Kind.SCALAR_TYPE_DEFINITION]: Kind.SCALAR_TYPE_EXTENSION,
-        [Kind.OBJECT_TYPE_DEFINITION]: Kind.OBJECT_TYPE_EXTENSION,
-        [Kind.INTERFACE_TYPE_DEFINITION]: Kind.INTERFACE_TYPE_EXTENSION,
-        [Kind.UNION_TYPE_DEFINITION]: Kind.UNION_TYPE_EXTENSION,
-        [Kind.ENUM_TYPE_DEFINITION]: Kind.ENUM_TYPE_EXTENSION,
-        [Kind.INPUT_OBJECT_TYPE_DEFINITION]: Kind.INPUT_OBJECT_TYPE_EXTENSION,
-      };
-      function typeToExtKind(type2) {
-        if (isScalarType(type2)) {
-          return Kind.SCALAR_TYPE_EXTENSION;
-        }
-        if (isObjectType(type2)) {
-          return Kind.OBJECT_TYPE_EXTENSION;
-        }
-        if (isInterfaceType(type2)) {
-          return Kind.INTERFACE_TYPE_EXTENSION;
-        }
-        if (isUnionType(type2)) {
-          return Kind.UNION_TYPE_EXTENSION;
-        }
-        if (isEnumType(type2)) {
-          return Kind.ENUM_TYPE_EXTENSION;
-        }
-        if (isInputObjectType(type2)) {
-          return Kind.INPUT_OBJECT_TYPE_EXTENSION;
-        }
-        invariant$2(false, "Unexpected type: " + inspect$2(type2));
-      }
-      function extensionKindToTypeName(kind2) {
-        switch (kind2) {
-          case Kind.SCALAR_TYPE_EXTENSION:
-            return "scalar";
-          case Kind.OBJECT_TYPE_EXTENSION:
-            return "object";
-          case Kind.INTERFACE_TYPE_EXTENSION:
-            return "interface";
-          case Kind.UNION_TYPE_EXTENSION:
-            return "union";
-          case Kind.ENUM_TYPE_EXTENSION:
-            return "enum";
-          case Kind.INPUT_OBJECT_TYPE_EXTENSION:
-            return "input object";
-          default:
-            invariant$2(false, "Unexpected kind: " + inspect$2(kind2));
-        }
-      }
-      function ProvidedRequiredArgumentsRule(context) {
-        return __spreadProps(
-          __spreadValues(
-            {},
-            ProvidedRequiredArgumentsOnDirectivesRule(context)
-          ),
-          {
-            Field: {
-              leave(fieldNode) {
-                var _fieldNode$arguments;
-                const fieldDef = context.getFieldDef();
-                if (!fieldDef) {
-                  return false;
-                }
-                const providedArgs = new Set(
-                  (_fieldNode$arguments = fieldNode.arguments) === null ||
-                  _fieldNode$arguments === void 0
-                    ? void 0
-                    : _fieldNode$arguments.map((arg) => arg.name.value)
-                );
-                for (const argDef of fieldDef.args) {
-                  if (
-                    !providedArgs.has(argDef.name) &&
-                    isRequiredArgument$1(argDef)
-                  ) {
-                    const argTypeStr = inspect$2(argDef.type);
-                    context.reportError(
-                      new GraphQLError(
-                        `Field "${fieldDef.name}" argument "${argDef.name}" of type "${argTypeStr}" is required, but it was not provided.`,
-                        {
-                          nodes: fieldNode,
-                        }
-                      )
-                    );
-                  }
-                }
-              },
-            },
-          }
-        );
-      }
-      function ProvidedRequiredArgumentsOnDirectivesRule(context) {
-        var _schema$getDirectives;
-        const requiredArgsMap = /* @__PURE__ */ Object.create(null);
-        const schema = context.getSchema();
-        const definedDirectives =
-          (_schema$getDirectives =
-            schema === null || schema === void 0
-              ? void 0
-              : schema.getDirectives()) !== null &&
-          _schema$getDirectives !== void 0
-            ? _schema$getDirectives
-            : specifiedDirectives;
-        for (const directive of definedDirectives) {
-          requiredArgsMap[directive.name] = keyMap$1(
-            directive.args.filter(isRequiredArgument$1),
-            (arg) => arg.name
-          );
-        }
-        const astDefinitions = context.getDocument().definitions;
-        for (const def of astDefinitions) {
-          if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-            var _def$arguments;
-            const argNodes =
-              (_def$arguments = def.arguments) !== null &&
-              _def$arguments !== void 0
-                ? _def$arguments
-                : [];
-            requiredArgsMap[def.name.value] = keyMap$1(
-              argNodes.filter(isRequiredArgumentNode),
-              (arg) => arg.name.value
-            );
-          }
-        }
-        return {
-          Directive: {
-            leave(directiveNode) {
-              const directiveName = directiveNode.name.value;
-              const requiredArgs = requiredArgsMap[directiveName];
-              if (requiredArgs) {
-                var _directiveNode$argume;
-                const argNodes =
-                  (_directiveNode$argume = directiveNode.arguments) !== null &&
-                  _directiveNode$argume !== void 0
-                    ? _directiveNode$argume
-                    : [];
-                const argNodeMap = new Set(
-                  argNodes.map((arg) => arg.name.value)
-                );
-                for (const [argName, argDef] of Object.entries(requiredArgs)) {
-                  if (!argNodeMap.has(argName)) {
-                    const argType = isType(argDef.type)
-                      ? inspect$2(argDef.type)
-                      : print(argDef.type);
-                    context.reportError(
-                      new GraphQLError(
-                        `Directive "@${directiveName}" argument "${argName}" of type "${argType}" is required, but it was not provided.`,
-                        {
-                          nodes: directiveNode,
-                        }
-                      )
-                    );
-                  }
-                }
-              }
-            },
-          },
-        };
-      }
-      function isRequiredArgumentNode(arg) {
-        return arg.type.kind === Kind.NON_NULL_TYPE && arg.defaultValue == null;
-      }
-      function ScalarLeafsRule(context) {
-        return {
-          Field(node) {
-            const type2 = context.getType();
-            const selectionSet = node.selectionSet;
-            if (type2) {
-              if (isLeafType(getNamedType(type2))) {
-                if (selectionSet) {
-                  const fieldName = node.name.value;
-                  const typeStr = inspect$2(type2);
-                  context.reportError(
-                    new GraphQLError(
-                      `Field "${fieldName}" must not have a selection since type "${typeStr}" has no subfields.`,
-                      {
-                        nodes: selectionSet,
-                      }
-                    )
-                  );
-                }
-              } else if (!selectionSet) {
-                const fieldName = node.name.value;
-                const typeStr = inspect$2(type2);
-                context.reportError(
-                  new GraphQLError(
-                    `Field "${fieldName}" of type "${typeStr}" must have a selection of subfields. Did you mean "${fieldName} { ... }"?`,
-                    {
-                      nodes: node,
-                    }
-                  )
-                );
-              }
-            }
-          },
-        };
-      }
-      function printPathArray$1(path) {
-        return path
-          .map((key) =>
-            typeof key === "number" ? "[" + key.toString() + "]" : "." + key
-          )
-          .join("");
-      }
-      function addPath$1(prev, key, typename) {
-        return {
-          prev,
-          key,
-          typename,
-        };
-      }
-      function pathToArray$1(path) {
-        const flattened = [];
-        let curr = path;
-        while (curr) {
-          flattened.push(curr.key);
-          curr = curr.prev;
-        }
-        return flattened.reverse();
-      }
-      function coerceInputValue$1(
-        inputValue,
-        type2,
-        onError = defaultOnError$1
-      ) {
-        return coerceInputValueImpl$1(inputValue, type2, onError, void 0);
-      }
-      function defaultOnError$1(path, invalidValue, error2) {
-        let errorPrefix = "Invalid value " + inspect$2(invalidValue);
-        if (path.length > 0) {
-          errorPrefix += ` at "value${printPathArray$1(path)}"`;
-        }
-        error2.message = errorPrefix + ": " + error2.message;
-        throw error2;
-      }
-      function coerceInputValueImpl$1(inputValue, type2, onError, path) {
-        if (isNonNullType(type2)) {
-          if (inputValue != null) {
-            return coerceInputValueImpl$1(
-              inputValue,
-              type2.ofType,
-              onError,
-              path
-            );
-          }
-          onError(
-            pathToArray$1(path),
-            inputValue,
-            new GraphQLError(
-              `Expected non-nullable type "${inspect$2(type2)}" not to be null.`
-            )
-          );
-          return;
-        }
-        if (inputValue == null) {
-          return null;
-        }
-        if (isListType(type2)) {
-          const itemType = type2.ofType;
-          if (isIterableObject$1(inputValue)) {
-            return Array.from(inputValue, (itemValue, index) => {
-              const itemPath = addPath$1(path, index, void 0);
-              return coerceInputValueImpl$1(
-                itemValue,
-                itemType,
-                onError,
-                itemPath
-              );
-            });
-          }
-          return [coerceInputValueImpl$1(inputValue, itemType, onError, path)];
-        }
-        if (isInputObjectType(type2)) {
-          if (!isObjectLike$1(inputValue)) {
-            onError(
-              pathToArray$1(path),
-              inputValue,
-              new GraphQLError(`Expected type "${type2.name}" to be an object.`)
-            );
-            return;
-          }
-          const coercedValue = {};
-          const fieldDefs = type2.getFields();
-          for (const field of Object.values(fieldDefs)) {
-            const fieldValue = inputValue[field.name];
-            if (fieldValue === void 0) {
-              if (field.defaultValue !== void 0) {
-                coercedValue[field.name] = field.defaultValue;
-              } else if (isNonNullType(field.type)) {
-                const typeStr = inspect$2(field.type);
-                onError(
-                  pathToArray$1(path),
-                  inputValue,
-                  new GraphQLError(
-                    `Field "${field.name}" of required type "${typeStr}" was not provided.`
-                  )
-                );
-              }
-              continue;
-            }
-            coercedValue[field.name] = coerceInputValueImpl$1(
-              fieldValue,
-              field.type,
-              onError,
-              addPath$1(path, field.name, type2.name)
-            );
-          }
-          for (const fieldName of Object.keys(inputValue)) {
-            if (!fieldDefs[fieldName]) {
-              const suggestions = suggestionList$1(
-                fieldName,
-                Object.keys(type2.getFields())
-              );
-              onError(
-                pathToArray$1(path),
-                inputValue,
-                new GraphQLError(
-                  `Field "${fieldName}" is not defined by type "${type2.name}".` +
-                    didYouMean$1(suggestions)
-                )
-              );
-            }
-          }
-          return coercedValue;
-        }
-        if (isLeafType(type2)) {
-          let parseResult;
-          try {
-            parseResult = type2.parseValue(inputValue);
-          } catch (error2) {
-            if (error2 instanceof GraphQLError) {
-              onError(pathToArray$1(path), inputValue, error2);
-            } else {
-              onError(
-                pathToArray$1(path),
-                inputValue,
-                new GraphQLError(
-                  `Expected type "${type2.name}". ` + error2.message,
-                  {
-                    originalError: error2,
-                  }
-                )
-              );
-            }
-            return;
-          }
-          if (parseResult === void 0) {
-            onError(
-              pathToArray$1(path),
-              inputValue,
-              new GraphQLError(`Expected type "${type2.name}".`)
-            );
-          }
-          return parseResult;
-        }
-        invariant$2(false, "Unexpected input type: " + inspect$2(type2));
-      }
-      function valueFromAST$1(valueNode, type2, variables) {
-        if (!valueNode) {
-          return;
-        }
-        if (valueNode.kind === Kind.VARIABLE) {
-          const variableName = valueNode.name.value;
-          if (variables == null || variables[variableName] === void 0) {
-            return;
-          }
-          const variableValue = variables[variableName];
-          if (variableValue === null && isNonNullType(type2)) {
-            return;
-          }
-          return variableValue;
-        }
-        if (isNonNullType(type2)) {
-          if (valueNode.kind === Kind.NULL) {
-            return;
-          }
-          return valueFromAST$1(valueNode, type2.ofType, variables);
-        }
-        if (valueNode.kind === Kind.NULL) {
-          return null;
-        }
-        if (isListType(type2)) {
-          const itemType = type2.ofType;
-          if (valueNode.kind === Kind.LIST) {
-            const coercedValues = [];
-            for (const itemNode of valueNode.values) {
-              if (isMissingVariable$1(itemNode, variables)) {
-                if (isNonNullType(itemType)) {
-                  return;
-                }
-                coercedValues.push(null);
-              } else {
-                const itemValue = valueFromAST$1(itemNode, itemType, variables);
-                if (itemValue === void 0) {
-                  return;
-                }
-                coercedValues.push(itemValue);
-              }
-            }
-            return coercedValues;
-          }
-          const coercedValue = valueFromAST$1(valueNode, itemType, variables);
-          if (coercedValue === void 0) {
-            return;
-          }
-          return [coercedValue];
-        }
-        if (isInputObjectType(type2)) {
-          if (valueNode.kind !== Kind.OBJECT) {
-            return;
-          }
-          const coercedObj = /* @__PURE__ */ Object.create(null);
-          const fieldNodes = keyMap$1(
-            valueNode.fields,
-            (field) => field.name.value
-          );
-          for (const field of Object.values(type2.getFields())) {
-            const fieldNode = fieldNodes[field.name];
-            if (!fieldNode || isMissingVariable$1(fieldNode.value, variables)) {
-              if (field.defaultValue !== void 0) {
-                coercedObj[field.name] = field.defaultValue;
-              } else if (isNonNullType(field.type)) {
-                return;
-              }
-              continue;
-            }
-            const fieldValue = valueFromAST$1(
-              fieldNode.value,
-              field.type,
-              variables
-            );
-            if (fieldValue === void 0) {
-              return;
-            }
-            coercedObj[field.name] = fieldValue;
-          }
-          return coercedObj;
-        }
-        if (isLeafType(type2)) {
-          let result2;
-          try {
-            result2 = type2.parseLiteral(valueNode, variables);
-          } catch (_error) {
-            return;
-          }
-          if (result2 === void 0) {
-            return;
-          }
-          return result2;
-        }
-        invariant$2(false, "Unexpected input type: " + inspect$2(type2));
-      }
-      function isMissingVariable$1(valueNode, variables) {
-        return (
-          valueNode.kind === Kind.VARIABLE &&
-          (variables == null || variables[valueNode.name.value] === void 0)
-        );
-      }
-      function getVariableValues$1(schema, varDefNodes, inputs, options) {
-        const errors2 = [];
-        const maxErrors =
-          options === null || options === void 0 ? void 0 : options.maxErrors;
-        try {
-          const coerced = coerceVariableValues$1(
-            schema,
-            varDefNodes,
-            inputs,
-            (error2) => {
-              if (maxErrors != null && errors2.length >= maxErrors) {
-                throw new GraphQLError(
-                  "Too many errors processing variables, error limit reached. Execution aborted."
-                );
-              }
-              errors2.push(error2);
-            }
-          );
-          if (errors2.length === 0) {
-            return {
-              coerced,
-            };
-          }
-        } catch (error2) {
-          errors2.push(error2);
-        }
-        return {
-          errors: errors2,
-        };
-      }
-      function coerceVariableValues$1(schema, varDefNodes, inputs, onError) {
-        const coercedValues = {};
-        for (const varDefNode of varDefNodes) {
-          const varName = varDefNode.variable.name.value;
-          const varType = typeFromAST(schema, varDefNode.type);
-          if (!isInputType(varType)) {
-            const varTypeStr = print(varDefNode.type);
-            onError(
-              new GraphQLError(
-                `Variable "$${varName}" expected value of type "${varTypeStr}" which cannot be used as an input type.`,
-                {
-                  nodes: varDefNode.type,
-                }
-              )
-            );
-            continue;
-          }
-          if (!hasOwnProperty$2(inputs, varName)) {
-            if (varDefNode.defaultValue) {
-              coercedValues[varName] = valueFromAST$1(
-                varDefNode.defaultValue,
-                varType
-              );
-            } else if (isNonNullType(varType)) {
-              const varTypeStr = inspect$2(varType);
-              onError(
-                new GraphQLError(
-                  `Variable "$${varName}" of required type "${varTypeStr}" was not provided.`,
-                  {
-                    nodes: varDefNode,
-                  }
-                )
-              );
-            }
-            continue;
-          }
-          const value = inputs[varName];
-          if (value === null && isNonNullType(varType)) {
-            const varTypeStr = inspect$2(varType);
-            onError(
-              new GraphQLError(
-                `Variable "$${varName}" of non-null type "${varTypeStr}" must not be null.`,
-                {
-                  nodes: varDefNode,
-                }
-              )
-            );
-            continue;
-          }
-          coercedValues[varName] = coerceInputValue$1(
-            value,
-            varType,
-            (path, invalidValue, error2) => {
-              let prefix =
-                `Variable "$${varName}" got invalid value ` +
-                inspect$2(invalidValue);
-              if (path.length > 0) {
-                prefix += ` at "${varName}${printPathArray$1(path)}"`;
-              }
-              onError(
-                new GraphQLError(prefix + "; " + error2.message, {
-                  nodes: varDefNode,
-                  originalError: error2.originalError,
-                })
-              );
-            }
-          );
-        }
-        return coercedValues;
-      }
-      function getArgumentValues$1(def, node, variableValues) {
-        var _node$arguments;
-        const coercedValues = {};
-        const argumentNodes =
-          (_node$arguments = node.arguments) !== null &&
-          _node$arguments !== void 0
-            ? _node$arguments
-            : [];
-        const argNodeMap = keyMap$1(argumentNodes, (arg) => arg.name.value);
-        for (const argDef of def.args) {
-          const name2 = argDef.name;
-          const argType = argDef.type;
-          const argumentNode = argNodeMap[name2];
-          if (!argumentNode) {
-            if (argDef.defaultValue !== void 0) {
-              coercedValues[name2] = argDef.defaultValue;
-            } else if (isNonNullType(argType)) {
-              throw new GraphQLError(
-                `Argument "${name2}" of required type "${inspect$2(
-                  argType
-                )}" was not provided.`,
-                {
-                  nodes: node,
-                }
-              );
-            }
-            continue;
-          }
-          const valueNode = argumentNode.value;
-          let isNull = valueNode.kind === Kind.NULL;
-          if (valueNode.kind === Kind.VARIABLE) {
-            const variableName = valueNode.name.value;
-            if (
-              variableValues == null ||
-              !hasOwnProperty$2(variableValues, variableName)
-            ) {
-              if (argDef.defaultValue !== void 0) {
-                coercedValues[name2] = argDef.defaultValue;
-              } else if (isNonNullType(argType)) {
-                throw new GraphQLError(
-                  `Argument "${name2}" of required type "${inspect$2(
-                    argType
-                  )}" was provided the variable "$${variableName}" which was not provided a runtime value.`,
-                  {
-                    nodes: valueNode,
-                  }
-                );
-              }
-              continue;
-            }
-            isNull = variableValues[variableName] == null;
-          }
-          if (isNull && isNonNullType(argType)) {
-            throw new GraphQLError(
-              `Argument "${name2}" of non-null type "${inspect$2(
-                argType
-              )}" must not be null.`,
-              {
-                nodes: valueNode,
-              }
-            );
-          }
-          const coercedValue = valueFromAST$1(
-            valueNode,
-            argType,
-            variableValues
-          );
-          if (coercedValue === void 0) {
-            throw new GraphQLError(
-              `Argument "${name2}" has invalid value ${print(valueNode)}.`,
-              {
-                nodes: valueNode,
-              }
-            );
-          }
-          coercedValues[name2] = coercedValue;
-        }
-        return coercedValues;
-      }
-      function getDirectiveValues$1(directiveDef, node, variableValues) {
-        var _node$directives;
-        const directiveNode =
-          (_node$directives = node.directives) === null ||
-          _node$directives === void 0
-            ? void 0
-            : _node$directives.find(
-                (directive) => directive.name.value === directiveDef.name
-              );
-        if (directiveNode) {
-          return getArgumentValues$1(
-            directiveDef,
-            directiveNode,
-            variableValues
-          );
-        }
-      }
-      function hasOwnProperty$2(obj, prop2) {
-        return Object.prototype.hasOwnProperty.call(obj, prop2);
-      }
-      function collectFields$1(
-        schema,
-        fragments,
-        variableValues,
-        runtimeType,
-        selectionSet
-      ) {
-        const fields = /* @__PURE__ */ new Map();
-        collectFieldsImpl(
-          schema,
-          fragments,
-          variableValues,
-          runtimeType,
-          selectionSet,
-          fields,
-          /* @__PURE__ */ new Set()
-        );
-        return fields;
-      }
-      function collectSubfields$1(
-        schema,
-        fragments,
-        variableValues,
-        returnType,
-        fieldNodes
-      ) {
-        const subFieldNodes = /* @__PURE__ */ new Map();
-        const visitedFragmentNames = /* @__PURE__ */ new Set();
-        for (const node of fieldNodes) {
-          if (node.selectionSet) {
-            collectFieldsImpl(
-              schema,
-              fragments,
-              variableValues,
-              returnType,
-              node.selectionSet,
-              subFieldNodes,
-              visitedFragmentNames
-            );
-          }
-        }
-        return subFieldNodes;
-      }
-      function collectFieldsImpl(
-        schema,
-        fragments,
-        variableValues,
-        runtimeType,
-        selectionSet,
-        fields,
-        visitedFragmentNames
-      ) {
-        for (const selection of selectionSet.selections) {
-          switch (selection.kind) {
-            case Kind.FIELD: {
-              if (!shouldIncludeNode$1(variableValues, selection)) {
-                continue;
-              }
-              const name2 = getFieldEntryKey$1(selection);
-              const fieldList = fields.get(name2);
-              if (fieldList !== void 0) {
-                fieldList.push(selection);
-              } else {
-                fields.set(name2, [selection]);
-              }
-              break;
-            }
-            case Kind.INLINE_FRAGMENT: {
-              if (
-                !shouldIncludeNode$1(variableValues, selection) ||
-                !doesFragmentConditionMatch$1(schema, selection, runtimeType)
-              ) {
-                continue;
-              }
-              collectFieldsImpl(
-                schema,
-                fragments,
-                variableValues,
-                runtimeType,
-                selection.selectionSet,
-                fields,
-                visitedFragmentNames
-              );
-              break;
-            }
-            case Kind.FRAGMENT_SPREAD: {
-              const fragName = selection.name.value;
-              if (
-                visitedFragmentNames.has(fragName) ||
-                !shouldIncludeNode$1(variableValues, selection)
-              ) {
-                continue;
-              }
-              visitedFragmentNames.add(fragName);
-              const fragment = fragments[fragName];
-              if (
-                !fragment ||
-                !doesFragmentConditionMatch$1(schema, fragment, runtimeType)
-              ) {
-                continue;
-              }
-              collectFieldsImpl(
-                schema,
-                fragments,
-                variableValues,
-                runtimeType,
-                fragment.selectionSet,
-                fields,
-                visitedFragmentNames
-              );
-              break;
-            }
-          }
-        }
-      }
-      function shouldIncludeNode$1(variableValues, node) {
-        const skip2 = getDirectiveValues$1(
-          GraphQLSkipDirective,
-          node,
-          variableValues
-        );
-        if ((skip2 === null || skip2 === void 0 ? void 0 : skip2.if) === true) {
-          return false;
-        }
-        const include = getDirectiveValues$1(
-          GraphQLIncludeDirective,
-          node,
-          variableValues
-        );
-        if (
-          (include === null || include === void 0 ? void 0 : include.if) ===
-          false
-        ) {
-          return false;
-        }
-        return true;
-      }
-      function doesFragmentConditionMatch$1(schema, fragment, type2) {
-        const typeConditionNode = fragment.typeCondition;
-        if (!typeConditionNode) {
-          return true;
-        }
-        const conditionalType = typeFromAST(schema, typeConditionNode);
-        if (conditionalType === type2) {
-          return true;
-        }
-        if (isAbstractType(conditionalType)) {
-          return schema.isSubType(conditionalType, type2);
-        }
-        return false;
-      }
-      function getFieldEntryKey$1(node) {
-        return node.alias ? node.alias.value : node.name.value;
-      }
-      function SingleFieldSubscriptionsRule(context) {
-        return {
-          OperationDefinition(node) {
-            if (node.operation === "subscription") {
-              const schema = context.getSchema();
-              const subscriptionType = schema.getSubscriptionType();
-              if (subscriptionType) {
-                const operationName = node.name ? node.name.value : null;
-                const variableValues = /* @__PURE__ */ Object.create(null);
-                const document2 = context.getDocument();
-                const fragments = /* @__PURE__ */ Object.create(null);
-                for (const definition of document2.definitions) {
-                  if (definition.kind === Kind.FRAGMENT_DEFINITION) {
-                    fragments[definition.name.value] = definition;
-                  }
-                }
-                const fields = collectFields$1(
-                  schema,
-                  fragments,
-                  variableValues,
-                  subscriptionType,
-                  node.selectionSet
-                );
-                if (fields.size > 1) {
-                  const fieldSelectionLists = [...fields.values()];
-                  const extraFieldSelectionLists = fieldSelectionLists.slice(1);
-                  const extraFieldSelections = extraFieldSelectionLists.flat();
-                  context.reportError(
-                    new GraphQLError(
-                      operationName != null
-                        ? `Subscription "${operationName}" must select only one top level field.`
-                        : "Anonymous Subscription must select only one top level field.",
-                      {
-                        nodes: extraFieldSelections,
-                      }
-                    )
-                  );
-                }
-                for (const fieldNodes of fields.values()) {
-                  const field = fieldNodes[0];
-                  const fieldName = field.name.value;
-                  if (fieldName.startsWith("__")) {
-                    context.reportError(
-                      new GraphQLError(
-                        operationName != null
-                          ? `Subscription "${operationName}" must not select an introspection top level field.`
-                          : "Anonymous Subscription must not select an introspection top level field.",
-                        {
-                          nodes: fieldNodes,
-                        }
-                      )
-                    );
-                  }
-                }
-              }
-            }
-          },
-        };
-      }
-      function groupBy(list3, keyFn) {
-        const result2 = /* @__PURE__ */ new Map();
-        for (const item of list3) {
-          const key = keyFn(item);
-          const group = result2.get(key);
-          if (group === void 0) {
-            result2.set(key, [item]);
-          } else {
-            group.push(item);
-          }
-        }
-        return result2;
-      }
-      function UniqueArgumentDefinitionNamesRule(context) {
-        return {
-          DirectiveDefinition(directiveNode) {
-            var _directiveNode$argume;
-            const argumentNodes =
-              (_directiveNode$argume = directiveNode.arguments) !== null &&
-              _directiveNode$argume !== void 0
-                ? _directiveNode$argume
-                : [];
-            return checkArgUniqueness(
-              `@${directiveNode.name.value}`,
-              argumentNodes
-            );
-          },
-          InterfaceTypeDefinition: checkArgUniquenessPerField,
-          InterfaceTypeExtension: checkArgUniquenessPerField,
-          ObjectTypeDefinition: checkArgUniquenessPerField,
-          ObjectTypeExtension: checkArgUniquenessPerField,
-        };
-        function checkArgUniquenessPerField(typeNode) {
-          var _typeNode$fields;
-          const typeName = typeNode.name.value;
-          const fieldNodes =
-            (_typeNode$fields = typeNode.fields) !== null &&
-            _typeNode$fields !== void 0
-              ? _typeNode$fields
-              : [];
-          for (const fieldDef of fieldNodes) {
-            var _fieldDef$arguments;
-            const fieldName = fieldDef.name.value;
-            const argumentNodes =
-              (_fieldDef$arguments = fieldDef.arguments) !== null &&
-              _fieldDef$arguments !== void 0
-                ? _fieldDef$arguments
-                : [];
-            checkArgUniqueness(`${typeName}.${fieldName}`, argumentNodes);
-          }
-          return false;
-        }
-        function checkArgUniqueness(parentName, argumentNodes) {
-          const seenArgs = groupBy(argumentNodes, (arg) => arg.name.value);
-          for (const [argName, argNodes] of seenArgs) {
-            if (argNodes.length > 1) {
-              context.reportError(
-                new GraphQLError(
-                  `Argument "${parentName}(${argName}:)" can only be defined once.`,
-                  {
-                    nodes: argNodes.map((node) => node.name),
-                  }
-                )
-              );
-            }
-          }
-          return false;
-        }
-      }
-      function UniqueArgumentNamesRule(context) {
-        return {
-          Field: checkArgUniqueness,
-          Directive: checkArgUniqueness,
-        };
-        function checkArgUniqueness(parentNode) {
-          var _parentNode$arguments;
-          const argumentNodes =
-            (_parentNode$arguments = parentNode.arguments) !== null &&
-            _parentNode$arguments !== void 0
-              ? _parentNode$arguments
-              : [];
-          const seenArgs = groupBy(argumentNodes, (arg) => arg.name.value);
-          for (const [argName, argNodes] of seenArgs) {
-            if (argNodes.length > 1) {
-              context.reportError(
-                new GraphQLError(
-                  `There can be only one argument named "${argName}".`,
-                  {
-                    nodes: argNodes.map((node) => node.name),
-                  }
-                )
-              );
-            }
-          }
-        }
-      }
-      function UniqueDirectiveNamesRule(context) {
-        const knownDirectiveNames = /* @__PURE__ */ Object.create(null);
-        const schema = context.getSchema();
-        return {
-          DirectiveDefinition(node) {
-            const directiveName = node.name.value;
-            if (
-              schema !== null &&
-              schema !== void 0 &&
-              schema.getDirective(directiveName)
-            ) {
-              context.reportError(
-                new GraphQLError(
-                  `Directive "@${directiveName}" already exists in the schema. It cannot be redefined.`,
-                  {
-                    nodes: node.name,
-                  }
-                )
-              );
-              return;
-            }
-            if (knownDirectiveNames[directiveName]) {
-              context.reportError(
-                new GraphQLError(
-                  `There can be only one directive named "@${directiveName}".`,
-                  {
-                    nodes: [knownDirectiveNames[directiveName], node.name],
-                  }
-                )
-              );
-            } else {
-              knownDirectiveNames[directiveName] = node.name;
-            }
-            return false;
-          },
-        };
-      }
-      function UniqueDirectivesPerLocationRule(context) {
-        const uniqueDirectiveMap = /* @__PURE__ */ Object.create(null);
-        const schema = context.getSchema();
-        const definedDirectives = schema
-          ? schema.getDirectives()
-          : specifiedDirectives;
-        for (const directive of definedDirectives) {
-          uniqueDirectiveMap[directive.name] = !directive.isRepeatable;
-        }
-        const astDefinitions = context.getDocument().definitions;
-        for (const def of astDefinitions) {
-          if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-            uniqueDirectiveMap[def.name.value] = !def.repeatable;
-          }
-        }
-        const schemaDirectives = /* @__PURE__ */ Object.create(null);
-        const typeDirectivesMap = /* @__PURE__ */ Object.create(null);
-        return {
-          enter(node) {
-            if (!("directives" in node) || !node.directives) {
-              return;
-            }
-            let seenDirectives;
-            if (
-              node.kind === Kind.SCHEMA_DEFINITION ||
-              node.kind === Kind.SCHEMA_EXTENSION
-            ) {
-              seenDirectives = schemaDirectives;
-            } else if (
-              isTypeDefinitionNode(node) ||
-              isTypeExtensionNode(node)
-            ) {
-              const typeName = node.name.value;
-              seenDirectives = typeDirectivesMap[typeName];
-              if (seenDirectives === void 0) {
-                typeDirectivesMap[typeName] = seenDirectives =
-                  /* @__PURE__ */ Object.create(null);
-              }
-            } else {
-              seenDirectives = /* @__PURE__ */ Object.create(null);
-            }
-            for (const directive of node.directives) {
-              const directiveName = directive.name.value;
-              if (uniqueDirectiveMap[directiveName]) {
-                if (seenDirectives[directiveName]) {
-                  context.reportError(
-                    new GraphQLError(
-                      `The directive "@${directiveName}" can only be used once at this location.`,
-                      {
-                        nodes: [seenDirectives[directiveName], directive],
-                      }
-                    )
-                  );
-                } else {
-                  seenDirectives[directiveName] = directive;
-                }
-              }
-            }
-          },
-        };
-      }
-      function UniqueEnumValueNamesRule(context) {
-        const schema = context.getSchema();
-        const existingTypeMap = schema
-          ? schema.getTypeMap()
-          : /* @__PURE__ */ Object.create(null);
-        const knownValueNames = /* @__PURE__ */ Object.create(null);
-        return {
-          EnumTypeDefinition: checkValueUniqueness,
-          EnumTypeExtension: checkValueUniqueness,
-        };
-        function checkValueUniqueness(node) {
-          var _node$values;
-          const typeName = node.name.value;
-          if (!knownValueNames[typeName]) {
-            knownValueNames[typeName] = /* @__PURE__ */ Object.create(null);
-          }
-          const valueNodes =
-            (_node$values = node.values) !== null && _node$values !== void 0
-              ? _node$values
-              : [];
-          const valueNames = knownValueNames[typeName];
-          for (const valueDef of valueNodes) {
-            const valueName = valueDef.name.value;
-            const existingType = existingTypeMap[typeName];
-            if (isEnumType(existingType) && existingType.getValue(valueName)) {
-              context.reportError(
-                new GraphQLError(
-                  `Enum value "${typeName}.${valueName}" already exists in the schema. It cannot also be defined in this type extension.`,
-                  {
-                    nodes: valueDef.name,
-                  }
-                )
-              );
-            } else if (valueNames[valueName]) {
-              context.reportError(
-                new GraphQLError(
-                  `Enum value "${typeName}.${valueName}" can only be defined once.`,
-                  {
-                    nodes: [valueNames[valueName], valueDef.name],
-                  }
-                )
-              );
-            } else {
-              valueNames[valueName] = valueDef.name;
-            }
-          }
-          return false;
-        }
-      }
-      function UniqueFieldDefinitionNamesRule(context) {
-        const schema = context.getSchema();
-        const existingTypeMap = schema
-          ? schema.getTypeMap()
-          : /* @__PURE__ */ Object.create(null);
-        const knownFieldNames = /* @__PURE__ */ Object.create(null);
-        return {
-          InputObjectTypeDefinition: checkFieldUniqueness,
-          InputObjectTypeExtension: checkFieldUniqueness,
-          InterfaceTypeDefinition: checkFieldUniqueness,
-          InterfaceTypeExtension: checkFieldUniqueness,
-          ObjectTypeDefinition: checkFieldUniqueness,
-          ObjectTypeExtension: checkFieldUniqueness,
-        };
-        function checkFieldUniqueness(node) {
-          var _node$fields;
-          const typeName = node.name.value;
-          if (!knownFieldNames[typeName]) {
-            knownFieldNames[typeName] = /* @__PURE__ */ Object.create(null);
-          }
-          const fieldNodes =
-            (_node$fields = node.fields) !== null && _node$fields !== void 0
-              ? _node$fields
-              : [];
-          const fieldNames = knownFieldNames[typeName];
-          for (const fieldDef of fieldNodes) {
-            const fieldName = fieldDef.name.value;
-            if (hasField(existingTypeMap[typeName], fieldName)) {
-              context.reportError(
-                new GraphQLError(
-                  `Field "${typeName}.${fieldName}" already exists in the schema. It cannot also be defined in this type extension.`,
-                  {
-                    nodes: fieldDef.name,
-                  }
-                )
-              );
-            } else if (fieldNames[fieldName]) {
-              context.reportError(
-                new GraphQLError(
-                  `Field "${typeName}.${fieldName}" can only be defined once.`,
-                  {
-                    nodes: [fieldNames[fieldName], fieldDef.name],
-                  }
-                )
-              );
-            } else {
-              fieldNames[fieldName] = fieldDef.name;
-            }
-          }
-          return false;
-        }
-      }
-      function hasField(type2, fieldName) {
-        if (
-          isObjectType(type2) ||
-          isInterfaceType(type2) ||
-          isInputObjectType(type2)
-        ) {
-          return type2.getFields()[fieldName] != null;
-        }
-        return false;
-      }
-      function UniqueFragmentNamesRule(context) {
-        const knownFragmentNames = /* @__PURE__ */ Object.create(null);
-        return {
-          OperationDefinition: () => false,
-          FragmentDefinition(node) {
-            const fragmentName = node.name.value;
-            if (knownFragmentNames[fragmentName]) {
-              context.reportError(
-                new GraphQLError(
-                  `There can be only one fragment named "${fragmentName}".`,
-                  {
-                    nodes: [knownFragmentNames[fragmentName], node.name],
-                  }
-                )
-              );
-            } else {
-              knownFragmentNames[fragmentName] = node.name;
-            }
-            return false;
-          },
-        };
-      }
-      function UniqueInputFieldNamesRule(context) {
-        const knownNameStack = [];
-        let knownNames = /* @__PURE__ */ Object.create(null);
-        return {
-          ObjectValue: {
-            enter() {
-              knownNameStack.push(knownNames);
-              knownNames = /* @__PURE__ */ Object.create(null);
-            },
-            leave() {
-              const prevKnownNames = knownNameStack.pop();
-              prevKnownNames || invariant$2(false);
-              knownNames = prevKnownNames;
-            },
-          },
-          ObjectField(node) {
-            const fieldName = node.name.value;
-            if (knownNames[fieldName]) {
-              context.reportError(
-                new GraphQLError(
-                  `There can be only one input field named "${fieldName}".`,
-                  {
-                    nodes: [knownNames[fieldName], node.name],
-                  }
-                )
-              );
-            } else {
-              knownNames[fieldName] = node.name;
-            }
-          },
-        };
-      }
-      function UniqueOperationNamesRule(context) {
-        const knownOperationNames = /* @__PURE__ */ Object.create(null);
-        return {
-          OperationDefinition(node) {
-            const operationName = node.name;
-            if (operationName) {
-              if (knownOperationNames[operationName.value]) {
-                context.reportError(
-                  new GraphQLError(
-                    `There can be only one operation named "${operationName.value}".`,
-                    {
-                      nodes: [
-                        knownOperationNames[operationName.value],
-                        operationName,
-                      ],
-                    }
-                  )
-                );
-              } else {
-                knownOperationNames[operationName.value] = operationName;
-              }
-            }
-            return false;
-          },
-          FragmentDefinition: () => false,
-        };
-      }
-      function UniqueOperationTypesRule(context) {
-        const schema = context.getSchema();
-        const definedOperationTypes = /* @__PURE__ */ Object.create(null);
-        const existingOperationTypes = schema
-          ? {
-              query: schema.getQueryType(),
-              mutation: schema.getMutationType(),
-              subscription: schema.getSubscriptionType(),
-            }
-          : {};
-        return {
-          SchemaDefinition: checkOperationTypes,
-          SchemaExtension: checkOperationTypes,
-        };
-        function checkOperationTypes(node) {
-          var _node$operationTypes;
-          const operationTypesNodes =
-            (_node$operationTypes = node.operationTypes) !== null &&
-            _node$operationTypes !== void 0
-              ? _node$operationTypes
-              : [];
-          for (const operationType of operationTypesNodes) {
-            const operation = operationType.operation;
-            const alreadyDefinedOperationType =
-              definedOperationTypes[operation];
-            if (existingOperationTypes[operation]) {
-              context.reportError(
-                new GraphQLError(
-                  `Type for ${operation} already defined in the schema. It cannot be redefined.`,
-                  {
-                    nodes: operationType,
-                  }
-                )
-              );
-            } else if (alreadyDefinedOperationType) {
-              context.reportError(
-                new GraphQLError(
-                  `There can be only one ${operation} type in schema.`,
-                  {
-                    nodes: [alreadyDefinedOperationType, operationType],
-                  }
-                )
-              );
-            } else {
-              definedOperationTypes[operation] = operationType;
-            }
-          }
-          return false;
-        }
-      }
-      function UniqueTypeNamesRule(context) {
-        const knownTypeNames = /* @__PURE__ */ Object.create(null);
-        const schema = context.getSchema();
-        return {
-          ScalarTypeDefinition: checkTypeName,
-          ObjectTypeDefinition: checkTypeName,
-          InterfaceTypeDefinition: checkTypeName,
-          UnionTypeDefinition: checkTypeName,
-          EnumTypeDefinition: checkTypeName,
-          InputObjectTypeDefinition: checkTypeName,
-        };
-        function checkTypeName(node) {
-          const typeName = node.name.value;
-          if (
-            schema !== null &&
-            schema !== void 0 &&
-            schema.getType(typeName)
-          ) {
-            context.reportError(
-              new GraphQLError(
-                `Type "${typeName}" already exists in the schema. It cannot also be defined in this type definition.`,
-                {
-                  nodes: node.name,
-                }
-              )
-            );
-            return;
-          }
-          if (knownTypeNames[typeName]) {
-            context.reportError(
-              new GraphQLError(
-                `There can be only one type named "${typeName}".`,
-                {
-                  nodes: [knownTypeNames[typeName], node.name],
-                }
-              )
-            );
-          } else {
-            knownTypeNames[typeName] = node.name;
-          }
-          return false;
-        }
-      }
-      function UniqueVariableNamesRule(context) {
-        return {
-          OperationDefinition(operationNode) {
-            var _operationNode$variab;
-            const variableDefinitions =
-              (_operationNode$variab = operationNode.variableDefinitions) !==
-                null && _operationNode$variab !== void 0
-                ? _operationNode$variab
-                : [];
-            const seenVariableDefinitions = groupBy(
-              variableDefinitions,
-              (node) => node.variable.name.value
-            );
-            for (const [
-              variableName,
-              variableNodes,
-            ] of seenVariableDefinitions) {
-              if (variableNodes.length > 1) {
-                context.reportError(
-                  new GraphQLError(
-                    `There can be only one variable named "$${variableName}".`,
-                    {
-                      nodes: variableNodes.map((node) => node.variable.name),
-                    }
-                  )
-                );
-              }
-            }
-          },
-        };
-      }
-      function ValuesOfCorrectTypeRule(context) {
-        return {
-          ListValue(node) {
-            const type2 = getNullableType(context.getParentInputType());
-            if (!isListType(type2)) {
-              isValidValueNode(context, node);
-              return false;
-            }
-          },
-          ObjectValue(node) {
-            const type2 = getNamedType(context.getInputType());
-            if (!isInputObjectType(type2)) {
-              isValidValueNode(context, node);
-              return false;
-            }
-            const fieldNodeMap = keyMap$1(
-              node.fields,
-              (field) => field.name.value
-            );
-            for (const fieldDef of Object.values(type2.getFields())) {
-              const fieldNode = fieldNodeMap[fieldDef.name];
-              if (!fieldNode && isRequiredInputField(fieldDef)) {
-                const typeStr = inspect$2(fieldDef.type);
-                context.reportError(
-                  new GraphQLError(
-                    `Field "${type2.name}.${fieldDef.name}" of required type "${typeStr}" was not provided.`,
-                    {
-                      nodes: node,
-                    }
-                  )
-                );
-              }
-            }
-          },
-          ObjectField(node) {
-            const parentType = getNamedType(context.getParentInputType());
-            const fieldType = context.getInputType();
-            if (!fieldType && isInputObjectType(parentType)) {
-              const suggestions = suggestionList$1(
-                node.name.value,
-                Object.keys(parentType.getFields())
-              );
-              context.reportError(
-                new GraphQLError(
-                  `Field "${node.name.value}" is not defined by type "${parentType.name}".` +
-                    didYouMean$1(suggestions),
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-            }
-          },
-          NullValue(node) {
-            const type2 = context.getInputType();
-            if (isNonNullType(type2)) {
-              context.reportError(
-                new GraphQLError(
-                  `Expected value of type "${inspect$2(type2)}", found ${print(
-                    node
-                  )}.`,
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-            }
-          },
-          EnumValue: (node) => isValidValueNode(context, node),
-          IntValue: (node) => isValidValueNode(context, node),
-          FloatValue: (node) => isValidValueNode(context, node),
-          StringValue: (node) => isValidValueNode(context, node),
-          BooleanValue: (node) => isValidValueNode(context, node),
-        };
-      }
-      function isValidValueNode(context, node) {
-        const locationType = context.getInputType();
-        if (!locationType) {
-          return;
-        }
-        const type2 = getNamedType(locationType);
-        if (!isLeafType(type2)) {
-          const typeStr = inspect$2(locationType);
-          context.reportError(
-            new GraphQLError(
-              `Expected value of type "${typeStr}", found ${print(node)}.`,
-              {
-                nodes: node,
-              }
-            )
-          );
-          return;
-        }
-        try {
-          const parseResult = type2.parseLiteral(node, void 0);
-          if (parseResult === void 0) {
-            const typeStr = inspect$2(locationType);
-            context.reportError(
-              new GraphQLError(
-                `Expected value of type "${typeStr}", found ${print(node)}.`,
-                {
-                  nodes: node,
-                }
-              )
-            );
-          }
-        } catch (error2) {
-          const typeStr = inspect$2(locationType);
-          if (error2 instanceof GraphQLError) {
-            context.reportError(error2);
-          } else {
-            context.reportError(
-              new GraphQLError(
-                `Expected value of type "${typeStr}", found ${print(node)}; ` +
-                  error2.message,
-                {
-                  nodes: node,
-                  originalError: error2,
-                }
-              )
-            );
-          }
-        }
-      }
-      function VariablesAreInputTypesRule(context) {
-        return {
-          VariableDefinition(node) {
-            const type2 = typeFromAST(context.getSchema(), node.type);
-            if (type2 !== void 0 && !isInputType(type2)) {
-              const variableName = node.variable.name.value;
-              const typeName = print(node.type);
-              context.reportError(
-                new GraphQLError(
-                  `Variable "$${variableName}" cannot be non-input type "${typeName}".`,
-                  {
-                    nodes: node.type,
-                  }
-                )
-              );
-            }
-          },
-        };
-      }
-      function VariablesInAllowedPositionRule(context) {
-        let varDefMap = /* @__PURE__ */ Object.create(null);
-        return {
-          OperationDefinition: {
-            enter() {
-              varDefMap = /* @__PURE__ */ Object.create(null);
-            },
-            leave(operation) {
-              const usages = context.getRecursiveVariableUsages(operation);
-              for (const {
-                node,
-                type: type2,
-                defaultValue: defaultValue2,
-              } of usages) {
-                const varName = node.name.value;
-                const varDef = varDefMap[varName];
-                if (varDef && type2) {
-                  const schema = context.getSchema();
-                  const varType = typeFromAST(schema, varDef.type);
-                  if (
-                    varType &&
-                    !allowedVariableUsage(
-                      schema,
-                      varType,
-                      varDef.defaultValue,
-                      type2,
-                      defaultValue2
-                    )
-                  ) {
-                    const varTypeStr = inspect$2(varType);
-                    const typeStr = inspect$2(type2);
-                    context.reportError(
-                      new GraphQLError(
-                        `Variable "$${varName}" of type "${varTypeStr}" used in position expecting type "${typeStr}".`,
-                        {
-                          nodes: [varDef, node],
-                        }
-                      )
-                    );
-                  }
-                }
-              }
-            },
-          },
-          VariableDefinition(node) {
-            varDefMap[node.variable.name.value] = node;
-          },
-        };
-      }
-      function allowedVariableUsage(
-        schema,
-        varType,
-        varDefaultValue,
-        locationType,
-        locationDefaultValue
-      ) {
-        if (isNonNullType(locationType) && !isNonNullType(varType)) {
-          const hasNonNullVariableDefaultValue =
-            varDefaultValue != null && varDefaultValue.kind !== Kind.NULL;
-          const hasLocationDefaultValue = locationDefaultValue !== void 0;
-          if (!hasNonNullVariableDefaultValue && !hasLocationDefaultValue) {
-            return false;
-          }
-          const nullableLocationType = locationType.ofType;
-          return isTypeSubTypeOf(schema, varType, nullableLocationType);
-        }
-        return isTypeSubTypeOf(schema, varType, locationType);
-      }
-      const specifiedRules = Object.freeze([
-        ExecutableDefinitionsRule,
-        UniqueOperationNamesRule,
-        LoneAnonymousOperationRule,
-        SingleFieldSubscriptionsRule,
-        KnownTypeNamesRule,
-        FragmentsOnCompositeTypesRule,
-        VariablesAreInputTypesRule,
-        ScalarLeafsRule,
-        FieldsOnCorrectTypeRule,
-        UniqueFragmentNamesRule,
-        KnownFragmentNamesRule,
-        NoUnusedFragmentsRule,
-        PossibleFragmentSpreadsRule,
-        NoFragmentCyclesRule,
-        UniqueVariableNamesRule,
-        NoUndefinedVariablesRule,
-        NoUnusedVariablesRule,
-        KnownDirectivesRule,
-        UniqueDirectivesPerLocationRule,
-        KnownArgumentNamesRule,
-        UniqueArgumentNamesRule,
-        ValuesOfCorrectTypeRule,
-        ProvidedRequiredArgumentsRule,
-        VariablesInAllowedPositionRule,
-        OverlappingFieldsCanBeMergedRule,
-        UniqueInputFieldNamesRule,
-      ]);
-      const specifiedSDLRules$1 = Object.freeze([
-        LoneSchemaDefinitionRule,
-        UniqueOperationTypesRule,
-        UniqueTypeNamesRule,
-        UniqueEnumValueNamesRule,
-        UniqueFieldDefinitionNamesRule,
-        UniqueArgumentDefinitionNamesRule,
-        UniqueDirectiveNamesRule,
-        KnownTypeNamesRule,
-        KnownDirectivesRule,
-        UniqueDirectivesPerLocationRule,
-        PossibleTypeExtensionsRule,
-        KnownArgumentNamesOnDirectivesRule,
-        UniqueArgumentNamesRule,
-        UniqueInputFieldNamesRule,
-        ProvidedRequiredArgumentsOnDirectivesRule,
-      ]);
-      class ASTValidationContext {
-        constructor(ast2, onError) {
-          this._ast = ast2;
-          this._fragments = void 0;
-          this._fragmentSpreads = /* @__PURE__ */ new Map();
-          this._recursivelyReferencedFragments = /* @__PURE__ */ new Map();
-          this._onError = onError;
-        }
-        get [Symbol.toStringTag]() {
-          return "ASTValidationContext";
-        }
-        reportError(error2) {
-          this._onError(error2);
-        }
-        getDocument() {
-          return this._ast;
-        }
-        getFragment(name2) {
-          let fragments;
-          if (this._fragments) {
-            fragments = this._fragments;
-          } else {
-            fragments = /* @__PURE__ */ Object.create(null);
-            for (const defNode of this.getDocument().definitions) {
-              if (defNode.kind === Kind.FRAGMENT_DEFINITION) {
-                fragments[defNode.name.value] = defNode;
-              }
-            }
-            this._fragments = fragments;
-          }
-          return fragments[name2];
-        }
-        getFragmentSpreads(node) {
-          let spreads = this._fragmentSpreads.get(node);
-          if (!spreads) {
-            spreads = [];
-            const setsToVisit = [node];
-            let set2;
-            while ((set2 = setsToVisit.pop())) {
-              for (const selection of set2.selections) {
-                if (selection.kind === Kind.FRAGMENT_SPREAD) {
-                  spreads.push(selection);
-                } else if (selection.selectionSet) {
-                  setsToVisit.push(selection.selectionSet);
-                }
-              }
-            }
-            this._fragmentSpreads.set(node, spreads);
-          }
-          return spreads;
-        }
-        getRecursivelyReferencedFragments(operation) {
-          let fragments = this._recursivelyReferencedFragments.get(operation);
-          if (!fragments) {
-            fragments = [];
-            const collectedNames = /* @__PURE__ */ Object.create(null);
-            const nodesToVisit = [operation.selectionSet];
-            let node;
-            while ((node = nodesToVisit.pop())) {
-              for (const spread of this.getFragmentSpreads(node)) {
-                const fragName = spread.name.value;
-                if (collectedNames[fragName] !== true) {
-                  collectedNames[fragName] = true;
-                  const fragment = this.getFragment(fragName);
-                  if (fragment) {
-                    fragments.push(fragment);
-                    nodesToVisit.push(fragment.selectionSet);
-                  }
-                }
-              }
-            }
-            this._recursivelyReferencedFragments.set(operation, fragments);
-          }
-          return fragments;
-        }
-      }
-      class SDLValidationContext extends ASTValidationContext {
-        constructor(ast2, schema, onError) {
-          super(ast2, onError);
-          this._schema = schema;
-        }
-        get [Symbol.toStringTag]() {
-          return "SDLValidationContext";
-        }
-        getSchema() {
-          return this._schema;
-        }
-      }
-      class ValidationContext extends ASTValidationContext {
-        constructor(schema, ast2, typeInfo, onError) {
-          super(ast2, onError);
-          this._schema = schema;
-          this._typeInfo = typeInfo;
-          this._variableUsages = /* @__PURE__ */ new Map();
-          this._recursiveVariableUsages = /* @__PURE__ */ new Map();
-        }
-        get [Symbol.toStringTag]() {
-          return "ValidationContext";
-        }
-        getSchema() {
-          return this._schema;
-        }
-        getVariableUsages(node) {
-          let usages = this._variableUsages.get(node);
-          if (!usages) {
-            const newUsages = [];
-            const typeInfo = new TypeInfo(this._schema);
-            visit(
-              node,
-              visitWithTypeInfo(typeInfo, {
-                VariableDefinition: () => false,
-                Variable(variable) {
-                  newUsages.push({
-                    node: variable,
-                    type: typeInfo.getInputType(),
-                    defaultValue: typeInfo.getDefaultValue(),
-                  });
-                },
-              })
-            );
-            usages = newUsages;
-            this._variableUsages.set(node, usages);
-          }
-          return usages;
-        }
-        getRecursiveVariableUsages(operation) {
-          let usages = this._recursiveVariableUsages.get(operation);
-          if (!usages) {
-            usages = this.getVariableUsages(operation);
-            for (const frag of this.getRecursivelyReferencedFragments(
-              operation
-            )) {
-              usages = usages.concat(this.getVariableUsages(frag));
-            }
-            this._recursiveVariableUsages.set(operation, usages);
-          }
-          return usages;
-        }
-        getType() {
-          return this._typeInfo.getType();
-        }
-        getParentType() {
-          return this._typeInfo.getParentType();
-        }
-        getInputType() {
-          return this._typeInfo.getInputType();
-        }
-        getParentInputType() {
-          return this._typeInfo.getParentInputType();
-        }
-        getFieldDef() {
-          return this._typeInfo.getFieldDef();
-        }
-        getDirective() {
-          return this._typeInfo.getDirective();
-        }
-        getArgument() {
-          return this._typeInfo.getArgument();
-        }
-        getEnumValue() {
-          return this._typeInfo.getEnumValue();
-        }
-      }
-      function validate(
-        schema,
-        documentAST,
-        rules = specifiedRules,
-        options,
-        typeInfo = new TypeInfo(schema)
-      ) {
-        var _options$maxErrors;
-        const maxErrors =
-          (_options$maxErrors =
-            options === null || options === void 0
-              ? void 0
-              : options.maxErrors) !== null && _options$maxErrors !== void 0
-            ? _options$maxErrors
-            : 100;
-        documentAST || devAssert$1(false, "Must provide document.");
-        assertValidSchema(schema);
-        const abortObj = Object.freeze({});
-        const errors2 = [];
-        const context = new ValidationContext(
-          schema,
-          documentAST,
-          typeInfo,
-          (error2) => {
-            if (errors2.length >= maxErrors) {
-              errors2.push(
-                new GraphQLError(
-                  "Too many validation errors, error limit reached. Validation aborted."
-                )
-              );
-              throw abortObj;
-            }
-            errors2.push(error2);
-          }
-        );
-        const visitor = visitInParallel(rules.map((rule) => rule(context)));
-        try {
-          visit(documentAST, visitWithTypeInfo(typeInfo, visitor));
-        } catch (e) {
-          if (e !== abortObj) {
-            throw e;
-          }
-        }
-        return errors2;
-      }
-      function validateSDL(
-        documentAST,
-        schemaToExtend,
-        rules = specifiedSDLRules$1
-      ) {
-        const errors2 = [];
-        const context = new SDLValidationContext(
-          documentAST,
-          schemaToExtend,
-          (error2) => {
-            errors2.push(error2);
-          }
-        );
-        const visitors = rules.map((rule) => rule(context));
-        visit(documentAST, visitInParallel(visitors));
-        return errors2;
-      }
-      function assertValidSDL(documentAST) {
-        const errors2 = validateSDL(documentAST);
-        if (errors2.length !== 0) {
-          throw new Error(errors2.map((error2) => error2.message).join("\n\n"));
-        }
-      }
-      function assertValidSDLExtension(documentAST, schema) {
-        const errors2 = validateSDL(documentAST, schema);
-        if (errors2.length !== 0) {
-          throw new Error(errors2.map((error2) => error2.message).join("\n\n"));
-        }
-      }
-      function memoize3(fn) {
-        let cache0;
-        return function memoized(a1, a2, a3) {
-          if (cache0 === void 0) {
-            cache0 = /* @__PURE__ */ new WeakMap();
-          }
-          let cache1 = cache0.get(a1);
-          if (cache1 === void 0) {
-            cache1 = /* @__PURE__ */ new WeakMap();
-            cache0.set(a1, cache1);
-          }
-          let cache2 = cache1.get(a2);
-          if (cache2 === void 0) {
-            cache2 = /* @__PURE__ */ new WeakMap();
-            cache1.set(a2, cache2);
-          }
-          let fnResult = cache2.get(a3);
-          if (fnResult === void 0) {
-            fnResult = fn(a1, a2, a3);
-            cache2.set(a3, fnResult);
-          }
-          return fnResult;
-        };
-      }
-      function promiseForObject(object) {
-        return Promise.all(Object.values(object)).then((resolvedValues) => {
-          const resolvedObject = /* @__PURE__ */ Object.create(null);
-          for (const [i, key] of Object.keys(object).entries()) {
-            resolvedObject[key] = resolvedValues[i];
-          }
-          return resolvedObject;
-        });
-      }
-      function promiseReduce$1(values, callbackFn, initialValue) {
-        let accumulator = initialValue;
-        for (const value of values) {
-          accumulator = isPromise$2(accumulator)
-            ? accumulator.then((resolved) => callbackFn(resolved, value))
-            : callbackFn(accumulator, value);
-        }
-        return accumulator;
-      }
-      function toError$1(thrownValue) {
-        return thrownValue instanceof Error
-          ? thrownValue
-          : new NonErrorThrown$1(thrownValue);
-      }
-      class NonErrorThrown$1 extends Error {
-        constructor(thrownValue) {
-          super("Unexpected error value: " + inspect$2(thrownValue));
-          this.name = "NonErrorThrown";
-          this.thrownValue = thrownValue;
-        }
-      }
-      function locatedError(rawOriginalError, nodes, path) {
-        var _nodes;
-        const originalError = toError$1(rawOriginalError);
-        if (isLocatedGraphQLError(originalError)) {
-          return originalError;
-        }
-        return new GraphQLError(originalError.message, {
-          nodes:
-            (_nodes = originalError.nodes) !== null && _nodes !== void 0
-              ? _nodes
-              : nodes,
-          source: originalError.source,
-          positions: originalError.positions,
-          path,
-          originalError,
-        });
-      }
-      function isLocatedGraphQLError(error2) {
-        return Array.isArray(error2.path);
-      }
-      const collectSubfields = memoize3((exeContext, returnType, fieldNodes) =>
-        collectSubfields$1(
-          exeContext.schema,
-          exeContext.fragments,
-          exeContext.variableValues,
-          returnType,
-          fieldNodes
-        )
-      );
-      function execute$1(args) {
-        arguments.length < 2 ||
-          devAssert$1(
-            false,
-            "graphql@16 dropped long-deprecated support for positional arguments, please pass an object instead."
-          );
-        const { schema, document: document2, variableValues, rootValue } = args;
-        assertValidExecutionArguments(schema, document2, variableValues);
-        const exeContext = buildExecutionContext(args);
-        if (!("schema" in exeContext)) {
-          return {
-            errors: exeContext,
-          };
-        }
-        try {
-          const { operation } = exeContext;
-          const result2 = executeOperation(exeContext, operation, rootValue);
-          if (isPromise$2(result2)) {
-            return result2.then(
-              (data) => buildResponse(data, exeContext.errors),
-              (error2) => {
-                exeContext.errors.push(error2);
-                return buildResponse(null, exeContext.errors);
-              }
-            );
-          }
-          return buildResponse(result2, exeContext.errors);
-        } catch (error2) {
-          exeContext.errors.push(error2);
-          return buildResponse(null, exeContext.errors);
-        }
-      }
-      function executeSync(args) {
-        const result2 = execute$1(args);
-        if (isPromise$2(result2)) {
-          throw new Error(
-            "GraphQL execution failed to complete synchronously."
-          );
-        }
-        return result2;
-      }
-      function buildResponse(data, errors2) {
-        return errors2.length === 0
-          ? {
-              data,
-            }
-          : {
-              errors: errors2,
-              data,
-            };
-      }
-      function assertValidExecutionArguments(
-        schema,
-        document2,
-        rawVariableValues
-      ) {
-        document2 || devAssert$1(false, "Must provide document.");
-        assertValidSchema(schema);
-        rawVariableValues == null ||
-          isObjectLike$1(rawVariableValues) ||
-          devAssert$1(
-            false,
-            "Variables must be provided as an Object where each property is a variable value. Perhaps look to see if an unparsed JSON string was provided."
-          );
-      }
-      function buildExecutionContext(args) {
-        var _definition$name, _operation$variableDe;
-        const {
-          schema,
-          document: document2,
-          rootValue,
-          contextValue,
-          variableValues: rawVariableValues,
-          operationName,
-          fieldResolver,
-          typeResolver,
-          subscribeFieldResolver,
-        } = args;
-        let operation;
-        const fragments = /* @__PURE__ */ Object.create(null);
-        for (const definition of document2.definitions) {
-          switch (definition.kind) {
-            case Kind.OPERATION_DEFINITION:
-              if (operationName == null) {
-                if (operation !== void 0) {
-                  return [
-                    new GraphQLError(
-                      "Must provide operation name if query contains multiple operations."
-                    ),
-                  ];
-                }
-                operation = definition;
-              } else if (
-                ((_definition$name = definition.name) === null ||
-                _definition$name === void 0
-                  ? void 0
-                  : _definition$name.value) === operationName
-              ) {
-                operation = definition;
-              }
-              break;
-            case Kind.FRAGMENT_DEFINITION:
-              fragments[definition.name.value] = definition;
-              break;
-          }
-        }
-        if (!operation) {
-          if (operationName != null) {
-            return [
-              new GraphQLError(`Unknown operation named "${operationName}".`),
-            ];
-          }
-          return [new GraphQLError("Must provide an operation.")];
-        }
-        const variableDefinitions =
-          (_operation$variableDe = operation.variableDefinitions) !== null &&
-          _operation$variableDe !== void 0
-            ? _operation$variableDe
-            : [];
-        const coercedVariableValues = getVariableValues$1(
-          schema,
-          variableDefinitions,
-          rawVariableValues !== null && rawVariableValues !== void 0
-            ? rawVariableValues
-            : {},
-          {
-            maxErrors: 50,
-          }
-        );
-        if (coercedVariableValues.errors) {
-          return coercedVariableValues.errors;
-        }
-        return {
-          schema,
-          fragments,
-          rootValue,
-          contextValue,
-          operation,
-          variableValues: coercedVariableValues.coerced,
-          fieldResolver:
-            fieldResolver !== null && fieldResolver !== void 0
-              ? fieldResolver
-              : defaultFieldResolver$1,
-          typeResolver:
-            typeResolver !== null && typeResolver !== void 0
-              ? typeResolver
-              : defaultTypeResolver$1,
-          subscribeFieldResolver:
-            subscribeFieldResolver !== null && subscribeFieldResolver !== void 0
-              ? subscribeFieldResolver
-              : defaultFieldResolver$1,
-          errors: [],
-        };
-      }
-      function executeOperation(exeContext, operation, rootValue) {
-        const rootType = exeContext.schema.getRootType(operation.operation);
-        if (rootType == null) {
-          throw new GraphQLError(
-            `Schema is not configured to execute ${operation.operation} operation.`,
-            {
-              nodes: operation,
-            }
-          );
-        }
-        const rootFields = collectFields$1(
-          exeContext.schema,
-          exeContext.fragments,
-          exeContext.variableValues,
-          rootType,
-          operation.selectionSet
-        );
-        const path = void 0;
-        switch (operation.operation) {
-          case OperationTypeNode.QUERY:
-            return executeFields(
-              exeContext,
-              rootType,
-              rootValue,
-              path,
-              rootFields
-            );
-          case OperationTypeNode.MUTATION:
-            return executeFieldsSerially(
-              exeContext,
-              rootType,
-              rootValue,
-              path,
-              rootFields
-            );
-          case OperationTypeNode.SUBSCRIPTION:
-            return executeFields(
-              exeContext,
-              rootType,
-              rootValue,
-              path,
-              rootFields
-            );
-        }
-      }
-      function executeFieldsSerially(
-        exeContext,
-        parentType,
-        sourceValue,
-        path,
-        fields
-      ) {
-        return promiseReduce$1(
-          fields.entries(),
-          (results, [responseName, fieldNodes]) => {
-            const fieldPath = addPath$1(path, responseName, parentType.name);
-            const result2 = executeField(
-              exeContext,
-              parentType,
-              sourceValue,
-              fieldNodes,
-              fieldPath
-            );
-            if (result2 === void 0) {
-              return results;
-            }
-            if (isPromise$2(result2)) {
-              return result2.then((resolvedResult) => {
-                results[responseName] = resolvedResult;
-                return results;
-              });
-            }
-            results[responseName] = result2;
-            return results;
-          },
-          /* @__PURE__ */ Object.create(null)
-        );
-      }
-      function executeFields(
-        exeContext,
-        parentType,
-        sourceValue,
-        path,
-        fields
-      ) {
-        const results = /* @__PURE__ */ Object.create(null);
-        let containsPromise = false;
-        for (const [responseName, fieldNodes] of fields.entries()) {
-          const fieldPath = addPath$1(path, responseName, parentType.name);
-          const result2 = executeField(
-            exeContext,
-            parentType,
-            sourceValue,
-            fieldNodes,
-            fieldPath
-          );
-          if (result2 !== void 0) {
-            results[responseName] = result2;
-            if (isPromise$2(result2)) {
-              containsPromise = true;
-            }
-          }
-        }
-        if (!containsPromise) {
-          return results;
-        }
-        return promiseForObject(results);
-      }
-      function executeField(exeContext, parentType, source, fieldNodes, path) {
-        var _fieldDef$resolve;
-        const fieldDef = getFieldDef$2(
-          exeContext.schema,
-          parentType,
-          fieldNodes[0]
-        );
-        if (!fieldDef) {
-          return;
-        }
-        const returnType = fieldDef.type;
-        const resolveFn =
-          (_fieldDef$resolve = fieldDef.resolve) !== null &&
-          _fieldDef$resolve !== void 0
-            ? _fieldDef$resolve
-            : exeContext.fieldResolver;
-        const info2 = buildResolveInfo(
-          exeContext,
-          fieldDef,
-          fieldNodes,
-          parentType,
-          path
-        );
-        try {
-          const args = getArgumentValues$1(
-            fieldDef,
-            fieldNodes[0],
-            exeContext.variableValues
-          );
-          const contextValue = exeContext.contextValue;
-          const result2 = resolveFn(source, args, contextValue, info2);
-          let completed;
-          if (isPromise$2(result2)) {
-            completed = result2.then((resolved) =>
-              completeValue(
-                exeContext,
-                returnType,
-                fieldNodes,
-                info2,
-                path,
-                resolved
-              )
-            );
-          } else {
-            completed = completeValue(
-              exeContext,
-              returnType,
-              fieldNodes,
-              info2,
-              path,
-              result2
-            );
-          }
-          if (isPromise$2(completed)) {
-            return completed.then(void 0, (rawError) => {
-              const error2 = locatedError(
-                rawError,
-                fieldNodes,
-                pathToArray$1(path)
-              );
-              return handleFieldError(error2, returnType, exeContext);
-            });
-          }
-          return completed;
-        } catch (rawError) {
-          const error2 = locatedError(
-            rawError,
-            fieldNodes,
-            pathToArray$1(path)
-          );
-          return handleFieldError(error2, returnType, exeContext);
-        }
-      }
-      function buildResolveInfo(
-        exeContext,
-        fieldDef,
-        fieldNodes,
-        parentType,
-        path
-      ) {
-        return {
-          fieldName: fieldDef.name,
-          fieldNodes,
-          returnType: fieldDef.type,
-          parentType,
-          path,
-          schema: exeContext.schema,
-          fragments: exeContext.fragments,
-          rootValue: exeContext.rootValue,
-          operation: exeContext.operation,
-          variableValues: exeContext.variableValues,
-        };
-      }
-      function handleFieldError(error2, returnType, exeContext) {
-        if (isNonNullType(returnType)) {
-          throw error2;
-        }
-        exeContext.errors.push(error2);
-        return null;
-      }
-      function completeValue(
-        exeContext,
-        returnType,
-        fieldNodes,
-        info2,
-        path,
-        result2
-      ) {
-        if (result2 instanceof Error) {
-          throw result2;
-        }
-        if (isNonNullType(returnType)) {
-          const completed = completeValue(
-            exeContext,
-            returnType.ofType,
-            fieldNodes,
-            info2,
-            path,
-            result2
-          );
-          if (completed === null) {
-            throw new Error(
-              `Cannot return null for non-nullable field ${info2.parentType.name}.${info2.fieldName}.`
-            );
-          }
-          return completed;
-        }
-        if (result2 == null) {
-          return null;
-        }
-        if (isListType(returnType)) {
-          return completeListValue(
-            exeContext,
-            returnType,
-            fieldNodes,
-            info2,
-            path,
-            result2
-          );
-        }
-        if (isLeafType(returnType)) {
-          return completeLeafValue(returnType, result2);
-        }
-        if (isAbstractType(returnType)) {
-          return completeAbstractValue(
-            exeContext,
-            returnType,
-            fieldNodes,
-            info2,
-            path,
-            result2
-          );
-        }
-        if (isObjectType(returnType)) {
-          return completeObjectValue(
-            exeContext,
-            returnType,
-            fieldNodes,
-            info2,
-            path,
-            result2
-          );
-        }
-        invariant$2(
-          false,
-          "Cannot complete value of unexpected output type: " +
-            inspect$2(returnType)
-        );
-      }
-      function completeListValue(
-        exeContext,
-        returnType,
-        fieldNodes,
-        info2,
-        path,
-        result2
-      ) {
-        if (!isIterableObject$1(result2)) {
-          throw new GraphQLError(
-            `Expected Iterable, but did not find one for field "${info2.parentType.name}.${info2.fieldName}".`
-          );
-        }
-        const itemType = returnType.ofType;
-        let containsPromise = false;
-        const completedResults = Array.from(result2, (item, index) => {
-          const itemPath = addPath$1(path, index, void 0);
-          try {
-            let completedItem;
-            if (isPromise$2(item)) {
-              completedItem = item.then((resolved) =>
-                completeValue(
-                  exeContext,
-                  itemType,
-                  fieldNodes,
-                  info2,
-                  itemPath,
-                  resolved
-                )
-              );
-            } else {
-              completedItem = completeValue(
-                exeContext,
-                itemType,
-                fieldNodes,
-                info2,
-                itemPath,
-                item
-              );
-            }
-            if (isPromise$2(completedItem)) {
-              containsPromise = true;
-              return completedItem.then(void 0, (rawError) => {
-                const error2 = locatedError(
-                  rawError,
-                  fieldNodes,
-                  pathToArray$1(itemPath)
-                );
-                return handleFieldError(error2, itemType, exeContext);
-              });
-            }
-            return completedItem;
-          } catch (rawError) {
-            const error2 = locatedError(
-              rawError,
-              fieldNodes,
-              pathToArray$1(itemPath)
-            );
-            return handleFieldError(error2, itemType, exeContext);
-          }
-        });
-        return containsPromise
-          ? Promise.all(completedResults)
-          : completedResults;
-      }
-      function completeLeafValue(returnType, result2) {
-        const serializedResult = returnType.serialize(result2);
-        if (serializedResult == null) {
-          throw new Error(
-            `Expected \`${inspect$2(returnType)}.serialize(${inspect$2(
-              result2
-            )})\` to return non-nullable value, returned: ${inspect$2(
-              serializedResult
-            )}`
-          );
-        }
-        return serializedResult;
-      }
-      function completeAbstractValue(
-        exeContext,
-        returnType,
-        fieldNodes,
-        info2,
-        path,
-        result2
-      ) {
-        var _returnType$resolveTy;
-        const resolveTypeFn =
-          (_returnType$resolveTy = returnType.resolveType) !== null &&
-          _returnType$resolveTy !== void 0
-            ? _returnType$resolveTy
-            : exeContext.typeResolver;
-        const contextValue = exeContext.contextValue;
-        const runtimeType = resolveTypeFn(
-          result2,
-          contextValue,
-          info2,
-          returnType
-        );
-        if (isPromise$2(runtimeType)) {
-          return runtimeType.then((resolvedRuntimeType) =>
-            completeObjectValue(
-              exeContext,
-              ensureValidRuntimeType(
-                resolvedRuntimeType,
-                exeContext,
-                returnType,
-                fieldNodes,
-                info2,
-                result2
-              ),
-              fieldNodes,
-              info2,
-              path,
-              result2
-            )
-          );
-        }
-        return completeObjectValue(
-          exeContext,
-          ensureValidRuntimeType(
-            runtimeType,
-            exeContext,
-            returnType,
-            fieldNodes,
-            info2,
-            result2
-          ),
-          fieldNodes,
-          info2,
-          path,
-          result2
-        );
-      }
-      function ensureValidRuntimeType(
-        runtimeTypeName,
-        exeContext,
-        returnType,
-        fieldNodes,
-        info2,
-        result2
-      ) {
-        if (runtimeTypeName == null) {
-          throw new GraphQLError(
-            `Abstract type "${returnType.name}" must resolve to an Object type at runtime for field "${info2.parentType.name}.${info2.fieldName}". Either the "${returnType.name}" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.`,
-            fieldNodes
-          );
-        }
-        if (isObjectType(runtimeTypeName)) {
-          throw new GraphQLError(
-            "Support for returning GraphQLObjectType from resolveType was removed in graphql-js@16.0.0 please return type name instead."
-          );
-        }
-        if (typeof runtimeTypeName !== "string") {
-          throw new GraphQLError(
-            `Abstract type "${
-              returnType.name
-            }" must resolve to an Object type at runtime for field "${
-              info2.parentType.name
-            }.${info2.fieldName}" with value ${inspect$2(
-              result2
-            )}, received "${inspect$2(runtimeTypeName)}".`
-          );
-        }
-        const runtimeType = exeContext.schema.getType(runtimeTypeName);
-        if (runtimeType == null) {
-          throw new GraphQLError(
-            `Abstract type "${returnType.name}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
-            {
-              nodes: fieldNodes,
-            }
-          );
-        }
-        if (!isObjectType(runtimeType)) {
-          throw new GraphQLError(
-            `Abstract type "${returnType.name}" was resolved to a non-object type "${runtimeTypeName}".`,
-            {
-              nodes: fieldNodes,
-            }
-          );
-        }
-        if (!exeContext.schema.isSubType(returnType, runtimeType)) {
-          throw new GraphQLError(
-            `Runtime Object type "${runtimeType.name}" is not a possible type for "${returnType.name}".`,
-            {
-              nodes: fieldNodes,
-            }
-          );
-        }
-        return runtimeType;
-      }
-      function completeObjectValue(
-        exeContext,
-        returnType,
-        fieldNodes,
-        info2,
-        path,
-        result2
-      ) {
-        const subFieldNodes = collectSubfields(
-          exeContext,
-          returnType,
-          fieldNodes
-        );
-        if (returnType.isTypeOf) {
-          const isTypeOf = returnType.isTypeOf(
-            result2,
-            exeContext.contextValue,
-            info2
-          );
-          if (isPromise$2(isTypeOf)) {
-            return isTypeOf.then((resolvedIsTypeOf) => {
-              if (!resolvedIsTypeOf) {
-                throw invalidReturnTypeError(returnType, result2, fieldNodes);
-              }
-              return executeFields(
-                exeContext,
-                returnType,
-                result2,
-                path,
-                subFieldNodes
-              );
-            });
-          }
-          if (!isTypeOf) {
-            throw invalidReturnTypeError(returnType, result2, fieldNodes);
-          }
-        }
-        return executeFields(
-          exeContext,
-          returnType,
-          result2,
-          path,
-          subFieldNodes
-        );
-      }
-      function invalidReturnTypeError(returnType, result2, fieldNodes) {
-        return new GraphQLError(
-          `Expected value of type "${returnType.name}" but got: ${inspect$2(
-            result2
-          )}.`,
-          {
-            nodes: fieldNodes,
-          }
-        );
-      }
-      const defaultTypeResolver$1 = function (
-        value,
-        contextValue,
-        info2,
-        abstractType
-      ) {
-        if (isObjectLike$1(value) && typeof value.__typename === "string") {
-          return value.__typename;
-        }
-        const possibleTypes = info2.schema.getPossibleTypes(abstractType);
-        const promisedIsTypeOfResults = [];
-        for (let i = 0; i < possibleTypes.length; i++) {
-          const type2 = possibleTypes[i];
-          if (type2.isTypeOf) {
-            const isTypeOfResult = type2.isTypeOf(value, contextValue, info2);
-            if (isPromise$2(isTypeOfResult)) {
-              promisedIsTypeOfResults[i] = isTypeOfResult;
-            } else if (isTypeOfResult) {
-              return type2.name;
-            }
-          }
-        }
-        if (promisedIsTypeOfResults.length) {
-          return Promise.all(promisedIsTypeOfResults).then(
-            (isTypeOfResults) => {
-              for (let i = 0; i < isTypeOfResults.length; i++) {
-                if (isTypeOfResults[i]) {
-                  return possibleTypes[i].name;
-                }
-              }
-            }
-          );
-        }
-      };
-      const defaultFieldResolver$1 = function (
-        source,
-        args,
-        contextValue,
-        info2
-      ) {
-        if (isObjectLike$1(source) || typeof source === "function") {
-          const property = source[info2.fieldName];
-          if (typeof property === "function") {
-            return source[info2.fieldName](args, contextValue, info2);
-          }
-          return property;
-        }
-      };
-      function getFieldDef$2(schema, parentType, fieldNode) {
-        const fieldName = fieldNode.name.value;
-        if (
-          fieldName === SchemaMetaFieldDef$1.name &&
-          schema.getQueryType() === parentType
-        ) {
-          return SchemaMetaFieldDef$1;
-        } else if (
-          fieldName === TypeMetaFieldDef$1.name &&
-          schema.getQueryType() === parentType
-        ) {
-          return TypeMetaFieldDef$1;
-        } else if (fieldName === TypeNameMetaFieldDef.name) {
-          return TypeNameMetaFieldDef;
-        }
-        return parentType.getFields()[fieldName];
-      }
-      function graphql$1(args) {
-        return new Promise((resolve) => resolve(graphqlImpl(args)));
-      }
-      function graphqlSync(args) {
-        const result2 = graphqlImpl(args);
-        if (isPromise$2(result2)) {
-          throw new Error(
-            "GraphQL execution failed to complete synchronously."
-          );
-        }
-        return result2;
-      }
-      function graphqlImpl(args) {
-        arguments.length < 2 ||
-          devAssert$1(
-            false,
-            "graphql@16 dropped long-deprecated support for positional arguments, please pass an object instead."
-          );
-        const {
-          schema,
-          source,
-          rootValue,
-          contextValue,
-          variableValues,
-          operationName,
-          fieldResolver,
-          typeResolver,
-        } = args;
-        const schemaValidationErrors = validateSchema(schema);
-        if (schemaValidationErrors.length > 0) {
-          return {
-            errors: schemaValidationErrors,
-          };
-        }
-        let document2;
-        try {
-          document2 = parse$1(source);
-        } catch (syntaxError2) {
-          return {
-            errors: [syntaxError2],
-          };
-        }
-        const validationErrors = validate(schema, document2);
-        if (validationErrors.length > 0) {
-          return {
-            errors: validationErrors,
-          };
-        }
-        return execute$1({
-          schema,
-          document: document2,
-          rootValue,
-          contextValue,
-          variableValues,
-          operationName,
-          fieldResolver,
-          typeResolver,
-        });
-      }
-      function isAsyncIterable$3(maybeAsyncIterable) {
-        return (
-          typeof (maybeAsyncIterable === null || maybeAsyncIterable === void 0
-            ? void 0
-            : maybeAsyncIterable[Symbol.asyncIterator]) === "function"
-        );
-      }
-      function mapAsyncIterator$1(iterable, callback) {
-        const iterator = iterable[Symbol.asyncIterator]();
-        async function mapResult(result2) {
-          if (result2.done) {
-            return result2;
-          }
-          try {
-            return {
-              value: await callback(result2.value),
-              done: false,
-            };
-          } catch (error2) {
-            if (typeof iterator.return === "function") {
-              try {
-                await iterator.return();
-              } catch (_e) {}
-            }
-            throw error2;
-          }
-        }
-        return {
-          async next() {
-            return mapResult(await iterator.next());
-          },
-          async return() {
-            return typeof iterator.return === "function"
-              ? mapResult(await iterator.return())
-              : {
-                  value: void 0,
-                  done: true,
-                };
-          },
-          async throw(error2) {
-            if (typeof iterator.throw === "function") {
-              return mapResult(await iterator.throw(error2));
-            }
-            throw error2;
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          },
-        };
-      }
-      async function subscribe(args) {
-        arguments.length < 2 ||
-          devAssert$1(
-            false,
-            "graphql@16 dropped long-deprecated support for positional arguments, please pass an object instead."
-          );
-        const {
-          schema,
-          document: document2,
-          rootValue,
-          contextValue,
-          variableValues,
-          operationName,
-          fieldResolver,
-          subscribeFieldResolver,
-        } = args;
-        const resultOrStream = await createSourceEventStream(
-          schema,
-          document2,
-          rootValue,
-          contextValue,
-          variableValues,
-          operationName,
-          subscribeFieldResolver
-        );
-        if (!isAsyncIterable$3(resultOrStream)) {
-          return resultOrStream;
-        }
-        const mapSourceToResponse = (payload) =>
-          execute$1({
-            schema,
-            document: document2,
-            rootValue: payload,
-            contextValue,
-            variableValues,
-            operationName,
-            fieldResolver,
-          });
-        return mapAsyncIterator$1(resultOrStream, mapSourceToResponse);
-      }
-      async function createSourceEventStream(
-        schema,
-        document2,
-        rootValue,
-        contextValue,
-        variableValues,
-        operationName,
-        subscribeFieldResolver
-      ) {
-        assertValidExecutionArguments(schema, document2, variableValues);
-        const exeContext = buildExecutionContext({
-          schema,
-          document: document2,
-          rootValue,
-          contextValue,
-          variableValues,
-          operationName,
-          subscribeFieldResolver,
-        });
-        if (!("schema" in exeContext)) {
-          return {
-            errors: exeContext,
-          };
-        }
-        try {
-          const eventStream = await executeSubscription(exeContext);
-          if (!isAsyncIterable$3(eventStream)) {
-            throw new Error(
-              `Subscription field must return Async Iterable. Received: ${inspect$2(
-                eventStream
-              )}.`
-            );
-          }
-          return eventStream;
-        } catch (error2) {
-          if (error2 instanceof GraphQLError) {
-            return {
-              errors: [error2],
-            };
-          }
-          throw error2;
-        }
-      }
-      async function executeSubscription(exeContext) {
-        const { schema, fragments, operation, variableValues, rootValue } =
-          exeContext;
-        const rootType = schema.getSubscriptionType();
-        if (rootType == null) {
-          throw new GraphQLError(
-            "Schema is not configured to execute subscription operation.",
-            {
-              nodes: operation,
-            }
-          );
-        }
-        const rootFields = collectFields$1(
-          schema,
-          fragments,
-          variableValues,
-          rootType,
-          operation.selectionSet
-        );
-        const [responseName, fieldNodes] = [...rootFields.entries()][0];
-        const fieldDef = getFieldDef$2(schema, rootType, fieldNodes[0]);
-        if (!fieldDef) {
-          const fieldName = fieldNodes[0].name.value;
-          throw new GraphQLError(
-            `The subscription field "${fieldName}" is not defined.`,
-            {
-              nodes: fieldNodes,
-            }
-          );
-        }
-        const path = addPath$1(void 0, responseName, rootType.name);
-        const info2 = buildResolveInfo(
-          exeContext,
-          fieldDef,
-          fieldNodes,
-          rootType,
-          path
-        );
-        try {
-          var _fieldDef$subscribe;
-          const args = getArgumentValues$1(
-            fieldDef,
-            fieldNodes[0],
-            variableValues
-          );
-          const contextValue = exeContext.contextValue;
-          const resolveFn =
-            (_fieldDef$subscribe = fieldDef.subscribe) !== null &&
-            _fieldDef$subscribe !== void 0
-              ? _fieldDef$subscribe
-              : exeContext.subscribeFieldResolver;
-          const eventStream = await resolveFn(
-            rootValue,
-            args,
-            contextValue,
-            info2
-          );
-          if (eventStream instanceof Error) {
-            throw eventStream;
-          }
-          return eventStream;
-        } catch (error2) {
-          throw locatedError(error2, fieldNodes, pathToArray$1(path));
-        }
-      }
-      function NoDeprecatedCustomRule(context) {
-        return {
-          Field(node) {
-            const fieldDef = context.getFieldDef();
-            const deprecationReason =
-              fieldDef === null || fieldDef === void 0
-                ? void 0
-                : fieldDef.deprecationReason;
-            if (fieldDef && deprecationReason != null) {
-              const parentType = context.getParentType();
-              parentType != null || invariant$2(false);
-              context.reportError(
-                new GraphQLError(
-                  `The field ${parentType.name}.${fieldDef.name} is deprecated. ${deprecationReason}`,
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-            }
-          },
-          Argument(node) {
-            const argDef = context.getArgument();
-            const deprecationReason =
-              argDef === null || argDef === void 0
-                ? void 0
-                : argDef.deprecationReason;
-            if (argDef && deprecationReason != null) {
-              const directiveDef = context.getDirective();
-              if (directiveDef != null) {
-                context.reportError(
-                  new GraphQLError(
-                    `Directive "@${directiveDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
-                    {
-                      nodes: node,
-                    }
-                  )
-                );
-              } else {
-                const parentType = context.getParentType();
-                const fieldDef = context.getFieldDef();
-                (parentType != null && fieldDef != null) || invariant$2(false);
-                context.reportError(
-                  new GraphQLError(
-                    `Field "${parentType.name}.${fieldDef.name}" argument "${argDef.name}" is deprecated. ${deprecationReason}`,
-                    {
-                      nodes: node,
-                    }
-                  )
-                );
-              }
-            }
-          },
-          ObjectField(node) {
-            const inputObjectDef = getNamedType(context.getParentInputType());
-            if (isInputObjectType(inputObjectDef)) {
-              const inputFieldDef = inputObjectDef.getFields()[node.name.value];
-              const deprecationReason =
-                inputFieldDef === null || inputFieldDef === void 0
-                  ? void 0
-                  : inputFieldDef.deprecationReason;
-              if (deprecationReason != null) {
-                context.reportError(
-                  new GraphQLError(
-                    `The input field ${inputObjectDef.name}.${inputFieldDef.name} is deprecated. ${deprecationReason}`,
-                    {
-                      nodes: node,
-                    }
-                  )
-                );
-              }
-            }
-          },
-          EnumValue(node) {
-            const enumValueDef = context.getEnumValue();
-            const deprecationReason =
-              enumValueDef === null || enumValueDef === void 0
-                ? void 0
-                : enumValueDef.deprecationReason;
-            if (enumValueDef && deprecationReason != null) {
-              const enumTypeDef = getNamedType(context.getInputType());
-              enumTypeDef != null || invariant$2(false);
-              context.reportError(
-                new GraphQLError(
-                  `The enum value "${enumTypeDef.name}.${enumValueDef.name}" is deprecated. ${deprecationReason}`,
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-            }
-          },
-        };
-      }
-      function NoSchemaIntrospectionCustomRule(context) {
-        return {
-          Field(node) {
-            const type2 = getNamedType(context.getType());
-            if (type2 && isIntrospectionType(type2)) {
-              context.reportError(
-                new GraphQLError(
-                  `GraphQL introspection has been disabled, but the requested query contained the field "${node.name.value}".`,
-                  {
-                    nodes: node,
-                  }
-                )
-              );
-            }
-          },
-        };
-      }
-      function getIntrospectionQuery(options) {
-        const optionsWithDefault = __spreadValues(
-          {
-            descriptions: true,
-            specifiedByUrl: false,
-            directiveIsRepeatable: false,
-            schemaDescription: false,
-            inputValueDeprecation: false,
-          },
-          options
-        );
-        const descriptions = optionsWithDefault.descriptions
-          ? "description"
-          : "";
-        const specifiedByUrl = optionsWithDefault.specifiedByUrl
-          ? "specifiedByURL"
-          : "";
-        const directiveIsRepeatable = optionsWithDefault.directiveIsRepeatable
-          ? "isRepeatable"
-          : "";
-        const schemaDescription = optionsWithDefault.schemaDescription
-          ? descriptions
-          : "";
-        function inputDeprecation(str) {
-          return optionsWithDefault.inputValueDeprecation ? str : "";
-        }
-        return `
-    query IntrospectionQuery {
-      __schema {
-        ${schemaDescription}
-        queryType { name }
-        mutationType { name }
-        subscriptionType { name }
-        types {
-          ...FullType
-        }
-        directives {
-          name
-          ${descriptions}
-          ${directiveIsRepeatable}
-          locations
-          args${inputDeprecation("(includeDeprecated: true)")} {
-            ...InputValue
-          }
-        }
-      }
-    }
-
-    fragment FullType on __Type {
-      kind
-      name
-      ${descriptions}
-      ${specifiedByUrl}
-      fields(includeDeprecated: true) {
-        name
-        ${descriptions}
-        args${inputDeprecation("(includeDeprecated: true)")} {
-          ...InputValue
-        }
-        type {
-          ...TypeRef
-        }
-        isDeprecated
-        deprecationReason
-      }
-      inputFields${inputDeprecation("(includeDeprecated: true)")} {
-        ...InputValue
-      }
-      interfaces {
-        ...TypeRef
-      }
-      enumValues(includeDeprecated: true) {
-        name
-        ${descriptions}
-        isDeprecated
-        deprecationReason
-      }
-      possibleTypes {
-        ...TypeRef
-      }
-    }
-
-    fragment InputValue on __InputValue {
-      name
-      ${descriptions}
-      type { ...TypeRef }
-      defaultValue
-      ${inputDeprecation("isDeprecated")}
-      ${inputDeprecation("deprecationReason")}
-    }
-
-    fragment TypeRef on __Type {
-      kind
-      name
-      ofType {
-        kind
-        name
-        ofType {
-          kind
-          name
-          ofType {
-            kind
-            name
-            ofType {
-              kind
-              name
-              ofType {
-                kind
-                name
-                ofType {
-                  kind
-                  name
-                  ofType {
-                    kind
-                    name
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  `;
-      }
-      function getOperationAST(documentAST, operationName) {
-        let operation = null;
-        for (const definition of documentAST.definitions) {
-          if (definition.kind === Kind.OPERATION_DEFINITION) {
-            var _definition$name;
-            if (operationName == null) {
-              if (operation) {
-                return null;
-              }
-              operation = definition;
-            } else if (
-              ((_definition$name = definition.name) === null ||
-              _definition$name === void 0
-                ? void 0
-                : _definition$name.value) === operationName
-            ) {
-              return definition;
-            }
-          }
-        }
-        return operation;
-      }
-      var getOperationAST$1 = /* @__PURE__ */ Object.freeze({
-        __proto__: null,
-        [Symbol.toStringTag]: "Module",
-        getOperationAST,
-      });
-      function getOperationRootType(schema, operation) {
-        if (operation.operation === "query") {
-          const queryType = schema.getQueryType();
-          if (!queryType) {
-            throw new GraphQLError(
-              "Schema does not define the required query root type.",
-              {
-                nodes: operation,
-              }
-            );
-          }
-          return queryType;
-        }
-        if (operation.operation === "mutation") {
-          const mutationType = schema.getMutationType();
-          if (!mutationType) {
-            throw new GraphQLError("Schema is not configured for mutations.", {
-              nodes: operation,
-            });
-          }
-          return mutationType;
-        }
-        if (operation.operation === "subscription") {
-          const subscriptionType = schema.getSubscriptionType();
-          if (!subscriptionType) {
-            throw new GraphQLError(
-              "Schema is not configured for subscriptions.",
-              {
-                nodes: operation,
-              }
-            );
-          }
-          return subscriptionType;
-        }
-        throw new GraphQLError(
-          "Can only have query, mutation and subscription operations.",
-          {
-            nodes: operation,
-          }
-        );
-      }
-      function introspectionFromSchema(schema, options) {
-        const optionsWithDefaults = __spreadValues(
-          {
-            specifiedByUrl: true,
-            directiveIsRepeatable: true,
-            schemaDescription: true,
-            inputValueDeprecation: true,
-          },
-          options
-        );
-        const document2 = parse$1(getIntrospectionQuery(optionsWithDefaults));
-        const result2 = executeSync({
-          schema,
-          document: document2,
-        });
-        (!result2.errors && result2.data) || invariant$2(false);
-        return result2.data;
-      }
-      function buildClientSchema(introspection2, options) {
-        (isObjectLike$1(introspection2) &&
-          isObjectLike$1(introspection2.__schema)) ||
-          devAssert$1(
-            false,
-            `Invalid or incomplete introspection result. Ensure that you are passing "data" property of introspection response and no "errors" was returned alongside: ${inspect$2(
-              introspection2
-            )}.`
-          );
-        const schemaIntrospection = introspection2.__schema;
-        const typeMap = keyValMap(
-          schemaIntrospection.types,
-          (typeIntrospection) => typeIntrospection.name,
-          (typeIntrospection) => buildType(typeIntrospection)
-        );
-        for (const stdType of [
-          ...specifiedScalarTypes,
-          ...introspectionTypes$1,
-        ]) {
-          if (typeMap[stdType.name]) {
-            typeMap[stdType.name] = stdType;
-          }
-        }
-        const queryType = schemaIntrospection.queryType
-          ? getObjectType(schemaIntrospection.queryType)
-          : null;
-        const mutationType = schemaIntrospection.mutationType
-          ? getObjectType(schemaIntrospection.mutationType)
-          : null;
-        const subscriptionType = schemaIntrospection.subscriptionType
-          ? getObjectType(schemaIntrospection.subscriptionType)
-          : null;
-        const directives = schemaIntrospection.directives
-          ? schemaIntrospection.directives.map(buildDirective)
-          : [];
-        return new GraphQLSchema({
-          description: schemaIntrospection.description,
-          query: queryType,
-          mutation: mutationType,
-          subscription: subscriptionType,
-          types: Object.values(typeMap),
-          directives,
-          assumeValid:
-            options === null || options === void 0
-              ? void 0
-              : options.assumeValid,
-        });
-        function getType(typeRef) {
-          if (typeRef.kind === TypeKind.LIST) {
-            const itemRef = typeRef.ofType;
-            if (!itemRef) {
-              throw new Error(
-                "Decorated type deeper than introspection query."
-              );
-            }
-            return new GraphQLList(getType(itemRef));
-          }
-          if (typeRef.kind === TypeKind.NON_NULL) {
-            const nullableRef = typeRef.ofType;
-            if (!nullableRef) {
-              throw new Error(
-                "Decorated type deeper than introspection query."
-              );
-            }
-            const nullableType = getType(nullableRef);
-            return new GraphQLNonNull(assertNullableType(nullableType));
-          }
-          return getNamedType2(typeRef);
-        }
-        function getNamedType2(typeRef) {
-          const typeName = typeRef.name;
-          if (!typeName) {
-            throw new Error(`Unknown type reference: ${inspect$2(typeRef)}.`);
-          }
-          const type2 = typeMap[typeName];
-          if (!type2) {
-            throw new Error(
-              `Invalid or incomplete schema, unknown type: ${typeName}. Ensure that a full introspection query is used in order to build a client schema.`
-            );
-          }
-          return type2;
-        }
-        function getObjectType(typeRef) {
-          return assertObjectType(getNamedType2(typeRef));
-        }
-        function getInterfaceType(typeRef) {
-          return assertInterfaceType(getNamedType2(typeRef));
-        }
-        function buildType(type2) {
-          if (type2 != null && type2.name != null && type2.kind != null) {
-            switch (type2.kind) {
-              case TypeKind.SCALAR:
-                return buildScalarDef(type2);
-              case TypeKind.OBJECT:
-                return buildObjectDef(type2);
-              case TypeKind.INTERFACE:
-                return buildInterfaceDef(type2);
-              case TypeKind.UNION:
-                return buildUnionDef(type2);
-              case TypeKind.ENUM:
-                return buildEnumDef(type2);
-              case TypeKind.INPUT_OBJECT:
-                return buildInputObjectDef(type2);
-            }
-          }
-          const typeStr = inspect$2(type2);
-          throw new Error(
-            `Invalid or incomplete introspection result. Ensure that a full introspection query is used in order to build a client schema: ${typeStr}.`
-          );
-        }
-        function buildScalarDef(scalarIntrospection) {
-          return new GraphQLScalarType({
-            name: scalarIntrospection.name,
-            description: scalarIntrospection.description,
-            specifiedByURL: scalarIntrospection.specifiedByURL,
-          });
-        }
-        function buildImplementationsList(implementingIntrospection) {
-          if (
-            implementingIntrospection.interfaces === null &&
-            implementingIntrospection.kind === TypeKind.INTERFACE
-          ) {
-            return [];
-          }
-          if (!implementingIntrospection.interfaces) {
-            const implementingIntrospectionStr = inspect$2(
-              implementingIntrospection
-            );
-            throw new Error(
-              `Introspection result missing interfaces: ${implementingIntrospectionStr}.`
-            );
-          }
-          return implementingIntrospection.interfaces.map(getInterfaceType);
-        }
-        function buildObjectDef(objectIntrospection) {
-          return new GraphQLObjectType({
-            name: objectIntrospection.name,
-            description: objectIntrospection.description,
-            interfaces: () => buildImplementationsList(objectIntrospection),
-            fields: () => buildFieldDefMap(objectIntrospection),
-          });
-        }
-        function buildInterfaceDef(interfaceIntrospection) {
-          return new GraphQLInterfaceType({
-            name: interfaceIntrospection.name,
-            description: interfaceIntrospection.description,
-            interfaces: () => buildImplementationsList(interfaceIntrospection),
-            fields: () => buildFieldDefMap(interfaceIntrospection),
-          });
-        }
-        function buildUnionDef(unionIntrospection) {
-          if (!unionIntrospection.possibleTypes) {
-            const unionIntrospectionStr = inspect$2(unionIntrospection);
-            throw new Error(
-              `Introspection result missing possibleTypes: ${unionIntrospectionStr}.`
-            );
-          }
-          return new GraphQLUnionType({
-            name: unionIntrospection.name,
-            description: unionIntrospection.description,
-            types: () => unionIntrospection.possibleTypes.map(getObjectType),
-          });
-        }
-        function buildEnumDef(enumIntrospection) {
-          if (!enumIntrospection.enumValues) {
-            const enumIntrospectionStr = inspect$2(enumIntrospection);
-            throw new Error(
-              `Introspection result missing enumValues: ${enumIntrospectionStr}.`
-            );
-          }
-          return new GraphQLEnumType({
-            name: enumIntrospection.name,
-            description: enumIntrospection.description,
-            values: keyValMap(
-              enumIntrospection.enumValues,
-              (valueIntrospection) => valueIntrospection.name,
-              (valueIntrospection) => ({
-                description: valueIntrospection.description,
-                deprecationReason: valueIntrospection.deprecationReason,
-              })
-            ),
-          });
-        }
-        function buildInputObjectDef(inputObjectIntrospection) {
-          if (!inputObjectIntrospection.inputFields) {
-            const inputObjectIntrospectionStr = inspect$2(
-              inputObjectIntrospection
-            );
-            throw new Error(
-              `Introspection result missing inputFields: ${inputObjectIntrospectionStr}.`
-            );
-          }
-          return new GraphQLInputObjectType({
-            name: inputObjectIntrospection.name,
-            description: inputObjectIntrospection.description,
-            fields: () =>
-              buildInputValueDefMap(inputObjectIntrospection.inputFields),
-          });
-        }
-        function buildFieldDefMap(typeIntrospection) {
-          if (!typeIntrospection.fields) {
-            throw new Error(
-              `Introspection result missing fields: ${inspect$2(
-                typeIntrospection
-              )}.`
-            );
-          }
-          return keyValMap(
-            typeIntrospection.fields,
-            (fieldIntrospection) => fieldIntrospection.name,
-            buildField
-          );
-        }
-        function buildField(fieldIntrospection) {
-          const type2 = getType(fieldIntrospection.type);
-          if (!isOutputType(type2)) {
-            const typeStr = inspect$2(type2);
-            throw new Error(
-              `Introspection must provide output type for fields, but received: ${typeStr}.`
-            );
-          }
-          if (!fieldIntrospection.args) {
-            const fieldIntrospectionStr = inspect$2(fieldIntrospection);
-            throw new Error(
-              `Introspection result missing field args: ${fieldIntrospectionStr}.`
-            );
-          }
-          return {
-            description: fieldIntrospection.description,
-            deprecationReason: fieldIntrospection.deprecationReason,
-            type: type2,
-            args: buildInputValueDefMap(fieldIntrospection.args),
-          };
-        }
-        function buildInputValueDefMap(inputValueIntrospections) {
-          return keyValMap(
-            inputValueIntrospections,
-            (inputValue) => inputValue.name,
-            buildInputValue
-          );
-        }
-        function buildInputValue(inputValueIntrospection) {
-          const type2 = getType(inputValueIntrospection.type);
-          if (!isInputType(type2)) {
-            const typeStr = inspect$2(type2);
-            throw new Error(
-              `Introspection must provide input type for arguments, but received: ${typeStr}.`
-            );
-          }
-          const defaultValue2 =
-            inputValueIntrospection.defaultValue != null
-              ? valueFromAST$1(
-                  parseValue$1(inputValueIntrospection.defaultValue),
-                  type2
-                )
-              : void 0;
-          return {
-            description: inputValueIntrospection.description,
-            type: type2,
-            defaultValue: defaultValue2,
-            deprecationReason: inputValueIntrospection.deprecationReason,
-          };
-        }
-        function buildDirective(directiveIntrospection) {
-          if (!directiveIntrospection.args) {
-            const directiveIntrospectionStr = inspect$2(directiveIntrospection);
-            throw new Error(
-              `Introspection result missing directive args: ${directiveIntrospectionStr}.`
-            );
-          }
-          if (!directiveIntrospection.locations) {
-            const directiveIntrospectionStr = inspect$2(directiveIntrospection);
-            throw new Error(
-              `Introspection result missing directive locations: ${directiveIntrospectionStr}.`
-            );
-          }
-          return new GraphQLDirective({
-            name: directiveIntrospection.name,
-            description: directiveIntrospection.description,
-            isRepeatable: directiveIntrospection.isRepeatable,
-            locations: directiveIntrospection.locations.slice(),
-            args: buildInputValueDefMap(directiveIntrospection.args),
-          });
-        }
-      }
-      function extendSchema(schema, documentAST, options) {
-        assertSchema(schema);
-        (documentAST != null && documentAST.kind === Kind.DOCUMENT) ||
-          devAssert$1(false, "Must provide valid Document AST.");
-        if (
-          (options === null || options === void 0
-            ? void 0
-            : options.assumeValid) !== true &&
-          (options === null || options === void 0
-            ? void 0
-            : options.assumeValidSDL) !== true
-        ) {
-          assertValidSDLExtension(documentAST, schema);
-        }
-        const schemaConfig = schema.toConfig();
-        const extendedConfig = extendSchemaImpl(
-          schemaConfig,
-          documentAST,
-          options
-        );
-        return schemaConfig === extendedConfig
-          ? schema
-          : new GraphQLSchema(extendedConfig);
-      }
-      function extendSchemaImpl(schemaConfig, documentAST, options) {
-        var _schemaDef,
-          _schemaDef$descriptio,
-          _schemaDef2,
-          _options$assumeValid;
-        const typeDefs = [];
-        const typeExtensionsMap = /* @__PURE__ */ Object.create(null);
-        const directiveDefs = [];
-        let schemaDef;
-        const schemaExtensions = [];
-        for (const def of documentAST.definitions) {
-          if (def.kind === Kind.SCHEMA_DEFINITION) {
-            schemaDef = def;
-          } else if (def.kind === Kind.SCHEMA_EXTENSION) {
-            schemaExtensions.push(def);
-          } else if (isTypeDefinitionNode(def)) {
-            typeDefs.push(def);
-          } else if (isTypeExtensionNode(def)) {
-            const extendedTypeName = def.name.value;
-            const existingTypeExtensions = typeExtensionsMap[extendedTypeName];
-            typeExtensionsMap[extendedTypeName] = existingTypeExtensions
-              ? existingTypeExtensions.concat([def])
-              : [def];
-          } else if (def.kind === Kind.DIRECTIVE_DEFINITION) {
-            directiveDefs.push(def);
-          }
-        }
-        if (
-          Object.keys(typeExtensionsMap).length === 0 &&
-          typeDefs.length === 0 &&
-          directiveDefs.length === 0 &&
-          schemaExtensions.length === 0 &&
-          schemaDef == null
-        ) {
-          return schemaConfig;
-        }
-        const typeMap = /* @__PURE__ */ Object.create(null);
-        for (const existingType of schemaConfig.types) {
-          typeMap[existingType.name] = extendNamedType(existingType);
-        }
-        for (const typeNode of typeDefs) {
-          var _stdTypeMap$name;
-          const name2 = typeNode.name.value;
-          typeMap[name2] =
-            (_stdTypeMap$name = stdTypeMap[name2]) !== null &&
-            _stdTypeMap$name !== void 0
-              ? _stdTypeMap$name
-              : buildType(typeNode);
-        }
-        const operationTypes = __spreadValues(
-          __spreadValues(
-            {
-              query: schemaConfig.query && replaceNamedType(schemaConfig.query),
-              mutation:
-                schemaConfig.mutation &&
-                replaceNamedType(schemaConfig.mutation),
-              subscription:
-                schemaConfig.subscription &&
-                replaceNamedType(schemaConfig.subscription),
-            },
-            schemaDef && getOperationTypes([schemaDef])
-          ),
-          getOperationTypes(schemaExtensions)
-        );
-        return __spreadProps(
-          __spreadValues(
-            {
-              description:
-                (_schemaDef = schemaDef) === null || _schemaDef === void 0
-                  ? void 0
-                  : (_schemaDef$descriptio = _schemaDef.description) === null ||
-                    _schemaDef$descriptio === void 0
-                  ? void 0
-                  : _schemaDef$descriptio.value,
-            },
-            operationTypes
-          ),
-          {
-            types: Object.values(typeMap),
-            directives: [
-              ...schemaConfig.directives.map(replaceDirective),
-              ...directiveDefs.map(buildDirective),
-            ],
-            extensions: /* @__PURE__ */ Object.create(null),
-            astNode:
-              (_schemaDef2 = schemaDef) !== null && _schemaDef2 !== void 0
-                ? _schemaDef2
-                : schemaConfig.astNode,
-            extensionASTNodes:
-              schemaConfig.extensionASTNodes.concat(schemaExtensions),
-            assumeValid:
-              (_options$assumeValid =
-                options === null || options === void 0
-                  ? void 0
-                  : options.assumeValid) !== null &&
-              _options$assumeValid !== void 0
-                ? _options$assumeValid
-                : false,
-          }
-        );
-        function replaceType(type2) {
-          if (isListType(type2)) {
-            return new GraphQLList(replaceType(type2.ofType));
-          }
-          if (isNonNullType(type2)) {
-            return new GraphQLNonNull(replaceType(type2.ofType));
-          }
-          return replaceNamedType(type2);
-        }
-        function replaceNamedType(type2) {
-          return typeMap[type2.name];
-        }
-        function replaceDirective(directive) {
-          const config2 = directive.toConfig();
-          return new GraphQLDirective(
-            __spreadProps(__spreadValues({}, config2), {
-              args: mapValue(config2.args, extendArg),
-            })
-          );
-        }
-        function extendNamedType(type2) {
-          if (isIntrospectionType(type2) || isSpecifiedScalarType(type2)) {
-            return type2;
-          }
-          if (isScalarType(type2)) {
-            return extendScalarType(type2);
-          }
-          if (isObjectType(type2)) {
-            return extendObjectType(type2);
-          }
-          if (isInterfaceType(type2)) {
-            return extendInterfaceType(type2);
-          }
-          if (isUnionType(type2)) {
-            return extendUnionType(type2);
-          }
-          if (isEnumType(type2)) {
-            return extendEnumType(type2);
-          }
-          if (isInputObjectType(type2)) {
-            return extendInputObjectType(type2);
-          }
-          invariant$2(false, "Unexpected type: " + inspect$2(type2));
-        }
-        function extendInputObjectType(type2) {
-          var _typeExtensionsMap$co;
-          const config2 = type2.toConfig();
-          const extensions =
-            (_typeExtensionsMap$co = typeExtensionsMap[config2.name]) !==
-              null && _typeExtensionsMap$co !== void 0
-              ? _typeExtensionsMap$co
-              : [];
-          return new GraphQLInputObjectType(
-            __spreadProps(__spreadValues({}, config2), {
-              fields: () =>
-                __spreadValues(
-                  __spreadValues(
-                    {},
-                    mapValue(config2.fields, (field) =>
-                      __spreadProps(__spreadValues({}, field), {
-                        type: replaceType(field.type),
-                      })
-                    )
-                  ),
-                  buildInputFieldMap(extensions)
-                ),
-              extensionASTNodes: config2.extensionASTNodes.concat(extensions),
-            })
-          );
-        }
-        function extendEnumType(type2) {
-          var _typeExtensionsMap$ty;
-          const config2 = type2.toConfig();
-          const extensions =
-            (_typeExtensionsMap$ty = typeExtensionsMap[type2.name]) !== null &&
-            _typeExtensionsMap$ty !== void 0
-              ? _typeExtensionsMap$ty
-              : [];
-          return new GraphQLEnumType(
-            __spreadProps(__spreadValues({}, config2), {
-              values: __spreadValues(
-                __spreadValues({}, config2.values),
-                buildEnumValueMap(extensions)
-              ),
-              extensionASTNodes: config2.extensionASTNodes.concat(extensions),
-            })
-          );
-        }
-        function extendScalarType(type2) {
-          var _typeExtensionsMap$co2;
-          const config2 = type2.toConfig();
-          const extensions =
-            (_typeExtensionsMap$co2 = typeExtensionsMap[config2.name]) !==
-              null && _typeExtensionsMap$co2 !== void 0
-              ? _typeExtensionsMap$co2
-              : [];
-          let specifiedByURL = config2.specifiedByURL;
-          for (const extensionNode of extensions) {
-            var _getSpecifiedByURL;
-            specifiedByURL =
-              (_getSpecifiedByURL = getSpecifiedByURL(extensionNode)) !==
-                null && _getSpecifiedByURL !== void 0
-                ? _getSpecifiedByURL
-                : specifiedByURL;
-          }
-          return new GraphQLScalarType(
-            __spreadProps(__spreadValues({}, config2), {
-              specifiedByURL,
-              extensionASTNodes: config2.extensionASTNodes.concat(extensions),
-            })
-          );
-        }
-        function extendObjectType(type2) {
-          var _typeExtensionsMap$co3;
-          const config2 = type2.toConfig();
-          const extensions =
-            (_typeExtensionsMap$co3 = typeExtensionsMap[config2.name]) !==
-              null && _typeExtensionsMap$co3 !== void 0
-              ? _typeExtensionsMap$co3
-              : [];
-          return new GraphQLObjectType(
-            __spreadProps(__spreadValues({}, config2), {
-              interfaces: () => [
-                ...type2.getInterfaces().map(replaceNamedType),
-                ...buildInterfaces(extensions),
-              ],
-              fields: () =>
-                __spreadValues(
-                  __spreadValues({}, mapValue(config2.fields, extendField)),
-                  buildFieldMap(extensions)
-                ),
-              extensionASTNodes: config2.extensionASTNodes.concat(extensions),
-            })
-          );
-        }
-        function extendInterfaceType(type2) {
-          var _typeExtensionsMap$co4;
-          const config2 = type2.toConfig();
-          const extensions =
-            (_typeExtensionsMap$co4 = typeExtensionsMap[config2.name]) !==
-              null && _typeExtensionsMap$co4 !== void 0
-              ? _typeExtensionsMap$co4
-              : [];
-          return new GraphQLInterfaceType(
-            __spreadProps(__spreadValues({}, config2), {
-              interfaces: () => [
-                ...type2.getInterfaces().map(replaceNamedType),
-                ...buildInterfaces(extensions),
-              ],
-              fields: () =>
-                __spreadValues(
-                  __spreadValues({}, mapValue(config2.fields, extendField)),
-                  buildFieldMap(extensions)
-                ),
-              extensionASTNodes: config2.extensionASTNodes.concat(extensions),
-            })
-          );
-        }
-        function extendUnionType(type2) {
-          var _typeExtensionsMap$co5;
-          const config2 = type2.toConfig();
-          const extensions =
-            (_typeExtensionsMap$co5 = typeExtensionsMap[config2.name]) !==
-              null && _typeExtensionsMap$co5 !== void 0
-              ? _typeExtensionsMap$co5
-              : [];
-          return new GraphQLUnionType(
-            __spreadProps(__spreadValues({}, config2), {
-              types: () => [
-                ...type2.getTypes().map(replaceNamedType),
-                ...buildUnionTypes(extensions),
-              ],
-              extensionASTNodes: config2.extensionASTNodes.concat(extensions),
-            })
-          );
-        }
-        function extendField(field) {
-          return __spreadProps(__spreadValues({}, field), {
-            type: replaceType(field.type),
-            args: field.args && mapValue(field.args, extendArg),
-          });
-        }
-        function extendArg(arg) {
-          return __spreadProps(__spreadValues({}, arg), {
-            type: replaceType(arg.type),
-          });
-        }
-        function getOperationTypes(nodes) {
-          const opTypes = {};
-          for (const node of nodes) {
-            var _node$operationTypes;
-            const operationTypesNodes =
-              (_node$operationTypes = node.operationTypes) !== null &&
-              _node$operationTypes !== void 0
-                ? _node$operationTypes
-                : [];
-            for (const operationType of operationTypesNodes) {
-              opTypes[operationType.operation] = getNamedType2(
-                operationType.type
-              );
-            }
-          }
-          return opTypes;
-        }
-        function getNamedType2(node) {
-          var _stdTypeMap$name2;
-          const name2 = node.name.value;
-          const type2 =
-            (_stdTypeMap$name2 = stdTypeMap[name2]) !== null &&
-            _stdTypeMap$name2 !== void 0
-              ? _stdTypeMap$name2
-              : typeMap[name2];
-          if (type2 === void 0) {
-            throw new Error(`Unknown type: "${name2}".`);
-          }
-          return type2;
-        }
-        function getWrappedType(node) {
-          if (node.kind === Kind.LIST_TYPE) {
-            return new GraphQLList(getWrappedType(node.type));
-          }
-          if (node.kind === Kind.NON_NULL_TYPE) {
-            return new GraphQLNonNull(getWrappedType(node.type));
-          }
-          return getNamedType2(node);
-        }
-        function buildDirective(node) {
-          var _node$description;
-          return new GraphQLDirective({
-            name: node.name.value,
-            description:
-              (_node$description = node.description) === null ||
-              _node$description === void 0
-                ? void 0
-                : _node$description.value,
-            locations: node.locations.map(({ value }) => value),
-            isRepeatable: node.repeatable,
-            args: buildArgumentMap(node.arguments),
-            astNode: node,
-          });
-        }
-        function buildFieldMap(nodes) {
-          const fieldConfigMap = /* @__PURE__ */ Object.create(null);
-          for (const node of nodes) {
-            var _node$fields;
-            const nodeFields =
-              (_node$fields = node.fields) !== null && _node$fields !== void 0
-                ? _node$fields
-                : [];
-            for (const field of nodeFields) {
-              var _field$description;
-              fieldConfigMap[field.name.value] = {
-                type: getWrappedType(field.type),
-                description:
-                  (_field$description = field.description) === null ||
-                  _field$description === void 0
-                    ? void 0
-                    : _field$description.value,
-                args: buildArgumentMap(field.arguments),
-                deprecationReason: getDeprecationReason(field),
-                astNode: field,
-              };
-            }
-          }
-          return fieldConfigMap;
-        }
-        function buildArgumentMap(args) {
-          const argsNodes = args !== null && args !== void 0 ? args : [];
-          const argConfigMap = /* @__PURE__ */ Object.create(null);
-          for (const arg of argsNodes) {
-            var _arg$description;
-            const type2 = getWrappedType(arg.type);
-            argConfigMap[arg.name.value] = {
-              type: type2,
-              description:
-                (_arg$description = arg.description) === null ||
-                _arg$description === void 0
-                  ? void 0
-                  : _arg$description.value,
-              defaultValue: valueFromAST$1(arg.defaultValue, type2),
-              deprecationReason: getDeprecationReason(arg),
-              astNode: arg,
-            };
-          }
-          return argConfigMap;
-        }
-        function buildInputFieldMap(nodes) {
-          const inputFieldMap = /* @__PURE__ */ Object.create(null);
-          for (const node of nodes) {
-            var _node$fields2;
-            const fieldsNodes =
-              (_node$fields2 = node.fields) !== null && _node$fields2 !== void 0
-                ? _node$fields2
-                : [];
-            for (const field of fieldsNodes) {
-              var _field$description2;
-              const type2 = getWrappedType(field.type);
-              inputFieldMap[field.name.value] = {
-                type: type2,
-                description:
-                  (_field$description2 = field.description) === null ||
-                  _field$description2 === void 0
-                    ? void 0
-                    : _field$description2.value,
-                defaultValue: valueFromAST$1(field.defaultValue, type2),
-                deprecationReason: getDeprecationReason(field),
-                astNode: field,
-              };
-            }
-          }
-          return inputFieldMap;
-        }
-        function buildEnumValueMap(nodes) {
-          const enumValueMap = /* @__PURE__ */ Object.create(null);
-          for (const node of nodes) {
-            var _node$values;
-            const valuesNodes =
-              (_node$values = node.values) !== null && _node$values !== void 0
-                ? _node$values
-                : [];
-            for (const value of valuesNodes) {
-              var _value$description;
-              enumValueMap[value.name.value] = {
-                description:
-                  (_value$description = value.description) === null ||
-                  _value$description === void 0
-                    ? void 0
-                    : _value$description.value,
-                deprecationReason: getDeprecationReason(value),
-                astNode: value,
-              };
-            }
-          }
-          return enumValueMap;
-        }
-        function buildInterfaces(nodes) {
-          return nodes.flatMap((node) => {
-            var _node$interfaces$map, _node$interfaces;
-            return (_node$interfaces$map =
-              (_node$interfaces = node.interfaces) === null ||
-              _node$interfaces === void 0
-                ? void 0
-                : _node$interfaces.map(getNamedType2)) !== null &&
-              _node$interfaces$map !== void 0
-              ? _node$interfaces$map
-              : [];
-          });
-        }
-        function buildUnionTypes(nodes) {
-          return nodes.flatMap((node) => {
-            var _node$types$map, _node$types;
-            return (_node$types$map =
-              (_node$types = node.types) === null || _node$types === void 0
-                ? void 0
-                : _node$types.map(getNamedType2)) !== null &&
-              _node$types$map !== void 0
-              ? _node$types$map
-              : [];
-          });
-        }
-        function buildType(astNode) {
-          var _typeExtensionsMap$na;
-          const name2 = astNode.name.value;
-          const extensionASTNodes =
-            (_typeExtensionsMap$na = typeExtensionsMap[name2]) !== null &&
-            _typeExtensionsMap$na !== void 0
-              ? _typeExtensionsMap$na
-              : [];
-          switch (astNode.kind) {
-            case Kind.OBJECT_TYPE_DEFINITION: {
-              var _astNode$description;
-              const allNodes = [astNode, ...extensionASTNodes];
-              return new GraphQLObjectType({
-                name: name2,
-                description:
-                  (_astNode$description = astNode.description) === null ||
-                  _astNode$description === void 0
-                    ? void 0
-                    : _astNode$description.value,
-                interfaces: () => buildInterfaces(allNodes),
-                fields: () => buildFieldMap(allNodes),
-                astNode,
-                extensionASTNodes,
-              });
-            }
-            case Kind.INTERFACE_TYPE_DEFINITION: {
-              var _astNode$description2;
-              const allNodes = [astNode, ...extensionASTNodes];
-              return new GraphQLInterfaceType({
-                name: name2,
-                description:
-                  (_astNode$description2 = astNode.description) === null ||
-                  _astNode$description2 === void 0
-                    ? void 0
-                    : _astNode$description2.value,
-                interfaces: () => buildInterfaces(allNodes),
-                fields: () => buildFieldMap(allNodes),
-                astNode,
-                extensionASTNodes,
-              });
-            }
-            case Kind.ENUM_TYPE_DEFINITION: {
-              var _astNode$description3;
-              const allNodes = [astNode, ...extensionASTNodes];
-              return new GraphQLEnumType({
-                name: name2,
-                description:
-                  (_astNode$description3 = astNode.description) === null ||
-                  _astNode$description3 === void 0
-                    ? void 0
-                    : _astNode$description3.value,
-                values: buildEnumValueMap(allNodes),
-                astNode,
-                extensionASTNodes,
-              });
-            }
-            case Kind.UNION_TYPE_DEFINITION: {
-              var _astNode$description4;
-              const allNodes = [astNode, ...extensionASTNodes];
-              return new GraphQLUnionType({
-                name: name2,
-                description:
-                  (_astNode$description4 = astNode.description) === null ||
-                  _astNode$description4 === void 0
-                    ? void 0
-                    : _astNode$description4.value,
-                types: () => buildUnionTypes(allNodes),
-                astNode,
-                extensionASTNodes,
-              });
-            }
-            case Kind.SCALAR_TYPE_DEFINITION: {
-              var _astNode$description5;
-              return new GraphQLScalarType({
-                name: name2,
-                description:
-                  (_astNode$description5 = astNode.description) === null ||
-                  _astNode$description5 === void 0
-                    ? void 0
-                    : _astNode$description5.value,
-                specifiedByURL: getSpecifiedByURL(astNode),
-                astNode,
-                extensionASTNodes,
-              });
-            }
-            case Kind.INPUT_OBJECT_TYPE_DEFINITION: {
-              var _astNode$description6;
-              const allNodes = [astNode, ...extensionASTNodes];
-              return new GraphQLInputObjectType({
-                name: name2,
-                description:
-                  (_astNode$description6 = astNode.description) === null ||
-                  _astNode$description6 === void 0
-                    ? void 0
-                    : _astNode$description6.value,
-                fields: () => buildInputFieldMap(allNodes),
-                astNode,
-                extensionASTNodes,
-              });
-            }
-          }
-        }
-      }
-      const stdTypeMap = keyMap$1(
-        [...specifiedScalarTypes, ...introspectionTypes$1],
-        (type2) => type2.name
-      );
-      function getDeprecationReason(node) {
-        const deprecated = getDirectiveValues$1(
-          GraphQLDeprecatedDirective,
-          node
-        );
-        return deprecated === null || deprecated === void 0
-          ? void 0
-          : deprecated.reason;
-      }
-      function getSpecifiedByURL(node) {
-        const specifiedBy = getDirectiveValues$1(
-          GraphQLSpecifiedByDirective,
-          node
-        );
-        return specifiedBy === null || specifiedBy === void 0
-          ? void 0
-          : specifiedBy.url;
-      }
-      function buildASTSchema(documentAST, options) {
-        (documentAST != null && documentAST.kind === Kind.DOCUMENT) ||
-          devAssert$1(false, "Must provide valid Document AST.");
-        if (
-          (options === null || options === void 0
-            ? void 0
-            : options.assumeValid) !== true &&
-          (options === null || options === void 0
-            ? void 0
-            : options.assumeValidSDL) !== true
-        ) {
-          assertValidSDL(documentAST);
-        }
-        const emptySchemaConfig = {
-          description: void 0,
-          types: [],
-          directives: [],
-          extensions: /* @__PURE__ */ Object.create(null),
-          extensionASTNodes: [],
-          assumeValid: false,
-        };
-        const config2 = extendSchemaImpl(
-          emptySchemaConfig,
-          documentAST,
-          options
-        );
-        if (config2.astNode == null) {
-          for (const type2 of config2.types) {
-            switch (type2.name) {
-              case "Query":
-                config2.query = type2;
-                break;
-              case "Mutation":
-                config2.mutation = type2;
-                break;
-              case "Subscription":
-                config2.subscription = type2;
-                break;
-            }
-          }
-        }
-        const directives = [
-          ...config2.directives,
-          ...specifiedDirectives.filter((stdDirective) =>
-            config2.directives.every(
-              (directive) => directive.name !== stdDirective.name
-            )
-          ),
-        ];
-        return new GraphQLSchema(
-          __spreadProps(__spreadValues({}, config2), { directives })
-        );
-      }
-      function buildSchema(source, options) {
-        const document2 = parse$1(source, {
-          noLocation:
-            options === null || options === void 0
-              ? void 0
-              : options.noLocation,
-          allowLegacyFragmentVariables:
-            options === null || options === void 0
-              ? void 0
-              : options.allowLegacyFragmentVariables,
-        });
-        return buildASTSchema(document2, {
-          assumeValidSDL:
-            options === null || options === void 0
-              ? void 0
-              : options.assumeValidSDL,
-          assumeValid:
-            options === null || options === void 0
-              ? void 0
-              : options.assumeValid,
-        });
-      }
-      function lexicographicSortSchema(schema) {
-        const schemaConfig = schema.toConfig();
-        const typeMap = keyValMap(
-          sortByName(schemaConfig.types),
-          (type2) => type2.name,
-          sortNamedType
-        );
-        return new GraphQLSchema(
-          __spreadProps(__spreadValues({}, schemaConfig), {
-            types: Object.values(typeMap),
-            directives: sortByName(schemaConfig.directives).map(sortDirective),
-            query: replaceMaybeType(schemaConfig.query),
-            mutation: replaceMaybeType(schemaConfig.mutation),
-            subscription: replaceMaybeType(schemaConfig.subscription),
-          })
-        );
-        function replaceType(type2) {
-          if (isListType(type2)) {
-            return new GraphQLList(replaceType(type2.ofType));
-          } else if (isNonNullType(type2)) {
-            return new GraphQLNonNull(replaceType(type2.ofType));
-          }
-          return replaceNamedType(type2);
-        }
-        function replaceNamedType(type2) {
-          return typeMap[type2.name];
-        }
-        function replaceMaybeType(maybeType) {
-          return maybeType && replaceNamedType(maybeType);
-        }
-        function sortDirective(directive) {
-          const config2 = directive.toConfig();
-          return new GraphQLDirective(
-            __spreadProps(__spreadValues({}, config2), {
-              locations: sortBy(config2.locations, (x2) => x2),
-              args: sortArgs(config2.args),
-            })
-          );
-        }
-        function sortArgs(args) {
-          return sortObjMap(args, (arg) =>
-            __spreadProps(__spreadValues({}, arg), {
-              type: replaceType(arg.type),
-            })
-          );
-        }
-        function sortFields2(fieldsMap) {
-          return sortObjMap(fieldsMap, (field) =>
-            __spreadProps(__spreadValues({}, field), {
-              type: replaceType(field.type),
-              args: field.args && sortArgs(field.args),
-            })
-          );
-        }
-        function sortInputFields(fieldsMap) {
-          return sortObjMap(fieldsMap, (field) =>
-            __spreadProps(__spreadValues({}, field), {
-              type: replaceType(field.type),
-            })
-          );
-        }
-        function sortTypes(array) {
-          return sortByName(array).map(replaceNamedType);
-        }
-        function sortNamedType(type2) {
-          if (isScalarType(type2) || isIntrospectionType(type2)) {
-            return type2;
-          }
-          if (isObjectType(type2)) {
-            const config2 = type2.toConfig();
-            return new GraphQLObjectType(
-              __spreadProps(__spreadValues({}, config2), {
-                interfaces: () => sortTypes(config2.interfaces),
-                fields: () => sortFields2(config2.fields),
-              })
-            );
-          }
-          if (isInterfaceType(type2)) {
-            const config2 = type2.toConfig();
-            return new GraphQLInterfaceType(
-              __spreadProps(__spreadValues({}, config2), {
-                interfaces: () => sortTypes(config2.interfaces),
-                fields: () => sortFields2(config2.fields),
-              })
-            );
-          }
-          if (isUnionType(type2)) {
-            const config2 = type2.toConfig();
-            return new GraphQLUnionType(
-              __spreadProps(__spreadValues({}, config2), {
-                types: () => sortTypes(config2.types),
-              })
-            );
-          }
-          if (isEnumType(type2)) {
-            const config2 = type2.toConfig();
-            return new GraphQLEnumType(
-              __spreadProps(__spreadValues({}, config2), {
-                values: sortObjMap(config2.values, (value) => value),
-              })
-            );
-          }
-          if (isInputObjectType(type2)) {
-            const config2 = type2.toConfig();
-            return new GraphQLInputObjectType(
-              __spreadProps(__spreadValues({}, config2), {
-                fields: () => sortInputFields(config2.fields),
-              })
-            );
-          }
-          invariant$2(false, "Unexpected type: " + inspect$2(type2));
-        }
-      }
-      function sortObjMap(map2, sortValueFn) {
-        const sortedMap = /* @__PURE__ */ Object.create(null);
-        for (const key of Object.keys(map2).sort(naturalCompare$1)) {
-          sortedMap[key] = sortValueFn(map2[key]);
-        }
-        return sortedMap;
-      }
-      function sortByName(array) {
-        return sortBy(array, (obj) => obj.name);
-      }
-      function sortBy(array, mapToKey) {
-        return array.slice().sort((obj1, obj2) => {
-          const key1 = mapToKey(obj1);
-          const key2 = mapToKey(obj2);
-          return naturalCompare$1(key1, key2);
-        });
-      }
-      function printSchema(schema) {
-        return printFilteredSchema(
-          schema,
-          (n2) => !isSpecifiedDirective(n2),
-          isDefinedType
-        );
-      }
-      function printIntrospectionSchema(schema) {
-        return printFilteredSchema(
-          schema,
-          isSpecifiedDirective,
-          isIntrospectionType
-        );
-      }
-      function isDefinedType(type2) {
-        return !isSpecifiedScalarType(type2) && !isIntrospectionType(type2);
-      }
-      function printFilteredSchema(schema, directiveFilter, typeFilter) {
-        const directives = schema.getDirectives().filter(directiveFilter);
-        const types = Object.values(schema.getTypeMap()).filter(typeFilter);
-        return [
-          printSchemaDefinition(schema),
-          ...directives.map((directive) => printDirective(directive)),
-          ...types.map((type2) => printType(type2)),
-        ]
-          .filter(Boolean)
-          .join("\n\n");
-      }
-      function printSchemaDefinition(schema) {
-        if (schema.description == null && isSchemaOfCommonNames(schema)) {
-          return;
-        }
-        const operationTypes = [];
-        const queryType = schema.getQueryType();
-        if (queryType) {
-          operationTypes.push(`  query: ${queryType.name}`);
-        }
-        const mutationType = schema.getMutationType();
-        if (mutationType) {
-          operationTypes.push(`  mutation: ${mutationType.name}`);
-        }
-        const subscriptionType = schema.getSubscriptionType();
-        if (subscriptionType) {
-          operationTypes.push(`  subscription: ${subscriptionType.name}`);
-        }
-        return (
-          printDescription(schema) +
-          `schema {
-${operationTypes.join("\n")}
-}`
-        );
-      }
-      function isSchemaOfCommonNames(schema) {
-        const queryType = schema.getQueryType();
-        if (queryType && queryType.name !== "Query") {
-          return false;
-        }
-        const mutationType = schema.getMutationType();
-        if (mutationType && mutationType.name !== "Mutation") {
-          return false;
-        }
-        const subscriptionType = schema.getSubscriptionType();
-        if (subscriptionType && subscriptionType.name !== "Subscription") {
-          return false;
-        }
-        return true;
-      }
-      function printType(type2) {
-        if (isScalarType(type2)) {
-          return printScalar(type2);
-        }
-        if (isObjectType(type2)) {
-          return printObject(type2);
-        }
-        if (isInterfaceType(type2)) {
-          return printInterface(type2);
-        }
-        if (isUnionType(type2)) {
-          return printUnion(type2);
-        }
-        if (isEnumType(type2)) {
-          return printEnum(type2);
-        }
-        if (isInputObjectType(type2)) {
-          return printInputObject(type2);
-        }
-        invariant$2(false, "Unexpected type: " + inspect$2(type2));
-      }
-      function printScalar(type2) {
-        return (
-          printDescription(type2) +
-          `scalar ${type2.name}` +
-          printSpecifiedByURL(type2)
-        );
-      }
-      function printImplementedInterfaces(type2) {
-        const interfaces = type2.getInterfaces();
-        return interfaces.length
-          ? " implements " + interfaces.map((i) => i.name).join(" & ")
-          : "";
-      }
-      function printObject(type2) {
-        return (
-          printDescription(type2) +
-          `type ${type2.name}` +
-          printImplementedInterfaces(type2) +
-          printFields(type2)
-        );
-      }
-      function printInterface(type2) {
-        return (
-          printDescription(type2) +
-          `interface ${type2.name}` +
-          printImplementedInterfaces(type2) +
-          printFields(type2)
-        );
-      }
-      function printUnion(type2) {
-        const types = type2.getTypes();
-        const possibleTypes = types.length ? " = " + types.join(" | ") : "";
-        return printDescription(type2) + "union " + type2.name + possibleTypes;
-      }
-      function printEnum(type2) {
-        const values = type2
-          .getValues()
-          .map(
-            (value, i) =>
-              printDescription(value, "  ", !i) +
-              "  " +
-              value.name +
-              printDeprecated(value.deprecationReason)
-          );
-        return (
-          printDescription(type2) + `enum ${type2.name}` + printBlock(values)
-        );
-      }
-      function printInputObject(type2) {
-        const fields = Object.values(type2.getFields()).map(
-          (f, i) => printDescription(f, "  ", !i) + "  " + printInputValue(f)
-        );
-        return (
-          printDescription(type2) + `input ${type2.name}` + printBlock(fields)
-        );
-      }
-      function printFields(type2) {
-        const fields = Object.values(type2.getFields()).map(
-          (f, i) =>
-            printDescription(f, "  ", !i) +
-            "  " +
-            f.name +
-            printArgs(f.args, "  ") +
-            ": " +
-            String(f.type) +
-            printDeprecated(f.deprecationReason)
-        );
-        return printBlock(fields);
-      }
-      function printBlock(items) {
-        return items.length !== 0 ? " {\n" + items.join("\n") + "\n}" : "";
-      }
-      function printArgs(args, indentation = "") {
-        if (args.length === 0) {
-          return "";
-        }
-        if (args.every((arg) => !arg.description)) {
-          return "(" + args.map(printInputValue).join(", ") + ")";
-        }
-        return (
-          "(\n" +
-          args
-            .map(
-              (arg, i) =>
-                printDescription(arg, "  " + indentation, !i) +
-                "  " +
-                indentation +
-                printInputValue(arg)
-            )
-            .join("\n") +
-          "\n" +
-          indentation +
-          ")"
-        );
-      }
-      function printInputValue(arg) {
-        const defaultAST = astFromValue(arg.defaultValue, arg.type);
-        let argDecl = arg.name + ": " + String(arg.type);
-        if (defaultAST) {
-          argDecl += ` = ${print(defaultAST)}`;
-        }
-        return argDecl + printDeprecated(arg.deprecationReason);
-      }
-      function printDirective(directive) {
-        return (
-          printDescription(directive) +
-          "directive @" +
-          directive.name +
-          printArgs(directive.args) +
-          (directive.isRepeatable ? " repeatable" : "") +
-          " on " +
-          directive.locations.join(" | ")
-        );
-      }
-      function printDeprecated(reason) {
-        if (reason == null) {
-          return "";
-        }
-        if (reason !== DEFAULT_DEPRECATION_REASON) {
-          const astValue = print({
-            kind: Kind.STRING,
-            value: reason,
-          });
-          return ` @deprecated(reason: ${astValue})`;
-        }
-        return " @deprecated";
-      }
-      function printSpecifiedByURL(scalar) {
-        if (scalar.specifiedByURL == null) {
-          return "";
-        }
-        const astValue = print({
-          kind: Kind.STRING,
-          value: scalar.specifiedByURL,
-        });
-        return ` @specifiedBy(url: ${astValue})`;
-      }
-      function printDescription(def, indentation = "", firstInBlock = true) {
-        const { description } = def;
-        if (description == null) {
-          return "";
-        }
-        const blockString = print({
-          kind: Kind.STRING,
-          value: description,
-          block: isPrintableAsBlockString(description),
-        });
-        const prefix =
-          indentation && !firstInBlock ? "\n" + indentation : indentation;
-        return prefix + blockString.replace(/\n/g, "\n" + indentation) + "\n";
-      }
-      function concatAST(documents) {
-        const definitions = [];
-        for (const doc of documents) {
-          definitions.push(...doc.definitions);
-        }
-        return {
-          kind: Kind.DOCUMENT,
-          definitions,
-        };
-      }
-      function separateOperations(documentAST) {
-        const operations = [];
-        const depGraph = /* @__PURE__ */ Object.create(null);
-        for (const definitionNode of documentAST.definitions) {
-          switch (definitionNode.kind) {
-            case Kind.OPERATION_DEFINITION:
-              operations.push(definitionNode);
-              break;
-            case Kind.FRAGMENT_DEFINITION:
-              depGraph[definitionNode.name.value] = collectDependencies(
-                definitionNode.selectionSet
-              );
-              break;
-          }
-        }
-        const separatedDocumentASTs = /* @__PURE__ */ Object.create(null);
-        for (const operation of operations) {
-          const dependencies = /* @__PURE__ */ new Set();
-          for (const fragmentName of collectDependencies(
-            operation.selectionSet
-          )) {
-            collectTransitiveDependencies(dependencies, depGraph, fragmentName);
-          }
-          const operationName = operation.name ? operation.name.value : "";
-          separatedDocumentASTs[operationName] = {
-            kind: Kind.DOCUMENT,
-            definitions: documentAST.definitions.filter(
-              (node) =>
-                node === operation ||
-                (node.kind === Kind.FRAGMENT_DEFINITION &&
-                  dependencies.has(node.name.value))
-            ),
-          };
-        }
-        return separatedDocumentASTs;
-      }
-      function collectTransitiveDependencies(collected, depGraph, fromName) {
-        if (!collected.has(fromName)) {
-          collected.add(fromName);
-          const immediateDeps = depGraph[fromName];
-          if (immediateDeps !== void 0) {
-            for (const toName of immediateDeps) {
-              collectTransitiveDependencies(collected, depGraph, toName);
-            }
-          }
-        }
-      }
-      function collectDependencies(selectionSet) {
-        const dependencies = [];
-        visit(selectionSet, {
-          FragmentSpread(node) {
-            dependencies.push(node.name.value);
-          },
-        });
-        return dependencies;
-      }
-      function stripIgnoredCharacters(source) {
-        const sourceObj = isSource(source) ? source : new Source(source);
-        const body = sourceObj.body;
-        const lexer = new Lexer(sourceObj);
-        let strippedBody = "";
-        let wasLastAddedTokenNonPunctuator = false;
-        while (lexer.advance().kind !== TokenKind.EOF) {
-          const currentToken = lexer.token;
-          const tokenKind = currentToken.kind;
-          const isNonPunctuator = !isPunctuatorTokenKind(currentToken.kind);
-          if (wasLastAddedTokenNonPunctuator) {
-            if (isNonPunctuator || currentToken.kind === TokenKind.SPREAD) {
-              strippedBody += " ";
-            }
-          }
-          const tokenBody = body.slice(currentToken.start, currentToken.end);
-          if (tokenKind === TokenKind.BLOCK_STRING) {
-            strippedBody += printBlockString$1(currentToken.value, {
-              minimize: true,
-            });
-          } else {
-            strippedBody += tokenBody;
-          }
-          wasLastAddedTokenNonPunctuator = isNonPunctuator;
-        }
-        return strippedBody;
-      }
-      function assertValidName(name2) {
-        const error2 = isValidNameError(name2);
-        if (error2) {
-          throw error2;
-        }
-        return name2;
-      }
-      function isValidNameError(name2) {
-        typeof name2 === "string" ||
-          devAssert$1(false, "Expected name to be a string.");
-        if (name2.startsWith("__")) {
-          return new GraphQLError(
-            `Name "${name2}" must not begin with "__", which is reserved by GraphQL introspection.`
-          );
-        }
-        try {
-          assertName(name2);
-        } catch (error2) {
-          return error2;
-        }
-      }
-      let BreakingChangeType;
-      (function (BreakingChangeType2) {
-        BreakingChangeType2["TYPE_REMOVED"] = "TYPE_REMOVED";
-        BreakingChangeType2["TYPE_CHANGED_KIND"] = "TYPE_CHANGED_KIND";
-        BreakingChangeType2["TYPE_REMOVED_FROM_UNION"] =
-          "TYPE_REMOVED_FROM_UNION";
-        BreakingChangeType2["VALUE_REMOVED_FROM_ENUM"] =
-          "VALUE_REMOVED_FROM_ENUM";
-        BreakingChangeType2["REQUIRED_INPUT_FIELD_ADDED"] =
-          "REQUIRED_INPUT_FIELD_ADDED";
-        BreakingChangeType2["IMPLEMENTED_INTERFACE_REMOVED"] =
-          "IMPLEMENTED_INTERFACE_REMOVED";
-        BreakingChangeType2["FIELD_REMOVED"] = "FIELD_REMOVED";
-        BreakingChangeType2["FIELD_CHANGED_KIND"] = "FIELD_CHANGED_KIND";
-        BreakingChangeType2["REQUIRED_ARG_ADDED"] = "REQUIRED_ARG_ADDED";
-        BreakingChangeType2["ARG_REMOVED"] = "ARG_REMOVED";
-        BreakingChangeType2["ARG_CHANGED_KIND"] = "ARG_CHANGED_KIND";
-        BreakingChangeType2["DIRECTIVE_REMOVED"] = "DIRECTIVE_REMOVED";
-        BreakingChangeType2["DIRECTIVE_ARG_REMOVED"] = "DIRECTIVE_ARG_REMOVED";
-        BreakingChangeType2["REQUIRED_DIRECTIVE_ARG_ADDED"] =
-          "REQUIRED_DIRECTIVE_ARG_ADDED";
-        BreakingChangeType2["DIRECTIVE_REPEATABLE_REMOVED"] =
-          "DIRECTIVE_REPEATABLE_REMOVED";
-        BreakingChangeType2["DIRECTIVE_LOCATION_REMOVED"] =
-          "DIRECTIVE_LOCATION_REMOVED";
-      })(BreakingChangeType || (BreakingChangeType = {}));
-      let DangerousChangeType;
-      (function (DangerousChangeType2) {
-        DangerousChangeType2["VALUE_ADDED_TO_ENUM"] = "VALUE_ADDED_TO_ENUM";
-        DangerousChangeType2["TYPE_ADDED_TO_UNION"] = "TYPE_ADDED_TO_UNION";
-        DangerousChangeType2["OPTIONAL_INPUT_FIELD_ADDED"] =
-          "OPTIONAL_INPUT_FIELD_ADDED";
-        DangerousChangeType2["OPTIONAL_ARG_ADDED"] = "OPTIONAL_ARG_ADDED";
-        DangerousChangeType2["IMPLEMENTED_INTERFACE_ADDED"] =
-          "IMPLEMENTED_INTERFACE_ADDED";
-        DangerousChangeType2["ARG_DEFAULT_VALUE_CHANGE"] =
-          "ARG_DEFAULT_VALUE_CHANGE";
-      })(DangerousChangeType || (DangerousChangeType = {}));
-      function findBreakingChanges(oldSchema, newSchema) {
-        return findSchemaChanges(oldSchema, newSchema).filter(
-          (change) => change.type in BreakingChangeType
-        );
-      }
-      function findDangerousChanges(oldSchema, newSchema) {
-        return findSchemaChanges(oldSchema, newSchema).filter(
-          (change) => change.type in DangerousChangeType
-        );
-      }
-      function findSchemaChanges(oldSchema, newSchema) {
-        return [
-          ...findTypeChanges(oldSchema, newSchema),
-          ...findDirectiveChanges(oldSchema, newSchema),
-        ];
-      }
-      function findDirectiveChanges(oldSchema, newSchema) {
-        const schemaChanges = [];
-        const directivesDiff = diff(
-          oldSchema.getDirectives(),
-          newSchema.getDirectives()
-        );
-        for (const oldDirective of directivesDiff.removed) {
-          schemaChanges.push({
-            type: BreakingChangeType.DIRECTIVE_REMOVED,
-            description: `${oldDirective.name} was removed.`,
-          });
-        }
-        for (const [oldDirective, newDirective] of directivesDiff.persisted) {
-          const argsDiff = diff(oldDirective.args, newDirective.args);
-          for (const newArg of argsDiff.added) {
-            if (isRequiredArgument$1(newArg)) {
-              schemaChanges.push({
-                type: BreakingChangeType.REQUIRED_DIRECTIVE_ARG_ADDED,
-                description: `A required arg ${newArg.name} on directive ${oldDirective.name} was added.`,
-              });
-            }
-          }
-          for (const oldArg of argsDiff.removed) {
-            schemaChanges.push({
-              type: BreakingChangeType.DIRECTIVE_ARG_REMOVED,
-              description: `${oldArg.name} was removed from ${oldDirective.name}.`,
-            });
-          }
-          if (oldDirective.isRepeatable && !newDirective.isRepeatable) {
-            schemaChanges.push({
-              type: BreakingChangeType.DIRECTIVE_REPEATABLE_REMOVED,
-              description: `Repeatable flag was removed from ${oldDirective.name}.`,
-            });
-          }
-          for (const location2 of oldDirective.locations) {
-            if (!newDirective.locations.includes(location2)) {
-              schemaChanges.push({
-                type: BreakingChangeType.DIRECTIVE_LOCATION_REMOVED,
-                description: `${location2} was removed from ${oldDirective.name}.`,
-              });
-            }
-          }
-        }
-        return schemaChanges;
-      }
-      function findTypeChanges(oldSchema, newSchema) {
-        const schemaChanges = [];
-        const typesDiff = diff(
-          Object.values(oldSchema.getTypeMap()),
-          Object.values(newSchema.getTypeMap())
-        );
-        for (const oldType of typesDiff.removed) {
-          schemaChanges.push({
-            type: BreakingChangeType.TYPE_REMOVED,
-            description: isSpecifiedScalarType(oldType)
-              ? `Standard scalar ${oldType.name} was removed because it is not referenced anymore.`
-              : `${oldType.name} was removed.`,
-          });
-        }
-        for (const [oldType, newType] of typesDiff.persisted) {
-          if (isEnumType(oldType) && isEnumType(newType)) {
-            schemaChanges.push(...findEnumTypeChanges(oldType, newType));
-          } else if (isUnionType(oldType) && isUnionType(newType)) {
-            schemaChanges.push(...findUnionTypeChanges(oldType, newType));
-          } else if (isInputObjectType(oldType) && isInputObjectType(newType)) {
-            schemaChanges.push(...findInputObjectTypeChanges(oldType, newType));
-          } else if (isObjectType(oldType) && isObjectType(newType)) {
-            schemaChanges.push(
-              ...findFieldChanges(oldType, newType),
-              ...findImplementedInterfacesChanges(oldType, newType)
-            );
-          } else if (isInterfaceType(oldType) && isInterfaceType(newType)) {
-            schemaChanges.push(
-              ...findFieldChanges(oldType, newType),
-              ...findImplementedInterfacesChanges(oldType, newType)
-            );
-          } else if (oldType.constructor !== newType.constructor) {
-            schemaChanges.push({
-              type: BreakingChangeType.TYPE_CHANGED_KIND,
-              description: `${oldType.name} changed from ${typeKindName(
-                oldType
-              )} to ${typeKindName(newType)}.`,
-            });
-          }
-        }
-        return schemaChanges;
-      }
-      function findInputObjectTypeChanges(oldType, newType) {
-        const schemaChanges = [];
-        const fieldsDiff = diff(
-          Object.values(oldType.getFields()),
-          Object.values(newType.getFields())
-        );
-        for (const newField of fieldsDiff.added) {
-          if (isRequiredInputField(newField)) {
-            schemaChanges.push({
-              type: BreakingChangeType.REQUIRED_INPUT_FIELD_ADDED,
-              description: `A required field ${newField.name} on input type ${oldType.name} was added.`,
-            });
-          } else {
-            schemaChanges.push({
-              type: DangerousChangeType.OPTIONAL_INPUT_FIELD_ADDED,
-              description: `An optional field ${newField.name} on input type ${oldType.name} was added.`,
-            });
-          }
-        }
-        for (const oldField of fieldsDiff.removed) {
-          schemaChanges.push({
-            type: BreakingChangeType.FIELD_REMOVED,
-            description: `${oldType.name}.${oldField.name} was removed.`,
-          });
-        }
-        for (const [oldField, newField] of fieldsDiff.persisted) {
-          const isSafe = isChangeSafeForInputObjectFieldOrFieldArg(
-            oldField.type,
-            newField.type
-          );
-          if (!isSafe) {
-            schemaChanges.push({
-              type: BreakingChangeType.FIELD_CHANGED_KIND,
-              description: `${oldType.name}.${
-                oldField.name
-              } changed type from ${String(oldField.type)} to ${String(
-                newField.type
-              )}.`,
-            });
-          }
-        }
-        return schemaChanges;
-      }
-      function findUnionTypeChanges(oldType, newType) {
-        const schemaChanges = [];
-        const possibleTypesDiff = diff(oldType.getTypes(), newType.getTypes());
-        for (const newPossibleType of possibleTypesDiff.added) {
-          schemaChanges.push({
-            type: DangerousChangeType.TYPE_ADDED_TO_UNION,
-            description: `${newPossibleType.name} was added to union type ${oldType.name}.`,
-          });
-        }
-        for (const oldPossibleType of possibleTypesDiff.removed) {
-          schemaChanges.push({
-            type: BreakingChangeType.TYPE_REMOVED_FROM_UNION,
-            description: `${oldPossibleType.name} was removed from union type ${oldType.name}.`,
-          });
-        }
-        return schemaChanges;
-      }
-      function findEnumTypeChanges(oldType, newType) {
-        const schemaChanges = [];
-        const valuesDiff = diff(oldType.getValues(), newType.getValues());
-        for (const newValue of valuesDiff.added) {
-          schemaChanges.push({
-            type: DangerousChangeType.VALUE_ADDED_TO_ENUM,
-            description: `${newValue.name} was added to enum type ${oldType.name}.`,
-          });
-        }
-        for (const oldValue of valuesDiff.removed) {
-          schemaChanges.push({
-            type: BreakingChangeType.VALUE_REMOVED_FROM_ENUM,
-            description: `${oldValue.name} was removed from enum type ${oldType.name}.`,
-          });
-        }
-        return schemaChanges;
-      }
-      function findImplementedInterfacesChanges(oldType, newType) {
-        const schemaChanges = [];
-        const interfacesDiff = diff(
-          oldType.getInterfaces(),
-          newType.getInterfaces()
-        );
-        for (const newInterface of interfacesDiff.added) {
-          schemaChanges.push({
-            type: DangerousChangeType.IMPLEMENTED_INTERFACE_ADDED,
-            description: `${newInterface.name} added to interfaces implemented by ${oldType.name}.`,
-          });
-        }
-        for (const oldInterface of interfacesDiff.removed) {
-          schemaChanges.push({
-            type: BreakingChangeType.IMPLEMENTED_INTERFACE_REMOVED,
-            description: `${oldType.name} no longer implements interface ${oldInterface.name}.`,
-          });
-        }
-        return schemaChanges;
-      }
-      function findFieldChanges(oldType, newType) {
-        const schemaChanges = [];
-        const fieldsDiff = diff(
-          Object.values(oldType.getFields()),
-          Object.values(newType.getFields())
-        );
-        for (const oldField of fieldsDiff.removed) {
-          schemaChanges.push({
-            type: BreakingChangeType.FIELD_REMOVED,
-            description: `${oldType.name}.${oldField.name} was removed.`,
-          });
-        }
-        for (const [oldField, newField] of fieldsDiff.persisted) {
-          schemaChanges.push(...findArgChanges(oldType, oldField, newField));
-          const isSafe = isChangeSafeForObjectOrInterfaceField(
-            oldField.type,
-            newField.type
-          );
-          if (!isSafe) {
-            schemaChanges.push({
-              type: BreakingChangeType.FIELD_CHANGED_KIND,
-              description: `${oldType.name}.${
-                oldField.name
-              } changed type from ${String(oldField.type)} to ${String(
-                newField.type
-              )}.`,
-            });
-          }
-        }
-        return schemaChanges;
-      }
-      function findArgChanges(oldType, oldField, newField) {
-        const schemaChanges = [];
-        const argsDiff = diff(oldField.args, newField.args);
-        for (const oldArg of argsDiff.removed) {
-          schemaChanges.push({
-            type: BreakingChangeType.ARG_REMOVED,
-            description: `${oldType.name}.${oldField.name} arg ${oldArg.name} was removed.`,
-          });
-        }
-        for (const [oldArg, newArg] of argsDiff.persisted) {
-          const isSafe = isChangeSafeForInputObjectFieldOrFieldArg(
-            oldArg.type,
-            newArg.type
-          );
-          if (!isSafe) {
-            schemaChanges.push({
-              type: BreakingChangeType.ARG_CHANGED_KIND,
-              description: `${oldType.name}.${oldField.name} arg ${
-                oldArg.name
-              } has changed type from ${String(oldArg.type)} to ${String(
-                newArg.type
-              )}.`,
-            });
-          } else if (oldArg.defaultValue !== void 0) {
-            if (newArg.defaultValue === void 0) {
-              schemaChanges.push({
-                type: DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,
-                description: `${oldType.name}.${oldField.name} arg ${oldArg.name} defaultValue was removed.`,
-              });
-            } else {
-              const oldValueStr = stringifyValue(
-                oldArg.defaultValue,
-                oldArg.type
-              );
-              const newValueStr = stringifyValue(
-                newArg.defaultValue,
-                newArg.type
-              );
-              if (oldValueStr !== newValueStr) {
-                schemaChanges.push({
-                  type: DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,
-                  description: `${oldType.name}.${oldField.name} arg ${oldArg.name} has changed defaultValue from ${oldValueStr} to ${newValueStr}.`,
-                });
-              }
-            }
-          }
-        }
-        for (const newArg of argsDiff.added) {
-          if (isRequiredArgument$1(newArg)) {
-            schemaChanges.push({
-              type: BreakingChangeType.REQUIRED_ARG_ADDED,
-              description: `A required arg ${newArg.name} on ${oldType.name}.${oldField.name} was added.`,
-            });
-          } else {
-            schemaChanges.push({
-              type: DangerousChangeType.OPTIONAL_ARG_ADDED,
-              description: `An optional arg ${newArg.name} on ${oldType.name}.${oldField.name} was added.`,
-            });
-          }
-        }
-        return schemaChanges;
-      }
-      function isChangeSafeForObjectOrInterfaceField(oldType, newType) {
-        if (isListType(oldType)) {
-          return (
-            (isListType(newType) &&
-              isChangeSafeForObjectOrInterfaceField(
-                oldType.ofType,
-                newType.ofType
-              )) ||
-            (isNonNullType(newType) &&
-              isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType))
-          );
-        }
-        if (isNonNullType(oldType)) {
-          return (
-            isNonNullType(newType) &&
-            isChangeSafeForObjectOrInterfaceField(
-              oldType.ofType,
-              newType.ofType
-            )
-          );
-        }
-        return (
-          (isNamedType(newType) && oldType.name === newType.name) ||
-          (isNonNullType(newType) &&
-            isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType))
-        );
-      }
-      function isChangeSafeForInputObjectFieldOrFieldArg(oldType, newType) {
-        if (isListType(oldType)) {
-          return (
-            isListType(newType) &&
-            isChangeSafeForInputObjectFieldOrFieldArg(
-              oldType.ofType,
-              newType.ofType
-            )
-          );
-        }
-        if (isNonNullType(oldType)) {
-          return (
-            (isNonNullType(newType) &&
-              isChangeSafeForInputObjectFieldOrFieldArg(
-                oldType.ofType,
-                newType.ofType
-              )) ||
-            (!isNonNullType(newType) &&
-              isChangeSafeForInputObjectFieldOrFieldArg(
-                oldType.ofType,
-                newType
-              ))
-          );
-        }
-        return isNamedType(newType) && oldType.name === newType.name;
-      }
-      function typeKindName(type2) {
-        if (isScalarType(type2)) {
-          return "a Scalar type";
-        }
-        if (isObjectType(type2)) {
-          return "an Object type";
-        }
-        if (isInterfaceType(type2)) {
-          return "an Interface type";
-        }
-        if (isUnionType(type2)) {
-          return "a Union type";
-        }
-        if (isEnumType(type2)) {
-          return "an Enum type";
-        }
-        if (isInputObjectType(type2)) {
-          return "an Input type";
-        }
-        invariant$2(false, "Unexpected type: " + inspect$2(type2));
-      }
-      function stringifyValue(value, type2) {
-        const ast2 = astFromValue(value, type2);
-        ast2 != null || invariant$2(false);
-        return print(sortValueNode(ast2));
-      }
-      function diff(oldArray, newArray) {
-        const added = [];
-        const removed = [];
-        const persisted = [];
-        const oldMap = keyMap$1(oldArray, ({ name: name2 }) => name2);
-        const newMap = keyMap$1(newArray, ({ name: name2 }) => name2);
-        for (const oldItem of oldArray) {
-          const newItem = newMap[oldItem.name];
-          if (newItem === void 0) {
-            removed.push(oldItem);
-          } else {
-            persisted.push([oldItem, newItem]);
-          }
-        }
-        for (const newItem of newArray) {
-          if (oldMap[newItem.name] === void 0) {
-            added.push(newItem);
-          }
-        }
-        return {
-          added,
-          persisted,
-          removed,
-        };
-      }
-      var graphql = /* @__PURE__ */ Object.freeze({
-        __proto__: null,
-        [Symbol.toStringTag]: "Module",
-        version,
-        versionInfo,
-        graphql: graphql$1,
-        graphqlSync,
-        resolveObjMapThunk,
-        resolveReadonlyArrayThunk,
-        GraphQLSchema,
-        GraphQLDirective,
-        GraphQLScalarType,
-        GraphQLObjectType,
-        GraphQLInterfaceType,
-        GraphQLUnionType,
-        GraphQLEnumType,
-        GraphQLInputObjectType,
-        GraphQLList,
-        GraphQLNonNull,
-        specifiedScalarTypes,
-        GraphQLInt,
-        GraphQLFloat,
-        GraphQLString,
-        GraphQLBoolean,
-        GraphQLID,
-        GRAPHQL_MAX_INT,
-        GRAPHQL_MIN_INT,
-        specifiedDirectives,
-        GraphQLIncludeDirective,
-        GraphQLSkipDirective,
-        GraphQLDeprecatedDirective,
-        GraphQLSpecifiedByDirective,
-        get TypeKind() {
-          return TypeKind;
-        },
-        DEFAULT_DEPRECATION_REASON,
-        introspectionTypes: introspectionTypes$1,
-        __Schema: __Schema$1,
-        __Directive: __Directive$1,
-        __DirectiveLocation,
-        __Type: __Type$1,
-        __Field: __Field$1,
-        __InputValue: __InputValue$1,
-        __EnumValue,
-        __TypeKind,
-        SchemaMetaFieldDef: SchemaMetaFieldDef$1,
-        TypeMetaFieldDef: TypeMetaFieldDef$1,
-        TypeNameMetaFieldDef,
-        isSchema,
-        isDirective,
-        isType,
-        isScalarType,
-        isObjectType,
-        isInterfaceType,
-        isUnionType,
-        isEnumType,
-        isInputObjectType,
-        isListType,
-        isNonNullType,
-        isInputType,
-        isOutputType,
-        isLeafType,
-        isCompositeType,
-        isAbstractType,
-        isWrappingType,
-        isNullableType,
-        isNamedType,
-        isRequiredArgument: isRequiredArgument$1,
-        isRequiredInputField,
-        isSpecifiedScalarType,
-        isIntrospectionType,
-        isSpecifiedDirective,
-        assertSchema,
-        assertDirective,
-        assertType,
-        assertScalarType,
-        assertObjectType,
-        assertInterfaceType,
-        assertUnionType,
-        assertEnumType,
-        assertInputObjectType,
-        assertListType,
-        assertNonNullType,
-        assertInputType,
-        assertOutputType,
-        assertLeafType,
-        assertCompositeType,
-        assertAbstractType,
-        assertWrappingType,
-        assertNullableType,
-        assertNamedType,
-        getNullableType,
-        getNamedType,
-        validateSchema,
-        assertValidSchema,
-        assertName,
-        assertEnumValueName,
-        Token: Token$4,
-        Source,
-        Location: Location$1,
-        get OperationTypeNode() {
-          return OperationTypeNode;
-        },
-        getLocation: getLocation$1,
-        printLocation,
-        printSourceLocation,
-        Lexer,
-        get TokenKind() {
-          return TokenKind;
-        },
-        parse: parse$1,
-        parseValue: parseValue$1,
-        parseConstValue,
-        parseType,
-        print,
-        visit,
-        visitInParallel,
-        getVisitFn,
-        getEnterLeaveForKind,
-        BREAK,
-        get Kind() {
-          return Kind;
-        },
-        get DirectiveLocation() {
-          return DirectiveLocation;
-        },
-        isDefinitionNode,
-        isExecutableDefinitionNode,
-        isSelectionNode,
-        isValueNode,
-        isConstValueNode,
-        isTypeNode,
-        isTypeSystemDefinitionNode,
-        isTypeDefinitionNode,
-        isTypeSystemExtensionNode,
-        isTypeExtensionNode,
-        execute: execute$1,
-        executeSync,
-        defaultFieldResolver: defaultFieldResolver$1,
-        defaultTypeResolver: defaultTypeResolver$1,
-        responsePathAsArray: pathToArray$1,
-        getArgumentValues: getArgumentValues$1,
-        getVariableValues: getVariableValues$1,
-        getDirectiveValues: getDirectiveValues$1,
-        subscribe,
-        createSourceEventStream,
-        validate,
-        ValidationContext,
-        specifiedRules,
-        ExecutableDefinitionsRule,
-        FieldsOnCorrectTypeRule,
-        FragmentsOnCompositeTypesRule,
-        KnownArgumentNamesRule,
-        KnownDirectivesRule,
-        KnownFragmentNamesRule,
-        KnownTypeNamesRule,
-        LoneAnonymousOperationRule,
-        NoFragmentCyclesRule,
-        NoUndefinedVariablesRule,
-        NoUnusedFragmentsRule,
-        NoUnusedVariablesRule,
-        OverlappingFieldsCanBeMergedRule,
-        PossibleFragmentSpreadsRule,
-        ProvidedRequiredArgumentsRule,
-        ScalarLeafsRule,
-        SingleFieldSubscriptionsRule,
-        UniqueArgumentNamesRule,
-        UniqueDirectivesPerLocationRule,
-        UniqueFragmentNamesRule,
-        UniqueInputFieldNamesRule,
-        UniqueOperationNamesRule,
-        UniqueVariableNamesRule,
-        ValuesOfCorrectTypeRule,
-        VariablesAreInputTypesRule,
-        VariablesInAllowedPositionRule,
-        LoneSchemaDefinitionRule,
-        UniqueOperationTypesRule,
-        UniqueTypeNamesRule,
-        UniqueEnumValueNamesRule,
-        UniqueFieldDefinitionNamesRule,
-        UniqueArgumentDefinitionNamesRule,
-        UniqueDirectiveNamesRule,
-        PossibleTypeExtensionsRule,
-        NoDeprecatedCustomRule,
-        NoSchemaIntrospectionCustomRule,
-        GraphQLError,
-        syntaxError: syntaxError$1,
-        locatedError,
-        printError,
-        formatError: formatError$1,
-        getIntrospectionQuery,
-        getOperationAST,
-        getOperationRootType,
-        introspectionFromSchema,
-        buildClientSchema,
-        buildASTSchema,
-        buildSchema,
-        extendSchema,
-        lexicographicSortSchema,
-        printSchema,
-        printType,
-        printIntrospectionSchema,
-        typeFromAST,
-        valueFromAST: valueFromAST$1,
-        valueFromASTUntyped,
-        astFromValue,
-        TypeInfo,
-        visitWithTypeInfo,
-        coerceInputValue: coerceInputValue$1,
-        concatAST,
-        separateOperations,
-        stripIgnoredCharacters,
-        isEqualType,
-        isTypeSubTypeOf,
-        doTypesOverlap,
-        assertValidName,
-        isValidNameError,
-        get BreakingChangeType() {
-          return BreakingChangeType;
-        },
-        get DangerousChangeType() {
-          return DangerousChangeType;
-        },
-        findBreakingChanges,
-        findDangerousChanges,
-      });
-      function getDefinitionState(tokenState) {
-        let definitionState;
-        forEachState$2(tokenState, (state) => {
-          switch (state.kind) {
-            case "Query":
-            case "ShortQuery":
-            case "Mutation":
-            case "Subscription":
-            case "FragmentDefinition":
-              definitionState = state;
-              break;
-          }
-        });
-        return definitionState;
-      }
-      function getFieldDef$1(schema, type2, fieldName) {
-        if (
-          fieldName === SchemaMetaFieldDef$1.name &&
-          schema.getQueryType() === type2
-        ) {
-          return SchemaMetaFieldDef$1;
-        }
-        if (
-          fieldName === TypeMetaFieldDef$1.name &&
-          schema.getQueryType() === type2
-        ) {
-          return TypeMetaFieldDef$1;
-        }
-        if (fieldName === TypeNameMetaFieldDef.name && isCompositeType(type2)) {
-          return TypeNameMetaFieldDef;
-        }
-        if ("getFields" in type2) {
-          return type2.getFields()[fieldName];
-        }
-        return null;
-      }
-      function forEachState$2(stack, fn) {
-        const reverseStateStack = [];
-        let state = stack;
-        while (state && state.kind) {
-          reverseStateStack.push(state);
-          state = state.prevState;
-        }
-        for (let i = reverseStateStack.length - 1; i >= 0; i--) {
-          fn(reverseStateStack[i]);
-        }
-      }
-      function objectValues(object) {
-        const keys = Object.keys(object);
-        const len = keys.length;
-        const values = new Array(len);
-        for (let i = 0; i < len; ++i) {
-          values[i] = object[keys[i]];
-        }
-        return values;
-      }
-      function hintList$2(token2, list3) {
-        return filterAndSortList$1(list3, normalizeText$1(token2.string));
-      }
-      function filterAndSortList$1(list3, text3) {
-        if (!text3) {
-          return filterNonEmpty$1(list3, (entry) => !entry.isDeprecated);
-        }
-        const byProximity = list3.map((entry) => ({
-          proximity: getProximity$1(normalizeText$1(entry.label), text3),
-          entry,
-        }));
-        return filterNonEmpty$1(
-          filterNonEmpty$1(byProximity, (pair) => pair.proximity <= 2),
-          (pair) => !pair.entry.isDeprecated
-        )
-          .sort(
-            (a, b) =>
-              (a.entry.isDeprecated ? 1 : 0) - (b.entry.isDeprecated ? 1 : 0) ||
-              a.proximity - b.proximity ||
-              a.entry.label.length - b.entry.label.length
-          )
-          .map((pair) => pair.entry);
-      }
-      function filterNonEmpty$1(array, predicate) {
-        const filtered = array.filter(predicate);
-        return filtered.length === 0 ? array : filtered;
-      }
-      function normalizeText$1(text3) {
-        return text3.toLowerCase().replace(/\W/g, "");
-      }
-      function getProximity$1(suggestion, text3) {
-        let proximity = lexicalDistance$1(text3, suggestion);
-        if (suggestion.length > text3.length) {
-          proximity -= suggestion.length - text3.length - 1;
-          proximity += suggestion.indexOf(text3) === 0 ? 0 : 0.5;
-        }
-        return proximity;
-      }
-      function lexicalDistance$1(a, b) {
-        let i;
-        let j;
-        const d = [];
-        const aLength = a.length;
-        const bLength = b.length;
-        for (i = 0; i <= aLength; i++) {
-          d[i] = [i];
-        }
-        for (j = 1; j <= bLength; j++) {
-          d[0][j] = j;
-        }
-        for (i = 1; i <= aLength; i++) {
-          for (j = 1; j <= bLength; j++) {
-            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            d[i][j] = Math.min(
-              d[i - 1][j] + 1,
-              d[i][j - 1] + 1,
-              d[i - 1][j - 1] + cost
-            );
-            if (
-              i > 1 &&
-              j > 1 &&
-              a[i - 1] === b[j - 2] &&
-              a[i - 2] === b[j - 1]
-            ) {
-              d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
-            }
-          }
-        }
-        return d[aLength][bLength];
-      }
-      var integer;
-      (function (integer2) {
-        integer2.MIN_VALUE = -2147483648;
-        integer2.MAX_VALUE = 2147483647;
-      })(integer || (integer = {}));
-      var uinteger;
-      (function (uinteger2) {
-        uinteger2.MIN_VALUE = 0;
-        uinteger2.MAX_VALUE = 2147483647;
-      })(uinteger || (uinteger = {}));
-      var Position$1;
-      (function (Position2) {
-        function create(line, character) {
-          if (line === Number.MAX_VALUE) {
-            line = uinteger.MAX_VALUE;
-          }
-          if (character === Number.MAX_VALUE) {
-            character = uinteger.MAX_VALUE;
-          }
-          return { line, character };
-        }
-        Position2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.objectLiteral(candidate) &&
-            Is.uinteger(candidate.line) &&
-            Is.uinteger(candidate.character)
-          );
-        }
-        Position2.is = is2;
-      })(Position$1 || (Position$1 = {}));
-      var Range$1;
-      (function (Range2) {
-        function create(one, two, three, four) {
-          if (
-            Is.uinteger(one) &&
-            Is.uinteger(two) &&
-            Is.uinteger(three) &&
-            Is.uinteger(four)
-          ) {
-            return {
-              start: Position$1.create(one, two),
-              end: Position$1.create(three, four),
-            };
-          } else if (Position$1.is(one) && Position$1.is(two)) {
-            return { start: one, end: two };
-          } else {
-            throw new Error(
-              "Range#create called with invalid arguments[" +
-                one +
-                ", " +
-                two +
-                ", " +
-                three +
-                ", " +
-                four +
-                "]"
-            );
-          }
-        }
-        Range2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.objectLiteral(candidate) &&
-            Position$1.is(candidate.start) &&
-            Position$1.is(candidate.end)
-          );
-        }
-        Range2.is = is2;
-      })(Range$1 || (Range$1 = {}));
-      var Location;
-      (function (Location2) {
-        function create(uri, range2) {
-          return { uri, range: range2 };
-        }
-        Location2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Range$1.is(candidate.range) &&
-            (Is.string(candidate.uri) || Is.undefined(candidate.uri))
-          );
-        }
-        Location2.is = is2;
-      })(Location || (Location = {}));
-      var LocationLink;
-      (function (LocationLink2) {
-        function create(
-          targetUri,
-          targetRange,
-          targetSelectionRange,
-          originSelectionRange
-        ) {
-          return {
-            targetUri,
-            targetRange,
-            targetSelectionRange,
-            originSelectionRange,
-          };
-        }
-        LocationLink2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Range$1.is(candidate.targetRange) &&
-            Is.string(candidate.targetUri) &&
-            (Range$1.is(candidate.targetSelectionRange) ||
-              Is.undefined(candidate.targetSelectionRange)) &&
-            (Range$1.is(candidate.originSelectionRange) ||
-              Is.undefined(candidate.originSelectionRange))
-          );
-        }
-        LocationLink2.is = is2;
-      })(LocationLink || (LocationLink = {}));
-      var Color;
-      (function (Color2) {
-        function create(red, green, blue, alpha2) {
-          return {
-            red,
-            green,
-            blue,
-            alpha: alpha2,
-          };
-        }
-        Color2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.numberRange(candidate.red, 0, 1) &&
-            Is.numberRange(candidate.green, 0, 1) &&
-            Is.numberRange(candidate.blue, 0, 1) &&
-            Is.numberRange(candidate.alpha, 0, 1)
-          );
-        }
-        Color2.is = is2;
-      })(Color || (Color = {}));
-      var ColorInformation;
-      (function (ColorInformation2) {
-        function create(range2, color) {
-          return {
-            range: range2,
-            color,
-          };
-        }
-        ColorInformation2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return Range$1.is(candidate.range) && Color.is(candidate.color);
-        }
-        ColorInformation2.is = is2;
-      })(ColorInformation || (ColorInformation = {}));
-      var ColorPresentation;
-      (function (ColorPresentation2) {
-        function create(label, textEdit, additionalTextEdits) {
-          return {
-            label,
-            textEdit,
-            additionalTextEdits,
-          };
-        }
-        ColorPresentation2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.string(candidate.label) &&
-            (Is.undefined(candidate.textEdit) || TextEdit.is(candidate)) &&
-            (Is.undefined(candidate.additionalTextEdits) ||
-              Is.typedArray(candidate.additionalTextEdits, TextEdit.is))
-          );
-        }
-        ColorPresentation2.is = is2;
-      })(ColorPresentation || (ColorPresentation = {}));
-      var FoldingRangeKind;
-      (function (FoldingRangeKind2) {
-        FoldingRangeKind2["Comment"] = "comment";
-        FoldingRangeKind2["Imports"] = "imports";
-        FoldingRangeKind2["Region"] = "region";
-      })(FoldingRangeKind || (FoldingRangeKind = {}));
-      var FoldingRange;
-      (function (FoldingRange2) {
-        function create(
-          startLine,
-          endLine,
-          startCharacter,
-          endCharacter,
-          kind2
-        ) {
-          var result2 = {
-            startLine,
-            endLine,
-          };
-          if (Is.defined(startCharacter)) {
-            result2.startCharacter = startCharacter;
-          }
-          if (Is.defined(endCharacter)) {
-            result2.endCharacter = endCharacter;
-          }
-          if (Is.defined(kind2)) {
-            result2.kind = kind2;
-          }
-          return result2;
-        }
-        FoldingRange2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.uinteger(candidate.startLine) &&
-            Is.uinteger(candidate.startLine) &&
-            (Is.undefined(candidate.startCharacter) ||
-              Is.uinteger(candidate.startCharacter)) &&
-            (Is.undefined(candidate.endCharacter) ||
-              Is.uinteger(candidate.endCharacter)) &&
-            (Is.undefined(candidate.kind) || Is.string(candidate.kind))
-          );
-        }
-        FoldingRange2.is = is2;
-      })(FoldingRange || (FoldingRange = {}));
-      var DiagnosticRelatedInformation;
-      (function (DiagnosticRelatedInformation2) {
-        function create(location2, message) {
-          return {
-            location: location2,
-            message,
-          };
-        }
-        DiagnosticRelatedInformation2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Location.is(candidate.location) &&
-            Is.string(candidate.message)
-          );
-        }
-        DiagnosticRelatedInformation2.is = is2;
-      })(DiagnosticRelatedInformation || (DiagnosticRelatedInformation = {}));
-      var DiagnosticSeverity;
-      (function (DiagnosticSeverity2) {
-        DiagnosticSeverity2.Error = 1;
-        DiagnosticSeverity2.Warning = 2;
-        DiagnosticSeverity2.Information = 3;
-        DiagnosticSeverity2.Hint = 4;
-      })(DiagnosticSeverity || (DiagnosticSeverity = {}));
-      var DiagnosticTag;
-      (function (DiagnosticTag2) {
-        DiagnosticTag2.Unnecessary = 1;
-        DiagnosticTag2.Deprecated = 2;
-      })(DiagnosticTag || (DiagnosticTag = {}));
-      var CodeDescription;
-      (function (CodeDescription2) {
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate !== void 0 &&
-            candidate !== null &&
-            Is.string(candidate.href)
-          );
-        }
-        CodeDescription2.is = is2;
-      })(CodeDescription || (CodeDescription = {}));
-      var Diagnostic;
-      (function (Diagnostic2) {
-        function create(
-          range2,
-          message,
-          severity,
-          code3,
-          source,
-          relatedInformation
-        ) {
-          var result2 = { range: range2, message };
-          if (Is.defined(severity)) {
-            result2.severity = severity;
-          }
-          if (Is.defined(code3)) {
-            result2.code = code3;
-          }
-          if (Is.defined(source)) {
-            result2.source = source;
-          }
-          if (Is.defined(relatedInformation)) {
-            result2.relatedInformation = relatedInformation;
-          }
-          return result2;
-        }
-        Diagnostic2.create = create;
-        function is2(value) {
-          var _a2;
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Range$1.is(candidate.range) &&
-            Is.string(candidate.message) &&
-            (Is.number(candidate.severity) ||
-              Is.undefined(candidate.severity)) &&
-            (Is.integer(candidate.code) ||
-              Is.string(candidate.code) ||
-              Is.undefined(candidate.code)) &&
-            (Is.undefined(candidate.codeDescription) ||
-              Is.string(
-                (_a2 = candidate.codeDescription) === null || _a2 === void 0
-                  ? void 0
-                  : _a2.href
-              )) &&
-            (Is.string(candidate.source) || Is.undefined(candidate.source)) &&
-            (Is.undefined(candidate.relatedInformation) ||
-              Is.typedArray(
-                candidate.relatedInformation,
-                DiagnosticRelatedInformation.is
-              ))
-          );
-        }
-        Diagnostic2.is = is2;
-      })(Diagnostic || (Diagnostic = {}));
-      var Command;
-      (function (Command2) {
-        function create(title, command) {
-          var args = [];
-          for (var _i = 2; _i < arguments.length; _i++) {
-            args[_i - 2] = arguments[_i];
-          }
-          var result2 = { title, command };
-          if (Is.defined(args) && args.length > 0) {
-            result2.arguments = args;
-          }
-          return result2;
-        }
-        Command2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Is.string(candidate.title) &&
-            Is.string(candidate.command)
-          );
-        }
-        Command2.is = is2;
-      })(Command || (Command = {}));
-      var TextEdit;
-      (function (TextEdit2) {
-        function replace2(range2, newText) {
-          return { range: range2, newText };
-        }
-        TextEdit2.replace = replace2;
-        function insert(position, newText) {
-          return { range: { start: position, end: position }, newText };
-        }
-        TextEdit2.insert = insert;
-        function del(range2) {
-          return { range: range2, newText: "" };
-        }
-        TextEdit2.del = del;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.objectLiteral(candidate) &&
-            Is.string(candidate.newText) &&
-            Range$1.is(candidate.range)
-          );
-        }
-        TextEdit2.is = is2;
-      })(TextEdit || (TextEdit = {}));
-      var ChangeAnnotation;
-      (function (ChangeAnnotation2) {
-        function create(label, needsConfirmation, description) {
-          var result2 = { label };
-          if (needsConfirmation !== void 0) {
-            result2.needsConfirmation = needsConfirmation;
-          }
-          if (description !== void 0) {
-            result2.description = description;
-          }
-          return result2;
-        }
-        ChangeAnnotation2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate !== void 0 &&
-            Is.objectLiteral(candidate) &&
-            Is.string(candidate.label) &&
-            (Is.boolean(candidate.needsConfirmation) ||
-              candidate.needsConfirmation === void 0) &&
-            (Is.string(candidate.description) ||
-              candidate.description === void 0)
-          );
-        }
-        ChangeAnnotation2.is = is2;
-      })(ChangeAnnotation || (ChangeAnnotation = {}));
-      var ChangeAnnotationIdentifier;
-      (function (ChangeAnnotationIdentifier2) {
-        function is2(value) {
-          var candidate = value;
-          return typeof candidate === "string";
-        }
-        ChangeAnnotationIdentifier2.is = is2;
-      })(ChangeAnnotationIdentifier || (ChangeAnnotationIdentifier = {}));
-      var AnnotatedTextEdit;
-      (function (AnnotatedTextEdit2) {
-        function replace2(range2, newText, annotation) {
-          return { range: range2, newText, annotationId: annotation };
-        }
-        AnnotatedTextEdit2.replace = replace2;
-        function insert(position, newText, annotation) {
-          return {
-            range: { start: position, end: position },
-            newText,
-            annotationId: annotation,
-          };
-        }
-        AnnotatedTextEdit2.insert = insert;
-        function del(range2, annotation) {
-          return { range: range2, newText: "", annotationId: annotation };
-        }
-        AnnotatedTextEdit2.del = del;
-        function is2(value) {
-          var candidate = value;
-          return (
-            TextEdit.is(candidate) &&
-            (ChangeAnnotation.is(candidate.annotationId) ||
-              ChangeAnnotationIdentifier.is(candidate.annotationId))
-          );
-        }
-        AnnotatedTextEdit2.is = is2;
-      })(AnnotatedTextEdit || (AnnotatedTextEdit = {}));
-      var TextDocumentEdit;
-      (function (TextDocumentEdit2) {
-        function create(textDocument, edits) {
-          return { textDocument, edits };
-        }
-        TextDocumentEdit2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            OptionalVersionedTextDocumentIdentifier.is(
-              candidate.textDocument
-            ) &&
-            Array.isArray(candidate.edits)
-          );
-        }
-        TextDocumentEdit2.is = is2;
-      })(TextDocumentEdit || (TextDocumentEdit = {}));
-      var CreateFile;
-      (function (CreateFile2) {
-        function create(uri, options, annotation) {
-          var result2 = {
-            kind: "create",
-            uri,
-          };
-          if (
-            options !== void 0 &&
-            (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)
-          ) {
-            result2.options = options;
-          }
-          if (annotation !== void 0) {
-            result2.annotationId = annotation;
-          }
-          return result2;
-        }
-        CreateFile2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate &&
-            candidate.kind === "create" &&
-            Is.string(candidate.uri) &&
-            (candidate.options === void 0 ||
-              ((candidate.options.overwrite === void 0 ||
-                Is.boolean(candidate.options.overwrite)) &&
-                (candidate.options.ignoreIfExists === void 0 ||
-                  Is.boolean(candidate.options.ignoreIfExists)))) &&
-            (candidate.annotationId === void 0 ||
-              ChangeAnnotationIdentifier.is(candidate.annotationId))
-          );
-        }
-        CreateFile2.is = is2;
-      })(CreateFile || (CreateFile = {}));
-      var RenameFile;
-      (function (RenameFile2) {
-        function create(oldUri, newUri, options, annotation) {
-          var result2 = {
-            kind: "rename",
-            oldUri,
-            newUri,
-          };
-          if (
-            options !== void 0 &&
-            (options.overwrite !== void 0 || options.ignoreIfExists !== void 0)
-          ) {
-            result2.options = options;
-          }
-          if (annotation !== void 0) {
-            result2.annotationId = annotation;
-          }
-          return result2;
-        }
-        RenameFile2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate &&
-            candidate.kind === "rename" &&
-            Is.string(candidate.oldUri) &&
-            Is.string(candidate.newUri) &&
-            (candidate.options === void 0 ||
-              ((candidate.options.overwrite === void 0 ||
-                Is.boolean(candidate.options.overwrite)) &&
-                (candidate.options.ignoreIfExists === void 0 ||
-                  Is.boolean(candidate.options.ignoreIfExists)))) &&
-            (candidate.annotationId === void 0 ||
-              ChangeAnnotationIdentifier.is(candidate.annotationId))
-          );
-        }
-        RenameFile2.is = is2;
-      })(RenameFile || (RenameFile = {}));
-      var DeleteFile;
-      (function (DeleteFile2) {
-        function create(uri, options, annotation) {
-          var result2 = {
-            kind: "delete",
-            uri,
-          };
-          if (
-            options !== void 0 &&
-            (options.recursive !== void 0 ||
-              options.ignoreIfNotExists !== void 0)
-          ) {
-            result2.options = options;
-          }
-          if (annotation !== void 0) {
-            result2.annotationId = annotation;
-          }
-          return result2;
-        }
-        DeleteFile2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate &&
-            candidate.kind === "delete" &&
-            Is.string(candidate.uri) &&
-            (candidate.options === void 0 ||
-              ((candidate.options.recursive === void 0 ||
-                Is.boolean(candidate.options.recursive)) &&
-                (candidate.options.ignoreIfNotExists === void 0 ||
-                  Is.boolean(candidate.options.ignoreIfNotExists)))) &&
-            (candidate.annotationId === void 0 ||
-              ChangeAnnotationIdentifier.is(candidate.annotationId))
-          );
-        }
-        DeleteFile2.is = is2;
-      })(DeleteFile || (DeleteFile = {}));
-      var WorkspaceEdit;
-      (function (WorkspaceEdit2) {
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate &&
-            (candidate.changes !== void 0 ||
-              candidate.documentChanges !== void 0) &&
-            (candidate.documentChanges === void 0 ||
-              candidate.documentChanges.every(function (change) {
-                if (Is.string(change.kind)) {
-                  return (
-                    CreateFile.is(change) ||
-                    RenameFile.is(change) ||
-                    DeleteFile.is(change)
-                  );
-                } else {
-                  return TextDocumentEdit.is(change);
-                }
-              }))
-          );
-        }
-        WorkspaceEdit2.is = is2;
-      })(WorkspaceEdit || (WorkspaceEdit = {}));
-      var TextEditChangeImpl = (function () {
-        function TextEditChangeImpl2(edits, changeAnnotations) {
-          this.edits = edits;
-          this.changeAnnotations = changeAnnotations;
-        }
-        TextEditChangeImpl2.prototype.insert = function (
-          position,
-          newText,
-          annotation
-        ) {
-          var edit;
-          var id2;
-          if (annotation === void 0) {
-            edit = TextEdit.insert(position, newText);
-          } else if (ChangeAnnotationIdentifier.is(annotation)) {
-            id2 = annotation;
-            edit = AnnotatedTextEdit.insert(position, newText, annotation);
-          } else {
-            this.assertChangeAnnotations(this.changeAnnotations);
-            id2 = this.changeAnnotations.manage(annotation);
-            edit = AnnotatedTextEdit.insert(position, newText, id2);
-          }
-          this.edits.push(edit);
-          if (id2 !== void 0) {
-            return id2;
-          }
-        };
-        TextEditChangeImpl2.prototype.replace = function (
-          range2,
-          newText,
-          annotation
-        ) {
-          var edit;
-          var id2;
-          if (annotation === void 0) {
-            edit = TextEdit.replace(range2, newText);
-          } else if (ChangeAnnotationIdentifier.is(annotation)) {
-            id2 = annotation;
-            edit = AnnotatedTextEdit.replace(range2, newText, annotation);
-          } else {
-            this.assertChangeAnnotations(this.changeAnnotations);
-            id2 = this.changeAnnotations.manage(annotation);
-            edit = AnnotatedTextEdit.replace(range2, newText, id2);
-          }
-          this.edits.push(edit);
-          if (id2 !== void 0) {
-            return id2;
-          }
-        };
-        TextEditChangeImpl2.prototype.delete = function (range2, annotation) {
-          var edit;
-          var id2;
-          if (annotation === void 0) {
-            edit = TextEdit.del(range2);
-          } else if (ChangeAnnotationIdentifier.is(annotation)) {
-            id2 = annotation;
-            edit = AnnotatedTextEdit.del(range2, annotation);
-          } else {
-            this.assertChangeAnnotations(this.changeAnnotations);
-            id2 = this.changeAnnotations.manage(annotation);
-            edit = AnnotatedTextEdit.del(range2, id2);
-          }
-          this.edits.push(edit);
-          if (id2 !== void 0) {
-            return id2;
-          }
-        };
-        TextEditChangeImpl2.prototype.add = function (edit) {
-          this.edits.push(edit);
-        };
-        TextEditChangeImpl2.prototype.all = function () {
-          return this.edits;
-        };
-        TextEditChangeImpl2.prototype.clear = function () {
-          this.edits.splice(0, this.edits.length);
-        };
-        TextEditChangeImpl2.prototype.assertChangeAnnotations = function (
-          value
-        ) {
-          if (value === void 0) {
-            throw new Error(
-              "Text edit change is not configured to manage change annotations."
-            );
-          }
-        };
-        return TextEditChangeImpl2;
-      })();
-      var ChangeAnnotations = (function () {
-        function ChangeAnnotations2(annotations2) {
-          this._annotations =
-            annotations2 === void 0
-              ? /* @__PURE__ */ Object.create(null)
-              : annotations2;
-          this._counter = 0;
-          this._size = 0;
-        }
-        ChangeAnnotations2.prototype.all = function () {
-          return this._annotations;
-        };
-        Object.defineProperty(ChangeAnnotations2.prototype, "size", {
-          get: function () {
-            return this._size;
-          },
-          enumerable: false,
-          configurable: true,
-        });
-        ChangeAnnotations2.prototype.manage = function (
-          idOrAnnotation,
-          annotation
-        ) {
-          var id2;
-          if (ChangeAnnotationIdentifier.is(idOrAnnotation)) {
-            id2 = idOrAnnotation;
-          } else {
-            id2 = this.nextId();
-            annotation = idOrAnnotation;
-          }
-          if (this._annotations[id2] !== void 0) {
-            throw new Error("Id " + id2 + " is already in use.");
-          }
-          if (annotation === void 0) {
-            throw new Error("No annotation provided for id " + id2);
-          }
-          this._annotations[id2] = annotation;
-          this._size++;
-          return id2;
-        };
-        ChangeAnnotations2.prototype.nextId = function () {
-          this._counter++;
-          return this._counter.toString();
-        };
-        return ChangeAnnotations2;
-      })();
-      (function () {
-        function WorkspaceChange(workspaceEdit) {
-          var _this = this;
-          this._textEditChanges = /* @__PURE__ */ Object.create(null);
-          if (workspaceEdit !== void 0) {
-            this._workspaceEdit = workspaceEdit;
-            if (workspaceEdit.documentChanges) {
-              this._changeAnnotations = new ChangeAnnotations(
-                workspaceEdit.changeAnnotations
-              );
-              workspaceEdit.changeAnnotations = this._changeAnnotations.all();
-              workspaceEdit.documentChanges.forEach(function (change) {
-                if (TextDocumentEdit.is(change)) {
-                  var textEditChange = new TextEditChangeImpl(
-                    change.edits,
-                    _this._changeAnnotations
-                  );
-                  _this._textEditChanges[change.textDocument.uri] =
-                    textEditChange;
-                }
-              });
-            } else if (workspaceEdit.changes) {
-              Object.keys(workspaceEdit.changes).forEach(function (key) {
-                var textEditChange = new TextEditChangeImpl(
-                  workspaceEdit.changes[key]
-                );
-                _this._textEditChanges[key] = textEditChange;
-              });
-            }
-          } else {
-            this._workspaceEdit = {};
-          }
-        }
-        Object.defineProperty(WorkspaceChange.prototype, "edit", {
-          get: function () {
-            this.initDocumentChanges();
-            if (this._changeAnnotations !== void 0) {
-              if (this._changeAnnotations.size === 0) {
-                this._workspaceEdit.changeAnnotations = void 0;
-              } else {
-                this._workspaceEdit.changeAnnotations =
-                  this._changeAnnotations.all();
-              }
-            }
-            return this._workspaceEdit;
-          },
-          enumerable: false,
-          configurable: true,
-        });
-        WorkspaceChange.prototype.getTextEditChange = function (key) {
-          if (OptionalVersionedTextDocumentIdentifier.is(key)) {
-            this.initDocumentChanges();
-            if (this._workspaceEdit.documentChanges === void 0) {
-              throw new Error(
-                "Workspace edit is not configured for document changes."
-              );
-            }
-            var textDocument = { uri: key.uri, version: key.version };
-            var result2 = this._textEditChanges[textDocument.uri];
-            if (!result2) {
-              var edits = [];
-              var textDocumentEdit = {
-                textDocument,
-                edits,
-              };
-              this._workspaceEdit.documentChanges.push(textDocumentEdit);
-              result2 = new TextEditChangeImpl(edits, this._changeAnnotations);
-              this._textEditChanges[textDocument.uri] = result2;
-            }
-            return result2;
-          } else {
-            this.initChanges();
-            if (this._workspaceEdit.changes === void 0) {
-              throw new Error(
-                "Workspace edit is not configured for normal text edit changes."
-              );
-            }
-            var result2 = this._textEditChanges[key];
-            if (!result2) {
-              var edits = [];
-              this._workspaceEdit.changes[key] = edits;
-              result2 = new TextEditChangeImpl(edits);
-              this._textEditChanges[key] = result2;
-            }
-            return result2;
-          }
-        };
-        WorkspaceChange.prototype.initDocumentChanges = function () {
-          if (
-            this._workspaceEdit.documentChanges === void 0 &&
-            this._workspaceEdit.changes === void 0
-          ) {
-            this._changeAnnotations = new ChangeAnnotations();
-            this._workspaceEdit.documentChanges = [];
-            this._workspaceEdit.changeAnnotations =
-              this._changeAnnotations.all();
-          }
-        };
-        WorkspaceChange.prototype.initChanges = function () {
-          if (
-            this._workspaceEdit.documentChanges === void 0 &&
-            this._workspaceEdit.changes === void 0
-          ) {
-            this._workspaceEdit.changes = /* @__PURE__ */ Object.create(null);
-          }
-        };
-        WorkspaceChange.prototype.createFile = function (
-          uri,
-          optionsOrAnnotation,
-          options
-        ) {
-          this.initDocumentChanges();
-          if (this._workspaceEdit.documentChanges === void 0) {
-            throw new Error(
-              "Workspace edit is not configured for document changes."
-            );
-          }
-          var annotation;
-          if (
-            ChangeAnnotation.is(optionsOrAnnotation) ||
-            ChangeAnnotationIdentifier.is(optionsOrAnnotation)
-          ) {
-            annotation = optionsOrAnnotation;
-          } else {
-            options = optionsOrAnnotation;
-          }
-          var operation;
-          var id2;
-          if (annotation === void 0) {
-            operation = CreateFile.create(uri, options);
-          } else {
-            id2 = ChangeAnnotationIdentifier.is(annotation)
-              ? annotation
-              : this._changeAnnotations.manage(annotation);
-            operation = CreateFile.create(uri, options, id2);
-          }
-          this._workspaceEdit.documentChanges.push(operation);
-          if (id2 !== void 0) {
-            return id2;
-          }
-        };
-        WorkspaceChange.prototype.renameFile = function (
-          oldUri,
-          newUri,
-          optionsOrAnnotation,
-          options
-        ) {
-          this.initDocumentChanges();
-          if (this._workspaceEdit.documentChanges === void 0) {
-            throw new Error(
-              "Workspace edit is not configured for document changes."
-            );
-          }
-          var annotation;
-          if (
-            ChangeAnnotation.is(optionsOrAnnotation) ||
-            ChangeAnnotationIdentifier.is(optionsOrAnnotation)
-          ) {
-            annotation = optionsOrAnnotation;
-          } else {
-            options = optionsOrAnnotation;
-          }
-          var operation;
-          var id2;
-          if (annotation === void 0) {
-            operation = RenameFile.create(oldUri, newUri, options);
-          } else {
-            id2 = ChangeAnnotationIdentifier.is(annotation)
-              ? annotation
-              : this._changeAnnotations.manage(annotation);
-            operation = RenameFile.create(oldUri, newUri, options, id2);
-          }
-          this._workspaceEdit.documentChanges.push(operation);
-          if (id2 !== void 0) {
-            return id2;
-          }
-        };
-        WorkspaceChange.prototype.deleteFile = function (
-          uri,
-          optionsOrAnnotation,
-          options
-        ) {
-          this.initDocumentChanges();
-          if (this._workspaceEdit.documentChanges === void 0) {
-            throw new Error(
-              "Workspace edit is not configured for document changes."
-            );
-          }
-          var annotation;
-          if (
-            ChangeAnnotation.is(optionsOrAnnotation) ||
-            ChangeAnnotationIdentifier.is(optionsOrAnnotation)
-          ) {
-            annotation = optionsOrAnnotation;
-          } else {
-            options = optionsOrAnnotation;
-          }
-          var operation;
-          var id2;
-          if (annotation === void 0) {
-            operation = DeleteFile.create(uri, options);
-          } else {
-            id2 = ChangeAnnotationIdentifier.is(annotation)
-              ? annotation
-              : this._changeAnnotations.manage(annotation);
-            operation = DeleteFile.create(uri, options, id2);
-          }
-          this._workspaceEdit.documentChanges.push(operation);
-          if (id2 !== void 0) {
-            return id2;
-          }
-        };
-        return WorkspaceChange;
-      })();
-      var TextDocumentIdentifier;
-      (function (TextDocumentIdentifier2) {
-        function create(uri) {
-          return { uri };
-        }
-        TextDocumentIdentifier2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return Is.defined(candidate) && Is.string(candidate.uri);
-        }
-        TextDocumentIdentifier2.is = is2;
-      })(TextDocumentIdentifier || (TextDocumentIdentifier = {}));
-      var VersionedTextDocumentIdentifier;
-      (function (VersionedTextDocumentIdentifier2) {
-        function create(uri, version2) {
-          return { uri, version: version2 };
-        }
-        VersionedTextDocumentIdentifier2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Is.string(candidate.uri) &&
-            Is.integer(candidate.version)
-          );
-        }
-        VersionedTextDocumentIdentifier2.is = is2;
-      })(
-        VersionedTextDocumentIdentifier ||
-          (VersionedTextDocumentIdentifier = {})
-      );
-      var OptionalVersionedTextDocumentIdentifier;
-      (function (OptionalVersionedTextDocumentIdentifier2) {
-        function create(uri, version2) {
-          return { uri, version: version2 };
-        }
-        OptionalVersionedTextDocumentIdentifier2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Is.string(candidate.uri) &&
-            (candidate.version === null || Is.integer(candidate.version))
-          );
-        }
-        OptionalVersionedTextDocumentIdentifier2.is = is2;
-      })(
-        OptionalVersionedTextDocumentIdentifier ||
-          (OptionalVersionedTextDocumentIdentifier = {})
-      );
-      var TextDocumentItem;
-      (function (TextDocumentItem2) {
-        function create(uri, languageId, version2, text3) {
-          return { uri, languageId, version: version2, text: text3 };
-        }
-        TextDocumentItem2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Is.string(candidate.uri) &&
-            Is.string(candidate.languageId) &&
-            Is.integer(candidate.version) &&
-            Is.string(candidate.text)
-          );
-        }
-        TextDocumentItem2.is = is2;
-      })(TextDocumentItem || (TextDocumentItem = {}));
-      var MarkupKind;
-      (function (MarkupKind2) {
-        MarkupKind2.PlainText = "plaintext";
-        MarkupKind2.Markdown = "markdown";
-      })(MarkupKind || (MarkupKind = {}));
-      (function (MarkupKind2) {
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate === MarkupKind2.PlainText ||
-            candidate === MarkupKind2.Markdown
-          );
-        }
-        MarkupKind2.is = is2;
-      })(MarkupKind || (MarkupKind = {}));
-      var MarkupContent;
-      (function (MarkupContent2) {
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.objectLiteral(value) &&
-            MarkupKind.is(candidate.kind) &&
-            Is.string(candidate.value)
-          );
-        }
-        MarkupContent2.is = is2;
-      })(MarkupContent || (MarkupContent = {}));
-      var CompletionItemKind$1;
-      (function (CompletionItemKind2) {
-        CompletionItemKind2.Text = 1;
-        CompletionItemKind2.Method = 2;
-        CompletionItemKind2.Function = 3;
-        CompletionItemKind2.Constructor = 4;
-        CompletionItemKind2.Field = 5;
-        CompletionItemKind2.Variable = 6;
-        CompletionItemKind2.Class = 7;
-        CompletionItemKind2.Interface = 8;
-        CompletionItemKind2.Module = 9;
-        CompletionItemKind2.Property = 10;
-        CompletionItemKind2.Unit = 11;
-        CompletionItemKind2.Value = 12;
-        CompletionItemKind2.Enum = 13;
-        CompletionItemKind2.Keyword = 14;
-        CompletionItemKind2.Snippet = 15;
-        CompletionItemKind2.Color = 16;
-        CompletionItemKind2.File = 17;
-        CompletionItemKind2.Reference = 18;
-        CompletionItemKind2.Folder = 19;
-        CompletionItemKind2.EnumMember = 20;
-        CompletionItemKind2.Constant = 21;
-        CompletionItemKind2.Struct = 22;
-        CompletionItemKind2.Event = 23;
-        CompletionItemKind2.Operator = 24;
-        CompletionItemKind2.TypeParameter = 25;
-      })(CompletionItemKind$1 || (CompletionItemKind$1 = {}));
-      var InsertTextFormat;
-      (function (InsertTextFormat2) {
-        InsertTextFormat2.PlainText = 1;
-        InsertTextFormat2.Snippet = 2;
-      })(InsertTextFormat || (InsertTextFormat = {}));
-      var CompletionItemTag;
-      (function (CompletionItemTag2) {
-        CompletionItemTag2.Deprecated = 1;
-      })(CompletionItemTag || (CompletionItemTag = {}));
-      var InsertReplaceEdit;
-      (function (InsertReplaceEdit2) {
-        function create(newText, insert, replace2) {
-          return { newText, insert, replace: replace2 };
-        }
-        InsertReplaceEdit2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate &&
-            Is.string(candidate.newText) &&
-            Range$1.is(candidate.insert) &&
-            Range$1.is(candidate.replace)
-          );
-        }
-        InsertReplaceEdit2.is = is2;
-      })(InsertReplaceEdit || (InsertReplaceEdit = {}));
-      var InsertTextMode;
-      (function (InsertTextMode2) {
-        InsertTextMode2.asIs = 1;
-        InsertTextMode2.adjustIndentation = 2;
-      })(InsertTextMode || (InsertTextMode = {}));
-      var CompletionItem;
-      (function (CompletionItem2) {
-        function create(label) {
-          return { label };
-        }
-        CompletionItem2.create = create;
-      })(CompletionItem || (CompletionItem = {}));
-      var CompletionList;
-      (function (CompletionList2) {
-        function create(items, isIncomplete) {
-          return { items: items ? items : [], isIncomplete: !!isIncomplete };
-        }
-        CompletionList2.create = create;
-      })(CompletionList || (CompletionList = {}));
-      var MarkedString;
-      (function (MarkedString2) {
-        function fromPlainText(plainText) {
-          return plainText.replace(/[\\`*_{}[\]()#+\-.!]/g, "\\$&");
-        }
-        MarkedString2.fromPlainText = fromPlainText;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.string(candidate) ||
-            (Is.objectLiteral(candidate) &&
-              Is.string(candidate.language) &&
-              Is.string(candidate.value))
-          );
-        }
-        MarkedString2.is = is2;
-      })(MarkedString || (MarkedString = {}));
-      var Hover;
-      (function (Hover2) {
-        function is2(value) {
-          var candidate = value;
-          return (
-            !!candidate &&
-            Is.objectLiteral(candidate) &&
-            (MarkupContent.is(candidate.contents) ||
-              MarkedString.is(candidate.contents) ||
-              Is.typedArray(candidate.contents, MarkedString.is)) &&
-            (value.range === void 0 || Range$1.is(value.range))
-          );
-        }
-        Hover2.is = is2;
-      })(Hover || (Hover = {}));
-      var ParameterInformation;
-      (function (ParameterInformation2) {
-        function create(label, documentation) {
-          return documentation ? { label, documentation } : { label };
-        }
-        ParameterInformation2.create = create;
-      })(ParameterInformation || (ParameterInformation = {}));
-      var SignatureInformation;
-      (function (SignatureInformation2) {
-        function create(label, documentation) {
-          var parameters = [];
-          for (var _i = 2; _i < arguments.length; _i++) {
-            parameters[_i - 2] = arguments[_i];
-          }
-          var result2 = { label };
-          if (Is.defined(documentation)) {
-            result2.documentation = documentation;
-          }
-          if (Is.defined(parameters)) {
-            result2.parameters = parameters;
-          } else {
-            result2.parameters = [];
-          }
-          return result2;
-        }
-        SignatureInformation2.create = create;
-      })(SignatureInformation || (SignatureInformation = {}));
-      var DocumentHighlightKind;
-      (function (DocumentHighlightKind2) {
-        DocumentHighlightKind2.Text = 1;
-        DocumentHighlightKind2.Read = 2;
-        DocumentHighlightKind2.Write = 3;
-      })(DocumentHighlightKind || (DocumentHighlightKind = {}));
-      var DocumentHighlight;
-      (function (DocumentHighlight2) {
-        function create(range2, kind2) {
-          var result2 = { range: range2 };
-          if (Is.number(kind2)) {
-            result2.kind = kind2;
-          }
-          return result2;
-        }
-        DocumentHighlight2.create = create;
-      })(DocumentHighlight || (DocumentHighlight = {}));
-      var SymbolKind;
-      (function (SymbolKind2) {
-        SymbolKind2.File = 1;
-        SymbolKind2.Module = 2;
-        SymbolKind2.Namespace = 3;
-        SymbolKind2.Package = 4;
-        SymbolKind2.Class = 5;
-        SymbolKind2.Method = 6;
-        SymbolKind2.Property = 7;
-        SymbolKind2.Field = 8;
-        SymbolKind2.Constructor = 9;
-        SymbolKind2.Enum = 10;
-        SymbolKind2.Interface = 11;
-        SymbolKind2.Function = 12;
-        SymbolKind2.Variable = 13;
-        SymbolKind2.Constant = 14;
-        SymbolKind2.String = 15;
-        SymbolKind2.Number = 16;
-        SymbolKind2.Boolean = 17;
-        SymbolKind2.Array = 18;
-        SymbolKind2.Object = 19;
-        SymbolKind2.Key = 20;
-        SymbolKind2.Null = 21;
-        SymbolKind2.EnumMember = 22;
-        SymbolKind2.Struct = 23;
-        SymbolKind2.Event = 24;
-        SymbolKind2.Operator = 25;
-        SymbolKind2.TypeParameter = 26;
-      })(SymbolKind || (SymbolKind = {}));
-      var SymbolTag;
-      (function (SymbolTag2) {
-        SymbolTag2.Deprecated = 1;
-      })(SymbolTag || (SymbolTag = {}));
-      var SymbolInformation;
-      (function (SymbolInformation2) {
-        function create(name2, kind2, range2, uri, containerName) {
-          var result2 = {
-            name: name2,
-            kind: kind2,
-            location: { uri, range: range2 },
-          };
-          if (containerName) {
-            result2.containerName = containerName;
-          }
-          return result2;
-        }
-        SymbolInformation2.create = create;
-      })(SymbolInformation || (SymbolInformation = {}));
-      var DocumentSymbol;
-      (function (DocumentSymbol2) {
-        function create(
-          name2,
-          detail,
-          kind2,
-          range2,
-          selectionRange,
-          children
-        ) {
-          var result2 = {
-            name: name2,
-            detail,
-            kind: kind2,
-            range: range2,
-            selectionRange,
-          };
-          if (children !== void 0) {
-            result2.children = children;
-          }
-          return result2;
-        }
-        DocumentSymbol2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate &&
-            Is.string(candidate.name) &&
-            Is.number(candidate.kind) &&
-            Range$1.is(candidate.range) &&
-            Range$1.is(candidate.selectionRange) &&
-            (candidate.detail === void 0 || Is.string(candidate.detail)) &&
-            (candidate.deprecated === void 0 ||
-              Is.boolean(candidate.deprecated)) &&
-            (candidate.children === void 0 ||
-              Array.isArray(candidate.children)) &&
-            (candidate.tags === void 0 || Array.isArray(candidate.tags))
-          );
-        }
-        DocumentSymbol2.is = is2;
-      })(DocumentSymbol || (DocumentSymbol = {}));
-      var CodeActionKind;
-      (function (CodeActionKind2) {
-        CodeActionKind2.Empty = "";
-        CodeActionKind2.QuickFix = "quickfix";
-        CodeActionKind2.Refactor = "refactor";
-        CodeActionKind2.RefactorExtract = "refactor.extract";
-        CodeActionKind2.RefactorInline = "refactor.inline";
-        CodeActionKind2.RefactorRewrite = "refactor.rewrite";
-        CodeActionKind2.Source = "source";
-        CodeActionKind2.SourceOrganizeImports = "source.organizeImports";
-        CodeActionKind2.SourceFixAll = "source.fixAll";
-      })(CodeActionKind || (CodeActionKind = {}));
-      var CodeActionContext;
-      (function (CodeActionContext2) {
-        function create(diagnostics, only) {
-          var result2 = { diagnostics };
-          if (only !== void 0 && only !== null) {
-            result2.only = only;
-          }
-          return result2;
-        }
-        CodeActionContext2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Is.typedArray(candidate.diagnostics, Diagnostic.is) &&
-            (candidate.only === void 0 ||
-              Is.typedArray(candidate.only, Is.string))
-          );
-        }
-        CodeActionContext2.is = is2;
-      })(CodeActionContext || (CodeActionContext = {}));
-      var CodeAction;
-      (function (CodeAction2) {
-        function create(title, kindOrCommandOrEdit, kind2) {
-          var result2 = { title };
-          var checkKind = true;
-          if (typeof kindOrCommandOrEdit === "string") {
-            checkKind = false;
-            result2.kind = kindOrCommandOrEdit;
-          } else if (Command.is(kindOrCommandOrEdit)) {
-            result2.command = kindOrCommandOrEdit;
-          } else {
-            result2.edit = kindOrCommandOrEdit;
-          }
-          if (checkKind && kind2 !== void 0) {
-            result2.kind = kind2;
-          }
-          return result2;
-        }
-        CodeAction2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate &&
-            Is.string(candidate.title) &&
-            (candidate.diagnostics === void 0 ||
-              Is.typedArray(candidate.diagnostics, Diagnostic.is)) &&
-            (candidate.kind === void 0 || Is.string(candidate.kind)) &&
-            (candidate.edit !== void 0 || candidate.command !== void 0) &&
-            (candidate.command === void 0 || Command.is(candidate.command)) &&
-            (candidate.isPreferred === void 0 ||
-              Is.boolean(candidate.isPreferred)) &&
-            (candidate.edit === void 0 || WorkspaceEdit.is(candidate.edit))
-          );
-        }
-        CodeAction2.is = is2;
-      })(CodeAction || (CodeAction = {}));
-      var CodeLens;
-      (function (CodeLens2) {
-        function create(range2, data) {
-          var result2 = { range: range2 };
-          if (Is.defined(data)) {
-            result2.data = data;
-          }
-          return result2;
-        }
-        CodeLens2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Range$1.is(candidate.range) &&
-            (Is.undefined(candidate.command) || Command.is(candidate.command))
-          );
-        }
-        CodeLens2.is = is2;
-      })(CodeLens || (CodeLens = {}));
-      var FormattingOptions;
-      (function (FormattingOptions2) {
-        function create(tabSize, insertSpaces) {
-          return { tabSize, insertSpaces };
-        }
-        FormattingOptions2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Is.uinteger(candidate.tabSize) &&
-            Is.boolean(candidate.insertSpaces)
-          );
-        }
-        FormattingOptions2.is = is2;
-      })(FormattingOptions || (FormattingOptions = {}));
-      var DocumentLink;
-      (function (DocumentLink2) {
-        function create(range2, target2, data) {
-          return { range: range2, target: target2, data };
-        }
-        DocumentLink2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            Is.defined(candidate) &&
-            Range$1.is(candidate.range) &&
-            (Is.undefined(candidate.target) || Is.string(candidate.target))
-          );
-        }
-        DocumentLink2.is = is2;
-      })(DocumentLink || (DocumentLink = {}));
-      var SelectionRange;
-      (function (SelectionRange2) {
-        function create(range2, parent) {
-          return { range: range2, parent };
-        }
-        SelectionRange2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return (
-            candidate !== void 0 &&
-            Range$1.is(candidate.range) &&
-            (candidate.parent === void 0 ||
-              SelectionRange2.is(candidate.parent))
-          );
-        }
-        SelectionRange2.is = is2;
-      })(SelectionRange || (SelectionRange = {}));
-      var TextDocument;
-      (function (TextDocument2) {
-        function create(uri, languageId, version2, content) {
-          return new FullTextDocument(uri, languageId, version2, content);
-        }
-        TextDocument2.create = create;
-        function is2(value) {
-          var candidate = value;
-          return Is.defined(candidate) &&
-            Is.string(candidate.uri) &&
-            (Is.undefined(candidate.languageId) ||
-              Is.string(candidate.languageId)) &&
-            Is.uinteger(candidate.lineCount) &&
-            Is.func(candidate.getText) &&
-            Is.func(candidate.positionAt) &&
-            Is.func(candidate.offsetAt)
-            ? true
-            : false;
-        }
-        TextDocument2.is = is2;
-        function applyEdits(document2, edits) {
-          var text3 = document2.getText();
-          var sortedEdits = mergeSort(edits, function (a, b) {
-            var diff2 = a.range.start.line - b.range.start.line;
-            if (diff2 === 0) {
-              return a.range.start.character - b.range.start.character;
-            }
-            return diff2;
-          });
-          var lastModifiedOffset = text3.length;
-          for (var i = sortedEdits.length - 1; i >= 0; i--) {
-            var e = sortedEdits[i];
-            var startOffset = document2.offsetAt(e.range.start);
-            var endOffset = document2.offsetAt(e.range.end);
-            if (endOffset <= lastModifiedOffset) {
-              text3 =
-                text3.substring(0, startOffset) +
-                e.newText +
-                text3.substring(endOffset, text3.length);
-            } else {
-              throw new Error("Overlapping edit");
-            }
-            lastModifiedOffset = startOffset;
-          }
-          return text3;
-        }
-        TextDocument2.applyEdits = applyEdits;
-        function mergeSort(data, compare) {
-          if (data.length <= 1) {
-            return data;
-          }
-          var p2 = (data.length / 2) | 0;
-          var left = data.slice(0, p2);
-          var right = data.slice(p2);
-          mergeSort(left, compare);
-          mergeSort(right, compare);
-          var leftIdx = 0;
-          var rightIdx = 0;
-          var i = 0;
-          while (leftIdx < left.length && rightIdx < right.length) {
-            var ret = compare(left[leftIdx], right[rightIdx]);
-            if (ret <= 0) {
-              data[i++] = left[leftIdx++];
-            } else {
-              data[i++] = right[rightIdx++];
-            }
-          }
-          while (leftIdx < left.length) {
-            data[i++] = left[leftIdx++];
-          }
-          while (rightIdx < right.length) {
-            data[i++] = right[rightIdx++];
-          }
-          return data;
-        }
-      })(TextDocument || (TextDocument = {}));
-      var FullTextDocument = (function () {
-        function FullTextDocument2(uri, languageId, version2, content) {
-          this._uri = uri;
-          this._languageId = languageId;
-          this._version = version2;
-          this._content = content;
-          this._lineOffsets = void 0;
-        }
-        Object.defineProperty(FullTextDocument2.prototype, "uri", {
-          get: function () {
-            return this._uri;
-          },
-          enumerable: false,
-          configurable: true,
-        });
-        Object.defineProperty(FullTextDocument2.prototype, "languageId", {
-          get: function () {
-            return this._languageId;
-          },
-          enumerable: false,
-          configurable: true,
-        });
-        Object.defineProperty(FullTextDocument2.prototype, "version", {
-          get: function () {
-            return this._version;
-          },
-          enumerable: false,
-          configurable: true,
-        });
-        FullTextDocument2.prototype.getText = function (range2) {
-          if (range2) {
-            var start2 = this.offsetAt(range2.start);
-            var end2 = this.offsetAt(range2.end);
-            return this._content.substring(start2, end2);
-          }
-          return this._content;
-        };
-        FullTextDocument2.prototype.update = function (event, version2) {
-          this._content = event.text;
-          this._version = version2;
-          this._lineOffsets = void 0;
-        };
-        FullTextDocument2.prototype.getLineOffsets = function () {
-          if (this._lineOffsets === void 0) {
-            var lineOffsets = [];
-            var text3 = this._content;
-            var isLineStart = true;
-            for (var i = 0; i < text3.length; i++) {
-              if (isLineStart) {
-                lineOffsets.push(i);
-                isLineStart = false;
-              }
-              var ch2 = text3.charAt(i);
-              isLineStart = ch2 === "\r" || ch2 === "\n";
-              if (
-                ch2 === "\r" &&
-                i + 1 < text3.length &&
-                text3.charAt(i + 1) === "\n"
-              ) {
-                i++;
-              }
-            }
-            if (isLineStart && text3.length > 0) {
-              lineOffsets.push(text3.length);
-            }
-            this._lineOffsets = lineOffsets;
-          }
-          return this._lineOffsets;
-        };
-        FullTextDocument2.prototype.positionAt = function (offset) {
-          offset = Math.max(Math.min(offset, this._content.length), 0);
-          var lineOffsets = this.getLineOffsets();
-          var low = 0,
-            high = lineOffsets.length;
-          if (high === 0) {
-            return Position$1.create(0, offset);
-          }
-          while (low < high) {
-            var mid2 = Math.floor((low + high) / 2);
-            if (lineOffsets[mid2] > offset) {
-              high = mid2;
-            } else {
-              low = mid2 + 1;
-            }
-          }
-          var line = low - 1;
-          return Position$1.create(line, offset - lineOffsets[line]);
-        };
-        FullTextDocument2.prototype.offsetAt = function (position) {
-          var lineOffsets = this.getLineOffsets();
-          if (position.line >= lineOffsets.length) {
-            return this._content.length;
-          } else if (position.line < 0) {
-            return 0;
-          }
-          var lineOffset = lineOffsets[position.line];
-          var nextLineOffset =
-            position.line + 1 < lineOffsets.length
-              ? lineOffsets[position.line + 1]
-              : this._content.length;
-          return Math.max(
-            Math.min(lineOffset + position.character, nextLineOffset),
-            lineOffset
-          );
-        };
-        Object.defineProperty(FullTextDocument2.prototype, "lineCount", {
-          get: function () {
-            return this.getLineOffsets().length;
-          },
-          enumerable: false,
-          configurable: true,
-        });
-        return FullTextDocument2;
-      })();
-      var Is;
-      (function (Is2) {
-        var toString = Object.prototype.toString;
-        function defined(value) {
-          return typeof value !== "undefined";
-        }
-        Is2.defined = defined;
-        function undefined$1(value) {
-          return typeof value === "undefined";
-        }
-        Is2.undefined = undefined$1;
-        function boolean(value) {
-          return value === true || value === false;
-        }
-        Is2.boolean = boolean;
-        function string2(value) {
-          return toString.call(value) === "[object String]";
-        }
-        Is2.string = string2;
-        function number(value) {
-          return toString.call(value) === "[object Number]";
-        }
-        Is2.number = number;
-        function numberRange(value, min, max) {
-          return (
-            toString.call(value) === "[object Number]" &&
-            min <= value &&
-            value <= max
-          );
-        }
-        Is2.numberRange = numberRange;
-        function integer2(value) {
-          return (
-            toString.call(value) === "[object Number]" &&
-            -2147483648 <= value &&
-            value <= 2147483647
-          );
-        }
-        Is2.integer = integer2;
-        function uinteger2(value) {
-          return (
-            toString.call(value) === "[object Number]" &&
-            0 <= value &&
-            value <= 2147483647
-          );
-        }
-        Is2.uinteger = uinteger2;
-        function func(value) {
-          return toString.call(value) === "[object Function]";
-        }
-        Is2.func = func;
-        function objectLiteral(value) {
-          return value !== null && typeof value === "object";
-        }
-        Is2.objectLiteral = objectLiteral;
-        function typedArray(value, check2) {
-          return Array.isArray(value) && value.every(check2);
-        }
-        Is2.typedArray = typedArray;
-      })(Is || (Is = {}));
-      class CharacterStream {
-        constructor(sourceText) {
-          this.getStartOfToken = () => this._start;
-          this.getCurrentPosition = () => this._pos;
-          this.eol = () => this._sourceText.length === this._pos;
-          this.sol = () => this._pos === 0;
-          this.peek = () => {
-            return this._sourceText.charAt(this._pos)
-              ? this._sourceText.charAt(this._pos)
-              : null;
-          };
-          this.next = () => {
-            const char = this._sourceText.charAt(this._pos);
-            this._pos++;
-            return char;
-          };
-          this.eat = (pattern) => {
-            const isMatched = this._testNextCharacter(pattern);
-            if (isMatched) {
-              this._start = this._pos;
-              this._pos++;
-              return this._sourceText.charAt(this._pos - 1);
-            }
-            return void 0;
-          };
-          this.eatWhile = (match2) => {
-            let isMatched = this._testNextCharacter(match2);
-            let didEat = false;
-            if (isMatched) {
-              didEat = isMatched;
-              this._start = this._pos;
-            }
-            while (isMatched) {
-              this._pos++;
-              isMatched = this._testNextCharacter(match2);
-              didEat = true;
-            }
-            return didEat;
-          };
-          this.eatSpace = () => this.eatWhile(/[\s\u00a0]/);
-          this.skipToEnd = () => {
-            this._pos = this._sourceText.length;
-          };
-          this.skipTo = (position) => {
-            this._pos = position;
-          };
-          this.match = (pattern, consume = true, caseFold = false) => {
-            let token2 = null;
-            let match2 = null;
-            if (typeof pattern === "string") {
-              const regex2 = new RegExp(pattern, caseFold ? "i" : "g");
-              match2 = regex2.test(
-                this._sourceText.substr(this._pos, pattern.length)
-              );
-              token2 = pattern;
-            } else if (pattern instanceof RegExp) {
-              match2 = this._sourceText.slice(this._pos).match(pattern);
-              token2 = match2 && match2[0];
-            }
-            if (match2 != null) {
-              if (
-                typeof pattern === "string" ||
-                (match2 instanceof Array &&
-                  this._sourceText.startsWith(match2[0], this._pos))
-              ) {
-                if (consume) {
-                  this._start = this._pos;
-                  if (token2 && token2.length) {
-                    this._pos += token2.length;
-                  }
-                }
-                return match2;
-              }
-            }
-            return false;
-          };
-          this.backUp = (num2) => {
-            this._pos -= num2;
-          };
-          this.column = () => this._pos;
-          this.indentation = () => {
-            const match2 = this._sourceText.match(/\s*/);
-            let indent2 = 0;
-            if (match2 && match2.length !== 0) {
-              const whitespaces = match2[0];
-              let pos = 0;
-              while (whitespaces.length > pos) {
-                if (whitespaces.charCodeAt(pos) === 9) {
-                  indent2 += 2;
-                } else {
-                  indent2++;
-                }
-                pos++;
-              }
-            }
-            return indent2;
-          };
-          this.current = () => this._sourceText.slice(this._start, this._pos);
-          this._start = 0;
-          this._pos = 0;
-          this._sourceText = sourceText;
-        }
-        _testNextCharacter(pattern) {
-          const character = this._sourceText.charAt(this._pos);
-          let isMatched = false;
-          if (typeof pattern === "string") {
-            isMatched = character === pattern;
-          } else {
-            isMatched =
-              pattern instanceof RegExp
-                ? pattern.test(character)
-                : pattern(character);
-          }
-          return isMatched;
-        }
-      }
-      function opt(ofRule) {
-        return { ofRule };
-      }
-      function list$1(ofRule, separator2) {
-        return { ofRule, isList: true, separator: separator2 };
-      }
-      function butNot(rule, exclusions) {
-        const ruleMatch = rule.match;
-        rule.match = (token2) => {
-          let check2 = false;
-          if (ruleMatch) {
-            check2 = ruleMatch(token2);
-          }
-          return (
-            check2 &&
-            exclusions.every(
-              (exclusion) => exclusion.match && !exclusion.match(token2)
-            )
-          );
-        };
-        return rule;
-      }
-      function t(kind2, style) {
-        return { style, match: (token2) => token2.kind === kind2 };
-      }
-      function p(value, style) {
-        return {
-          style: style || "punctuation",
-          match: (token2) =>
-            token2.kind === "Punctuation" && token2.value === value,
-        };
-      }
-      const isIgnored = (ch2) =>
-        ch2 === " " ||
-        ch2 === "	" ||
-        ch2 === "," ||
-        ch2 === "\n" ||
-        ch2 === "\r" ||
-        ch2 === "\uFEFF" ||
-        ch2 === "\xA0";
-      const LexRules$2 = {
-        Name: /^[_A-Za-z][_0-9A-Za-z]*/,
-        Punctuation: /^(?:!|\$|\(|\)|\.\.\.|:|=|&|@|\[|]|\{|\||\})/,
-        Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,
-        String:
-          /^(?:"""(?:\\"""|[^"]|"[^"]|""[^"])*(?:""")?|"(?:[^"\\]|\\(?:"|\/|\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*"?)/,
-        Comment: /^#.*/,
-      };
-      const ParseRules$2 = {
-        Document: [list$1("Definition")],
-        Definition(token2) {
-          switch (token2.value) {
-            case "{":
-              return "ShortQuery";
-            case "query":
-              return "Query";
-            case "mutation":
-              return "Mutation";
-            case "subscription":
-              return "Subscription";
-            case "fragment":
-              return Kind.FRAGMENT_DEFINITION;
-            case "schema":
-              return "SchemaDef";
-            case "scalar":
-              return "ScalarDef";
-            case "type":
-              return "ObjectTypeDef";
-            case "interface":
-              return "InterfaceDef";
-            case "union":
-              return "UnionDef";
-            case "enum":
-              return "EnumDef";
-            case "input":
-              return "InputDef";
-            case "extend":
-              return "ExtendDef";
-            case "directive":
-              return "DirectiveDef";
-          }
-        },
-        ShortQuery: ["SelectionSet"],
-        Query: [
-          word("query"),
-          opt(name("def")),
-          opt("VariableDefinitions"),
-          list$1("Directive"),
-          "SelectionSet",
-        ],
-        Mutation: [
-          word("mutation"),
-          opt(name("def")),
-          opt("VariableDefinitions"),
-          list$1("Directive"),
-          "SelectionSet",
-        ],
-        Subscription: [
-          word("subscription"),
-          opt(name("def")),
-          opt("VariableDefinitions"),
-          list$1("Directive"),
-          "SelectionSet",
-        ],
-        VariableDefinitions: [p("("), list$1("VariableDefinition"), p(")")],
-        VariableDefinition: ["Variable", p(":"), "Type", opt("DefaultValue")],
-        Variable: [p("$", "variable"), name("variable")],
-        DefaultValue: [p("="), "Value"],
-        SelectionSet: [p("{"), list$1("Selection"), p("}")],
-        Selection(token2, stream) {
-          return token2.value === "..."
-            ? stream.match(/[\s\u00a0,]*(on\b|@|{)/, false)
-              ? "InlineFragment"
-              : "FragmentSpread"
-            : stream.match(/[\s\u00a0,]*:/, false)
-            ? "AliasedField"
-            : "Field";
-        },
-        AliasedField: [
-          name("property"),
-          p(":"),
-          name("qualifier"),
-          opt("Arguments"),
-          list$1("Directive"),
-          opt("SelectionSet"),
-        ],
-        Field: [
-          name("property"),
-          opt("Arguments"),
-          list$1("Directive"),
-          opt("SelectionSet"),
-        ],
-        Arguments: [p("("), list$1("Argument"), p(")")],
-        Argument: [name("attribute"), p(":"), "Value"],
-        FragmentSpread: [p("..."), name("def"), list$1("Directive")],
-        InlineFragment: [
-          p("..."),
-          opt("TypeCondition"),
-          list$1("Directive"),
-          "SelectionSet",
-        ],
-        FragmentDefinition: [
-          word("fragment"),
-          opt(butNot(name("def"), [word("on")])),
-          "TypeCondition",
-          list$1("Directive"),
-          "SelectionSet",
-        ],
-        TypeCondition: [word("on"), "NamedType"],
-        Value(token2) {
-          switch (token2.kind) {
-            case "Number":
-              return "NumberValue";
-            case "String":
-              return "StringValue";
-            case "Punctuation":
-              switch (token2.value) {
-                case "[":
-                  return "ListValue";
-                case "{":
-                  return "ObjectValue";
-                case "$":
-                  return "Variable";
-                case "&":
-                  return "NamedType";
-              }
-              return null;
-            case "Name":
-              switch (token2.value) {
-                case "true":
-                case "false":
-                  return "BooleanValue";
-              }
-              if (token2.value === "null") {
-                return "NullValue";
-              }
-              return "EnumValue";
-          }
-        },
-        NumberValue: [t("Number", "number")],
-        StringValue: [
-          {
-            style: "string",
-            match: (token2) => token2.kind === "String",
-            update(state, token2) {
-              if (token2.value.startsWith('"""')) {
-                state.inBlockstring = !token2.value.slice(3).endsWith('"""');
-              }
-            },
-          },
-        ],
-        BooleanValue: [t("Name", "builtin")],
-        NullValue: [t("Name", "keyword")],
-        EnumValue: [name("string-2")],
-        ListValue: [p("["), list$1("Value"), p("]")],
-        ObjectValue: [p("{"), list$1("ObjectField"), p("}")],
-        ObjectField: [name("attribute"), p(":"), "Value"],
-        Type(token2) {
-          return token2.value === "[" ? "ListType" : "NonNullType";
-        },
-        ListType: [p("["), "Type", p("]"), opt(p("!"))],
-        NonNullType: ["NamedType", opt(p("!"))],
-        NamedType: [type("atom")],
-        Directive: [p("@", "meta"), name("meta"), opt("Arguments")],
-        DirectiveDef: [
-          word("directive"),
-          p("@", "meta"),
-          name("meta"),
-          opt("ArgumentsDef"),
-          word("on"),
-          list$1("DirectiveLocation", p("|")),
-        ],
-        InterfaceDef: [
-          word("interface"),
-          name("atom"),
-          opt("Implements"),
-          list$1("Directive"),
-          p("{"),
-          list$1("FieldDef"),
-          p("}"),
-        ],
-        Implements: [word("implements"), list$1("NamedType", p("&"))],
-        DirectiveLocation: [name("string-2")],
-        SchemaDef: [
-          word("schema"),
-          list$1("Directive"),
-          p("{"),
-          list$1("OperationTypeDef"),
-          p("}"),
-        ],
-        OperationTypeDef: [name("keyword"), p(":"), name("atom")],
-        ScalarDef: [word("scalar"), name("atom"), list$1("Directive")],
-        ObjectTypeDef: [
-          word("type"),
-          name("atom"),
-          opt("Implements"),
-          list$1("Directive"),
-          p("{"),
-          list$1("FieldDef"),
-          p("}"),
-        ],
-        FieldDef: [
-          name("property"),
-          opt("ArgumentsDef"),
-          p(":"),
-          "Type",
-          list$1("Directive"),
-        ],
-        ArgumentsDef: [p("("), list$1("InputValueDef"), p(")")],
-        InputValueDef: [
-          name("attribute"),
-          p(":"),
-          "Type",
-          opt("DefaultValue"),
-          list$1("Directive"),
-        ],
-        UnionDef: [
-          word("union"),
-          name("atom"),
-          list$1("Directive"),
-          p("="),
-          list$1("UnionMember", p("|")),
-        ],
-        UnionMember: ["NamedType"],
-        EnumDef: [
-          word("enum"),
-          name("atom"),
-          list$1("Directive"),
-          p("{"),
-          list$1("EnumValueDef"),
-          p("}"),
-        ],
-        EnumValueDef: [name("string-2"), list$1("Directive")],
-        InputDef: [
-          word("input"),
-          name("atom"),
-          list$1("Directive"),
-          p("{"),
-          list$1("InputValueDef"),
-          p("}"),
-        ],
-        ExtendDef: [word("extend"), "ObjectTypeDef"],
-      };
-      function word(value) {
-        return {
-          style: "keyword",
-          match: (token2) => token2.kind === "Name" && token2.value === value,
-        };
-      }
-      function name(style) {
-        return {
-          style,
-          match: (token2) => token2.kind === "Name",
-          update(state, token2) {
-            state.name = token2.value;
-          },
-        };
-      }
-      function type(style) {
-        return {
-          style,
-          match: (token2) => token2.kind === "Name",
-          update(state, token2) {
-            if (state.prevState && state.prevState.prevState) {
-              state.name = token2.value;
-              state.prevState.prevState.type = token2.value;
-            }
-          },
-        };
-      }
-      function onlineParser(
-        options = {
-          eatWhitespace: (stream) => stream.eatWhile(isIgnored),
-          lexRules: LexRules$2,
-          parseRules: ParseRules$2,
-          editorConfig: {},
-        }
-      ) {
-        return {
-          startState() {
-            const initialState = {
-              level: 0,
-              step: 0,
-              name: null,
-              kind: null,
-              type: null,
-              rule: null,
-              needsSeperator: false,
-              prevState: null,
-            };
-            pushRule(options.parseRules, initialState, Kind.DOCUMENT);
-            return initialState;
-          },
-          token(stream, state) {
-            return getToken(stream, state, options);
-          },
-        };
-      }
-      function getToken(stream, state, options) {
-        if (state.inBlockstring) {
-          if (stream.match(/.*"""/)) {
-            state.inBlockstring = false;
-            return "string";
-          } else {
-            stream.skipToEnd();
-            return "string";
-          }
-        }
-        const { lexRules, parseRules, eatWhitespace, editorConfig } = options;
-        if (state.rule && state.rule.length === 0) {
-          popRule(state);
-        } else if (state.needsAdvance) {
-          state.needsAdvance = false;
-          advanceRule(state, true);
-        }
-        if (stream.sol()) {
-          const tabSize = (editorConfig && editorConfig.tabSize) || 2;
-          state.indentLevel = Math.floor(stream.indentation() / tabSize);
-        }
-        if (eatWhitespace(stream)) {
-          return "ws";
-        }
-        const token2 = lex$1(lexRules, stream);
-        if (!token2) {
-          const matchedSomething = stream.match(/\S+/);
-          if (!matchedSomething) {
-            stream.match(/\s/);
-          }
-          pushRule(SpecialParseRules, state, "Invalid");
-          return "invalidchar";
-        }
-        if (token2.kind === "Comment") {
-          pushRule(SpecialParseRules, state, "Comment");
-          return "comment";
-        }
-        const backupState = assign$2({}, state);
-        if (token2.kind === "Punctuation") {
-          if (/^[{([]/.test(token2.value)) {
-            if (state.indentLevel !== void 0) {
-              state.levels = (state.levels || []).concat(state.indentLevel + 1);
-            }
-          } else if (/^[})\]]/.test(token2.value)) {
-            const levels = (state.levels = (state.levels || []).slice(0, -1));
-            if (state.indentLevel) {
-              if (
-                levels.length > 0 &&
-                levels[levels.length - 1] < state.indentLevel
-              ) {
-                state.indentLevel = levels[levels.length - 1];
-              }
-            }
-          }
-        }
-        while (state.rule) {
-          let expected =
-            typeof state.rule === "function"
-              ? state.step === 0
-                ? state.rule(token2, stream)
-                : null
-              : state.rule[state.step];
-          if (state.needsSeperator) {
-            expected =
-              expected && (expected == null ? void 0 : expected.separator);
-          }
-          if (expected) {
-            if (expected.ofRule) {
-              expected = expected.ofRule;
-            }
-            if (typeof expected === "string") {
-              pushRule(parseRules, state, expected);
-              continue;
-            }
-            if (expected.match && expected.match(token2)) {
-              if (expected.update) {
-                expected.update(state, token2);
-              }
-              if (token2.kind === "Punctuation") {
-                advanceRule(state, true);
-              } else {
-                state.needsAdvance = true;
-              }
-              return expected.style;
-            }
-          }
-          unsuccessful(state);
-        }
-        assign$2(state, backupState);
-        pushRule(SpecialParseRules, state, "Invalid");
-        return "invalidchar";
-      }
-      function assign$2(to, from) {
-        const keys = Object.keys(from);
-        for (let i = 0; i < keys.length; i++) {
-          to[keys[i]] = from[keys[i]];
-        }
-        return to;
-      }
-      const SpecialParseRules = {
-        Invalid: [],
-        Comment: [],
-      };
-      function pushRule(rules, state, ruleKind) {
-        if (!rules[ruleKind]) {
-          throw new TypeError("Unknown rule: " + ruleKind);
-        }
-        state.prevState = __spreadValues({}, state);
-        state.kind = ruleKind;
-        state.name = null;
-        state.type = null;
-        state.rule = rules[ruleKind];
-        state.step = 0;
-        state.needsSeperator = false;
-      }
-      function popRule(state) {
-        if (!state.prevState) {
-          return;
-        }
-        state.kind = state.prevState.kind;
-        state.name = state.prevState.name;
-        state.type = state.prevState.type;
-        state.rule = state.prevState.rule;
-        state.step = state.prevState.step;
-        state.needsSeperator = state.prevState.needsSeperator;
-        state.prevState = state.prevState.prevState;
-      }
-      function advanceRule(state, successful) {
-        if (isList(state) && state.rule) {
-          const step = state.rule[state.step];
-          if (step.separator) {
-            const separator2 = step.separator;
-            state.needsSeperator = !state.needsSeperator;
-            if (!state.needsSeperator && separator2.ofRule) {
-              return;
-            }
-          }
-          if (successful) {
-            return;
-          }
-        }
-        state.needsSeperator = false;
-        state.step++;
-        while (
-          state.rule &&
-          !(Array.isArray(state.rule) && state.step < state.rule.length)
-        ) {
-          popRule(state);
-          if (state.rule) {
-            if (isList(state)) {
-              if (state.rule && state.rule[state.step].separator) {
-                state.needsSeperator = !state.needsSeperator;
-              }
-            } else {
-              state.needsSeperator = false;
-              state.step++;
-            }
-          }
-        }
-      }
-      function isList(state) {
-        const step =
-          Array.isArray(state.rule) &&
-          typeof state.rule[state.step] !== "string" &&
-          state.rule[state.step];
-        return step && step.isList;
-      }
-      function unsuccessful(state) {
-        while (
-          state.rule &&
-          !(Array.isArray(state.rule) && state.rule[state.step].ofRule)
-        ) {
-          popRule(state);
-        }
-        if (state.rule) {
-          advanceRule(state, false);
-        }
-      }
-      function lex$1(lexRules, stream) {
-        const kinds = Object.keys(lexRules);
-        for (let i = 0; i < kinds.length; i++) {
-          const match2 = stream.match(lexRules[kinds[i]]);
-          if (match2 && match2 instanceof Array) {
-            return { kind: kinds[i], value: match2[0] };
-          }
-        }
-      }
-      const AdditionalRuleKinds = {
-        ALIASED_FIELD: "AliasedField",
-        ARGUMENTS: "Arguments",
-        SHORT_QUERY: "ShortQuery",
-        QUERY: "Query",
-        MUTATION: "Mutation",
-        SUBSCRIPTION: "Subscription",
-        TYPE_CONDITION: "TypeCondition",
-        INVALID: "Invalid",
-        COMMENT: "Comment",
-        SCHEMA_DEF: "SchemaDef",
-        SCALAR_DEF: "ScalarDef",
-        OBJECT_TYPE_DEF: "ObjectTypeDef",
-        OBJECT_VALUE: "ObjectValue",
-        LIST_VALUE: "ListValue",
-        INTERFACE_DEF: "InterfaceDef",
-        UNION_DEF: "UnionDef",
-        ENUM_DEF: "EnumDef",
-        ENUM_VALUE: "EnumValue",
-        FIELD_DEF: "FieldDef",
-        INPUT_DEF: "InputDef",
-        INPUT_VALUE_DEF: "InputValueDef",
-        ARGUMENTS_DEF: "ArgumentsDef",
-        EXTEND_DEF: "ExtendDef",
-        DIRECTIVE_DEF: "DirectiveDef",
-        IMPLEMENTS: "Implements",
-        VARIABLE_DEFINITIONS: "VariableDefinitions",
-        TYPE: "Type",
-      };
-      const RuleKinds = __spreadValues(
-        __spreadValues({}, Kind),
-        AdditionalRuleKinds
-      );
-      const SuggestionCommand = {
-        command: "editor.action.triggerSuggest",
-        title: "Suggestions",
-      };
-      const collectFragmentDefs = (op) => {
-        const externalFragments = [];
-        if (op) {
-          visit(parse$1(op), {
-            FragmentDefinition(def) {
-              externalFragments.push(def);
-            },
-          });
-        }
-        return externalFragments;
-      };
-      function getAutocompleteSuggestions(
-        schema,
-        queryText,
-        cursor,
-        contextToken,
-        fragmentDefs,
-        options
-      ) {
-        var _a2;
-        const opts = __spreadProps(__spreadValues({}, options), {
-          schema,
-        });
-        const token2 = contextToken || getTokenAtPosition(queryText, cursor);
-        const state =
-          token2.state.kind === "Invalid"
-            ? token2.state.prevState
-            : token2.state;
-        if (!state) {
-          return [];
-        }
-        const kind2 = state.kind;
-        const step = state.step;
-        const typeInfo = getTypeInfo$3(schema, token2.state);
-        if (kind2 === RuleKinds.DOCUMENT) {
-          return hintList$2(token2, [
-            { label: "query", kind: CompletionItemKind$1.Function },
-            { label: "mutation", kind: CompletionItemKind$1.Function },
-            { label: "subscription", kind: CompletionItemKind$1.Function },
-            { label: "fragment", kind: CompletionItemKind$1.Function },
-            { label: "{", kind: CompletionItemKind$1.Constructor },
-          ]);
-        }
-        if (
-          kind2 === RuleKinds.IMPLEMENTS ||
-          (kind2 === RuleKinds.NAMED_TYPE &&
-            ((_a2 = state.prevState) == null ? void 0 : _a2.kind) ===
-              RuleKinds.IMPLEMENTS)
-        ) {
-          return getSuggestionsForImplements(
-            token2,
-            state,
-            schema,
-            queryText,
-            typeInfo
-          );
-        }
-        if (
-          kind2 === RuleKinds.SELECTION_SET ||
-          kind2 === RuleKinds.FIELD ||
-          kind2 === RuleKinds.ALIASED_FIELD
-        ) {
-          return getSuggestionsForFieldNames(token2, typeInfo, opts);
-        }
-        if (
-          kind2 === RuleKinds.ARGUMENTS ||
-          (kind2 === RuleKinds.ARGUMENT && step === 0)
-        ) {
-          const argDefs = typeInfo.argDefs;
-          if (argDefs) {
-            return hintList$2(
-              token2,
-              argDefs.map((argDef) => {
-                var _a3;
-                return {
-                  label: argDef.name,
-                  insertText: argDef.name + ": ",
-                  command: SuggestionCommand,
-                  detail: String(argDef.type),
-                  documentation:
-                    (_a3 = argDef.description) != null ? _a3 : void 0,
-                  kind: CompletionItemKind$1.Variable,
-                  type: argDef.type,
-                };
-              })
-            );
-          }
-        }
-        if (
-          kind2 === RuleKinds.OBJECT_VALUE ||
-          (kind2 === RuleKinds.OBJECT_FIELD && step === 0)
-        ) {
-          if (typeInfo.objectFieldDefs) {
-            const objectFields = objectValues(typeInfo.objectFieldDefs);
-            const completionKind =
-              kind2 === RuleKinds.OBJECT_VALUE
-                ? CompletionItemKind$1.Value
-                : CompletionItemKind$1.Field;
-            return hintList$2(
-              token2,
-              objectFields.map((field) => {
-                var _a3;
-                return {
-                  label: field.name,
-                  detail: String(field.type),
-                  documentation:
-                    (_a3 = field.description) != null ? _a3 : void 0,
-                  kind: completionKind,
-                  type: field.type,
-                };
-              })
-            );
-          }
-        }
-        if (
-          kind2 === RuleKinds.ENUM_VALUE ||
-          (kind2 === RuleKinds.LIST_VALUE && step === 1) ||
-          (kind2 === RuleKinds.OBJECT_FIELD && step === 2) ||
-          (kind2 === RuleKinds.ARGUMENT && step === 2)
-        ) {
-          return getSuggestionsForInputValues(
-            token2,
-            typeInfo,
-            queryText,
-            schema
-          );
-        }
-        if (kind2 === RuleKinds.VARIABLE && step === 1) {
-          const namedInputType = getNamedType(typeInfo.inputType);
-          const variableDefinitions = getVariableCompletions(
-            queryText,
-            schema,
-            token2
-          );
-          return hintList$2(
-            token2,
-            variableDefinitions.filter(
-              (v2) =>
-                v2.detail ===
-                (namedInputType == null ? void 0 : namedInputType.name)
-            )
-          );
-        }
-        if (
-          (kind2 === RuleKinds.TYPE_CONDITION && step === 1) ||
-          (kind2 === RuleKinds.NAMED_TYPE &&
-            state.prevState != null &&
-            state.prevState.kind === RuleKinds.TYPE_CONDITION)
-        ) {
-          return getSuggestionsForFragmentTypeConditions(
-            token2,
-            typeInfo,
-            schema
-          );
-        }
-        if (kind2 === RuleKinds.FRAGMENT_SPREAD && step === 1) {
-          return getSuggestionsForFragmentSpread(
-            token2,
-            typeInfo,
-            schema,
-            queryText,
-            Array.isArray(fragmentDefs)
-              ? fragmentDefs
-              : collectFragmentDefs(fragmentDefs)
-          );
-        }
-        if (
-          (kind2 === RuleKinds.VARIABLE_DEFINITION && step === 2) ||
-          (kind2 === RuleKinds.LIST_TYPE && step === 1) ||
-          (kind2 === RuleKinds.NAMED_TYPE &&
-            state.prevState &&
-            (state.prevState.kind === RuleKinds.VARIABLE_DEFINITION ||
-              state.prevState.kind === RuleKinds.LIST_TYPE ||
-              state.prevState.kind === RuleKinds.NON_NULL_TYPE))
-        ) {
-          return getSuggestionsForVariableDefinition(token2, schema);
-        }
-        if (kind2 === RuleKinds.DIRECTIVE) {
-          return getSuggestionsForDirective(token2, state, schema);
-        }
-        return [];
-      }
-      const insertSuffix = ` {
-  $1
-}`;
-      const getInsertText = (field) => {
-        const type2 = field.type;
-        if (isCompositeType(type2)) {
-          return insertSuffix;
-        }
-        if (isListType(type2) && isCompositeType(type2.ofType)) {
-          return insertSuffix;
-        }
-        if (isNonNullType(type2)) {
-          if (isCompositeType(type2.ofType)) {
-            return insertSuffix;
-          }
-          if (
-            isListType(type2.ofType) &&
-            isCompositeType(type2.ofType.ofType)
-          ) {
-            return insertSuffix;
-          }
-        }
-        return null;
-      };
-      function getSuggestionsForFieldNames(token2, typeInfo, options) {
-        var _a2;
-        if (typeInfo.parentType) {
-          const parentType = typeInfo.parentType;
-          let fields = [];
-          if ("getFields" in parentType) {
-            fields = objectValues(parentType.getFields());
-          }
-          if (isCompositeType(parentType)) {
-            fields.push(TypeNameMetaFieldDef);
-          }
-          if (
-            parentType ===
-            ((_a2 = options == null ? void 0 : options.schema) == null
-              ? void 0
-              : _a2.getQueryType())
-          ) {
-            fields.push(SchemaMetaFieldDef$1, TypeMetaFieldDef$1);
-          }
-          return hintList$2(
-            token2,
-            fields.map((field, index) => {
-              var _a3;
-              const suggestion = {
-                sortText: String(index) + field.name,
-                label: field.name,
-                detail: String(field.type),
-                documentation: (_a3 = field.description) != null ? _a3 : void 0,
-                deprecated: Boolean(field.deprecationReason),
-                isDeprecated: Boolean(field.deprecationReason),
-                deprecationReason: field.deprecationReason,
-                kind: CompletionItemKind$1.Field,
-                type: field.type,
-              };
-              const insertText = getInsertText(field);
-              if (insertText) {
-                suggestion.insertText = field.name + insertText;
-                suggestion.insertTextFormat = InsertTextFormat.Snippet;
-                suggestion.command = SuggestionCommand;
-              }
-              return suggestion;
-            })
-          );
-        }
-        return [];
-      }
-      function getSuggestionsForInputValues(
-        token2,
-        typeInfo,
-        queryText,
-        schema
-      ) {
-        const namedInputType = getNamedType(typeInfo.inputType);
-        const queryVariables = getVariableCompletions(
-          queryText,
-          schema,
-          token2
-        ).filter((v2) => v2.detail === namedInputType.name);
-        if (namedInputType instanceof GraphQLEnumType) {
-          const values = namedInputType.getValues();
-          return hintList$2(
-            token2,
-            values
-              .map((value) => {
-                var _a2;
-                return {
-                  label: value.name,
-                  detail: String(namedInputType),
-                  documentation:
-                    (_a2 = value.description) != null ? _a2 : void 0,
-                  deprecated: Boolean(value.deprecationReason),
-                  isDeprecated: Boolean(value.deprecationReason),
-                  deprecationReason: value.deprecationReason,
-                  kind: CompletionItemKind$1.EnumMember,
-                  type: namedInputType,
-                };
-              })
-              .concat(queryVariables)
-          );
-        } else if (namedInputType === GraphQLBoolean) {
-          return hintList$2(
-            token2,
-            queryVariables.concat([
-              {
-                label: "true",
-                detail: String(GraphQLBoolean),
-                documentation: "Not false.",
-                kind: CompletionItemKind$1.Variable,
-                type: GraphQLBoolean,
-              },
-              {
-                label: "false",
-                detail: String(GraphQLBoolean),
-                documentation: "Not true.",
-                kind: CompletionItemKind$1.Variable,
-                type: GraphQLBoolean,
-              },
-            ])
-          );
-        }
-        return queryVariables;
-      }
-      function getSuggestionsForImplements(
-        token2,
-        tokenState,
-        schema,
-        documentText,
-        typeInfo
-      ) {
-        if (tokenState.needsSeperator) {
-          return [];
-        }
-        const typeMap = schema.getTypeMap();
-        const schemaInterfaces = objectValues(typeMap).filter(isInterfaceType);
-        const schemaInterfaceNames = schemaInterfaces.map(
-          ({ name: name2 }) => name2
-        );
-        const inlineInterfaces = /* @__PURE__ */ new Set();
-        runOnlineParser(documentText, (_, state) => {
-          var _a2, _b, _c, _d, _e;
-          if (state.name) {
-            if (
-              state.kind === RuleKinds.INTERFACE_DEF &&
-              !schemaInterfaceNames.includes(state.name)
-            ) {
-              inlineInterfaces.add(state.name);
-            }
-            if (
-              state.kind === RuleKinds.NAMED_TYPE &&
-              ((_a2 = state.prevState) == null ? void 0 : _a2.kind) ===
-                RuleKinds.IMPLEMENTS
-            ) {
-              if (typeInfo.interfaceDef) {
-                const existingType =
-                  (_b = typeInfo.interfaceDef) == null
-                    ? void 0
-                    : _b
-                        .getInterfaces()
-                        .find(({ name: name2 }) => name2 === state.name);
-                if (existingType) {
-                  return;
-                }
-                const type2 = schema.getType(state.name);
-                const interfaceConfig =
-                  (_c = typeInfo.interfaceDef) == null ? void 0 : _c.toConfig();
-                typeInfo.interfaceDef = new GraphQLInterfaceType(
-                  __spreadProps(__spreadValues({}, interfaceConfig), {
-                    interfaces: [
-                      ...interfaceConfig.interfaces,
-                      type2 ||
-                        new GraphQLInterfaceType({
-                          name: state.name,
-                          fields: {},
-                        }),
-                    ],
-                  })
-                );
-              } else if (typeInfo.objectTypeDef) {
-                const existingType =
-                  (_d = typeInfo.objectTypeDef) == null
-                    ? void 0
-                    : _d
-                        .getInterfaces()
-                        .find(({ name: name2 }) => name2 === state.name);
-                if (existingType) {
-                  return;
-                }
-                const type2 = schema.getType(state.name);
-                const objectTypeConfig =
-                  (_e = typeInfo.objectTypeDef) == null
-                    ? void 0
-                    : _e.toConfig();
-                typeInfo.objectTypeDef = new GraphQLObjectType(
-                  __spreadProps(__spreadValues({}, objectTypeConfig), {
-                    interfaces: [
-                      ...objectTypeConfig.interfaces,
-                      type2 ||
-                        new GraphQLInterfaceType({
-                          name: state.name,
-                          fields: {},
-                        }),
-                    ],
-                  })
-                );
-              }
-            }
-          }
-        });
-        const currentTypeToExtend =
-          typeInfo.interfaceDef || typeInfo.objectTypeDef;
-        const siblingInterfaces =
-          (currentTypeToExtend == null
-            ? void 0
-            : currentTypeToExtend.getInterfaces()) || [];
-        const siblingInterfaceNames = siblingInterfaces.map(
-          ({ name: name2 }) => name2
-        );
-        const possibleInterfaces = schemaInterfaces
-          .concat([...inlineInterfaces].map((name2) => ({ name: name2 })))
-          .filter(
-            ({ name: name2 }) =>
-              name2 !==
-                (currentTypeToExtend == null
-                  ? void 0
-                  : currentTypeToExtend.name) &&
-              !siblingInterfaceNames.includes(name2)
-          );
-        return hintList$2(
-          token2,
-          possibleInterfaces.map((type2) => {
-            const result2 = {
-              label: type2.name,
-              kind: CompletionItemKind$1.Interface,
-              type: type2,
-            };
-            if (type2 == null ? void 0 : type2.description) {
-              result2.documentation = type2.description;
-            }
-            return result2;
-          })
-        );
-      }
-      function getSuggestionsForFragmentTypeConditions(
-        token2,
-        typeInfo,
-        schema,
-        _kind
-      ) {
-        let possibleTypes;
-        if (typeInfo.parentType) {
-          if (isAbstractType(typeInfo.parentType)) {
-            const abstractType = assertAbstractType(typeInfo.parentType);
-            const possibleObjTypes = schema.getPossibleTypes(abstractType);
-            const possibleIfaceMap = /* @__PURE__ */ Object.create(null);
-            possibleObjTypes.forEach((type2) => {
-              type2.getInterfaces().forEach((iface) => {
-                possibleIfaceMap[iface.name] = iface;
-              });
-            });
-            possibleTypes = possibleObjTypes.concat(
-              objectValues(possibleIfaceMap)
-            );
-          } else {
-            possibleTypes = [typeInfo.parentType];
-          }
-        } else {
-          const typeMap = schema.getTypeMap();
-          possibleTypes = objectValues(typeMap).filter(isCompositeType);
-        }
-        return hintList$2(
-          token2,
-          possibleTypes.map((type2) => {
-            const namedType = getNamedType(type2);
-            return {
-              label: String(type2),
-              documentation: (namedType && namedType.description) || "",
-              kind: CompletionItemKind$1.Field,
-            };
-          })
-        );
-      }
-      function getSuggestionsForFragmentSpread(
-        token2,
-        typeInfo,
-        schema,
-        queryText,
-        fragmentDefs
-      ) {
-        if (!queryText) {
-          return [];
-        }
-        const typeMap = schema.getTypeMap();
-        const defState = getDefinitionState(token2.state);
-        const fragments = getFragmentDefinitions(queryText);
-        if (fragmentDefs && fragmentDefs.length > 0) {
-          fragments.push(...fragmentDefs);
-        }
-        const relevantFrags = fragments.filter(
-          (frag) =>
-            typeMap[frag.typeCondition.name.value] &&
-            !(
-              defState &&
-              defState.kind === RuleKinds.FRAGMENT_DEFINITION &&
-              defState.name === frag.name.value
-            ) &&
-            isCompositeType(typeInfo.parentType) &&
-            isCompositeType(typeMap[frag.typeCondition.name.value]) &&
-            doTypesOverlap(
-              schema,
-              typeInfo.parentType,
-              typeMap[frag.typeCondition.name.value]
-            )
-        );
-        return hintList$2(
-          token2,
-          relevantFrags.map((frag) => ({
-            label: frag.name.value,
-            detail: String(typeMap[frag.typeCondition.name.value]),
-            documentation: `fragment ${frag.name.value} on ${frag.typeCondition.name.value}`,
-            kind: CompletionItemKind$1.Field,
-            type: typeMap[frag.typeCondition.name.value],
-          }))
-        );
-      }
-      const getParentDefinition = (state, kind2) => {
-        var _a2, _b, _c, _d, _e, _f, _g, _h, _i, _j;
-        if (((_a2 = state.prevState) == null ? void 0 : _a2.kind) === kind2) {
-          return state.prevState;
-        }
-        if (
-          ((_c = (_b = state.prevState) == null ? void 0 : _b.prevState) == null
-            ? void 0
-            : _c.kind) === kind2
-        ) {
-          return state.prevState.prevState;
-        }
-        if (
-          ((_f =
-            (_e = (_d = state.prevState) == null ? void 0 : _d.prevState) ==
-            null
-              ? void 0
-              : _e.prevState) == null
-            ? void 0
-            : _f.kind) === kind2
-        ) {
-          return state.prevState.prevState.prevState;
-        }
-        if (
-          ((_j =
-            (_i =
-              (_h = (_g = state.prevState) == null ? void 0 : _g.prevState) ==
-              null
-                ? void 0
-                : _h.prevState) == null
-              ? void 0
-              : _i.prevState) == null
-            ? void 0
-            : _j.kind) === kind2
-        ) {
-          return state.prevState.prevState.prevState.prevState;
-        }
-      };
-      function getVariableCompletions(queryText, schema, token2) {
-        let variableName = null;
-        let variableType;
-        const definitions = /* @__PURE__ */ Object.create({});
-        runOnlineParser(queryText, (_, state) => {
-          if (
-            (state == null ? void 0 : state.kind) === RuleKinds.VARIABLE &&
-            state.name
-          ) {
-            variableName = state.name;
-          }
-          if (
-            (state == null ? void 0 : state.kind) === RuleKinds.NAMED_TYPE &&
-            variableName
-          ) {
-            const parentDefinition = getParentDefinition(state, RuleKinds.TYPE);
-            if (parentDefinition == null ? void 0 : parentDefinition.type) {
-              variableType = schema.getType(
-                parentDefinition == null ? void 0 : parentDefinition.type
-              );
-            }
-          }
-          if (variableName && variableType) {
-            if (!definitions[variableName]) {
-              definitions[variableName] = {
-                detail: variableType.toString(),
-                insertText:
-                  token2.string === "$" ? variableName : "$" + variableName,
-                label: variableName,
-                type: variableType,
-                kind: CompletionItemKind$1.Variable,
-              };
-              variableName = null;
-              variableType = null;
-            }
-          }
-        });
-        return objectValues(definitions);
-      }
-      function getFragmentDefinitions(queryText) {
-        const fragmentDefs = [];
-        runOnlineParser(queryText, (_, state) => {
-          if (
-            state.kind === RuleKinds.FRAGMENT_DEFINITION &&
-            state.name &&
-            state.type
-          ) {
-            fragmentDefs.push({
-              kind: RuleKinds.FRAGMENT_DEFINITION,
-              name: {
-                kind: Kind.NAME,
-                value: state.name,
-              },
-              selectionSet: {
-                kind: RuleKinds.SELECTION_SET,
-                selections: [],
-              },
-              typeCondition: {
-                kind: RuleKinds.NAMED_TYPE,
-                name: {
-                  kind: Kind.NAME,
-                  value: state.type,
-                },
-              },
-            });
-          }
-        });
-        return fragmentDefs;
-      }
-      function getSuggestionsForVariableDefinition(token2, schema, _kind) {
-        const inputTypeMap = schema.getTypeMap();
-        const inputTypes = objectValues(inputTypeMap).filter(isInputType);
-        return hintList$2(
-          token2,
-          inputTypes.map((type2) => ({
-            label: type2.name,
-            documentation: type2.description,
-            kind: CompletionItemKind$1.Variable,
-          }))
-        );
-      }
-      function getSuggestionsForDirective(token2, state, schema, _kind) {
-        if (state.prevState && state.prevState.kind) {
-          const directives = schema
-            .getDirectives()
-            .filter((directive) => canUseDirective(state.prevState, directive));
-          return hintList$2(
-            token2,
-            directives.map((directive) => ({
-              label: directive.name,
-              documentation: directive.description || "",
-              kind: CompletionItemKind$1.Function,
-            }))
-          );
-        }
-        return [];
-      }
-      function getTokenAtPosition(queryText, cursor) {
-        let styleAtCursor = null;
-        let stateAtCursor = null;
-        let stringAtCursor = null;
-        const token2 = runOnlineParser(
-          queryText,
-          (stream, state, style, index) => {
-            if (index === cursor.line) {
-              if (stream.getCurrentPosition() >= cursor.character) {
-                styleAtCursor = style;
-                stateAtCursor = __spreadValues({}, state);
-                stringAtCursor = stream.current();
-                return "BREAK";
-              }
-            }
-          }
-        );
-        return {
-          start: token2.start,
-          end: token2.end,
-          string: stringAtCursor || token2.string,
-          state: stateAtCursor || token2.state,
-          style: styleAtCursor || token2.style,
-        };
-      }
-      function runOnlineParser(queryText, callback) {
-        const lines = queryText.split("\n");
-        const parser = onlineParser();
-        let state = parser.startState();
-        let style = "";
-        let stream = new CharacterStream("");
-        for (let i = 0; i < lines.length; i++) {
-          stream = new CharacterStream(lines[i]);
-          while (!stream.eol()) {
-            style = parser.token(stream, state);
-            const code3 = callback(stream, state, style, i);
-            if (code3 === "BREAK") {
-              break;
-            }
-          }
-          callback(stream, state, style, i);
-          if (!state.kind) {
-            state = parser.startState();
-          }
-        }
-        return {
-          start: stream.getStartOfToken(),
-          end: stream.getCurrentPosition(),
-          string: stream.current(),
-          state,
-          style,
-        };
-      }
-      function canUseDirective(state, directive) {
-        if (!state || !state.kind) {
-          return false;
-        }
-        const kind2 = state.kind;
-        const locations = directive.locations;
-        switch (kind2) {
-          case RuleKinds.QUERY:
-            return locations.indexOf(DirectiveLocation.QUERY) !== -1;
-          case RuleKinds.MUTATION:
-            return locations.indexOf(DirectiveLocation.MUTATION) !== -1;
-          case RuleKinds.SUBSCRIPTION:
-            return locations.indexOf(DirectiveLocation.SUBSCRIPTION) !== -1;
-          case RuleKinds.FIELD:
-          case RuleKinds.ALIASED_FIELD:
-            return locations.indexOf(DirectiveLocation.FIELD) !== -1;
-          case RuleKinds.FRAGMENT_DEFINITION:
-            return (
-              locations.indexOf(DirectiveLocation.FRAGMENT_DEFINITION) !== -1
-            );
-          case RuleKinds.FRAGMENT_SPREAD:
-            return locations.indexOf(DirectiveLocation.FRAGMENT_SPREAD) !== -1;
-          case RuleKinds.INLINE_FRAGMENT:
-            return locations.indexOf(DirectiveLocation.INLINE_FRAGMENT) !== -1;
-          case RuleKinds.SCHEMA_DEF:
-            return locations.indexOf(DirectiveLocation.SCHEMA) !== -1;
-          case RuleKinds.SCALAR_DEF:
-            return locations.indexOf(DirectiveLocation.SCALAR) !== -1;
-          case RuleKinds.OBJECT_TYPE_DEF:
-            return locations.indexOf(DirectiveLocation.OBJECT) !== -1;
-          case RuleKinds.FIELD_DEF:
-            return locations.indexOf(DirectiveLocation.FIELD_DEFINITION) !== -1;
-          case RuleKinds.INTERFACE_DEF:
-            return locations.indexOf(DirectiveLocation.INTERFACE) !== -1;
-          case RuleKinds.UNION_DEF:
-            return locations.indexOf(DirectiveLocation.UNION) !== -1;
-          case RuleKinds.ENUM_DEF:
-            return locations.indexOf(DirectiveLocation.ENUM) !== -1;
-          case RuleKinds.ENUM_VALUE:
-            return locations.indexOf(DirectiveLocation.ENUM_VALUE) !== -1;
-          case RuleKinds.INPUT_DEF:
-            return locations.indexOf(DirectiveLocation.INPUT_OBJECT) !== -1;
-          case RuleKinds.INPUT_VALUE_DEF:
-            const prevStateKind = state.prevState && state.prevState.kind;
-            switch (prevStateKind) {
-              case RuleKinds.ARGUMENTS_DEF:
-                return (
-                  locations.indexOf(DirectiveLocation.ARGUMENT_DEFINITION) !==
-                  -1
-                );
-              case RuleKinds.INPUT_DEF:
-                return (
-                  locations.indexOf(
-                    DirectiveLocation.INPUT_FIELD_DEFINITION
-                  ) !== -1
-                );
-            }
-        }
-        return false;
-      }
-      function getTypeInfo$3(schema, tokenState) {
-        let argDef;
-        let argDefs;
-        let directiveDef;
-        let enumValue;
-        let fieldDef;
-        let inputType;
-        let objectTypeDef;
-        let objectFieldDefs;
-        let parentType;
-        let type2;
-        let interfaceDef;
-        forEachState$2(tokenState, (state) => {
-          switch (state.kind) {
-            case RuleKinds.QUERY:
-            case "ShortQuery":
-              type2 = schema.getQueryType();
-              break;
-            case RuleKinds.MUTATION:
-              type2 = schema.getMutationType();
-              break;
-            case RuleKinds.SUBSCRIPTION:
-              type2 = schema.getSubscriptionType();
-              break;
-            case RuleKinds.INLINE_FRAGMENT:
-            case RuleKinds.FRAGMENT_DEFINITION:
-              if (state.type) {
-                type2 = schema.getType(state.type);
-              }
-              break;
-            case RuleKinds.FIELD:
-            case RuleKinds.ALIASED_FIELD: {
-              if (!type2 || !state.name) {
-                fieldDef = null;
-              } else {
-                fieldDef = parentType
-                  ? getFieldDef$1(schema, parentType, state.name)
-                  : null;
-                type2 = fieldDef ? fieldDef.type : null;
-              }
-              break;
-            }
-            case RuleKinds.SELECTION_SET:
-              parentType = getNamedType(type2);
-              break;
-            case RuleKinds.DIRECTIVE:
-              directiveDef = state.name
-                ? schema.getDirective(state.name)
-                : null;
-              break;
-            case RuleKinds.INTERFACE_DEF:
-              if (state.name) {
-                objectTypeDef = null;
-                interfaceDef = new GraphQLInterfaceType({
-                  name: state.name,
-                  interfaces: [],
-                  fields: {},
-                });
-              }
-              break;
-            case RuleKinds.OBJECT_TYPE_DEF:
-              if (state.name) {
-                interfaceDef = null;
-                objectTypeDef = new GraphQLObjectType({
-                  name: state.name,
-                  interfaces: [],
-                  fields: {},
-                });
-              }
-              break;
-            case RuleKinds.ARGUMENTS: {
-              if (!state.prevState) {
-                argDefs = null;
-              } else {
-                switch (state.prevState.kind) {
-                  case RuleKinds.FIELD:
-                    argDefs = fieldDef && fieldDef.args;
-                    break;
-                  case RuleKinds.DIRECTIVE:
-                    argDefs = directiveDef && directiveDef.args;
-                    break;
-                  case RuleKinds.ALIASED_FIELD: {
-                    const name2 = state.prevState && state.prevState.name;
-                    if (!name2) {
-                      argDefs = null;
-                      break;
-                    }
-                    const field = parentType
-                      ? getFieldDef$1(schema, parentType, name2)
-                      : null;
-                    if (!field) {
-                      argDefs = null;
-                      break;
-                    }
-                    argDefs = field.args;
-                    break;
-                  }
-                  default:
-                    argDefs = null;
-                    break;
-                }
-              }
-              break;
-            }
-            case RuleKinds.ARGUMENT:
-              if (argDefs) {
-                for (let i = 0; i < argDefs.length; i++) {
-                  if (argDefs[i].name === state.name) {
-                    argDef = argDefs[i];
-                    break;
-                  }
-                }
-              }
-              inputType = argDef && argDef.type;
-              break;
-            case RuleKinds.ENUM_VALUE:
-              const enumType = getNamedType(inputType);
-              enumValue =
-                enumType instanceof GraphQLEnumType
-                  ? enumType.getValues().find((val) => val.value === state.name)
-                  : null;
-              break;
-            case RuleKinds.LIST_VALUE:
-              const nullableType = getNullableType(inputType);
-              inputType =
-                nullableType instanceof GraphQLList
-                  ? nullableType.ofType
-                  : null;
-              break;
-            case RuleKinds.OBJECT_VALUE:
-              const objectType = getNamedType(inputType);
-              objectFieldDefs =
-                objectType instanceof GraphQLInputObjectType
-                  ? objectType.getFields()
-                  : null;
-              break;
-            case RuleKinds.OBJECT_FIELD:
-              const objectField =
-                state.name && objectFieldDefs
-                  ? objectFieldDefs[state.name]
-                  : null;
-              inputType = objectField && objectField.type;
-              break;
-            case RuleKinds.NAMED_TYPE:
-              if (state.name) {
-                type2 = schema.getType(state.name);
-              }
-              break;
-          }
-        });
-        return {
-          argDef,
-          argDefs,
-          directiveDef,
-          enumValue,
-          fieldDef,
-          inputType,
-          objectFieldDefs,
-          parentType,
-          type: type2,
-          interfaceDef,
-          objectTypeDef,
-        };
-      }
-      var nullthrows$2 = { exports: {} };
-      function nullthrows(x2, message) {
-        if (x2 != null) {
-          return x2;
-        }
-        var error2 = new Error(
-          message !== void 0 ? message : "Got unexpected " + x2
-        );
-        error2.framesToPop = 1;
-        throw error2;
-      }
-      nullthrows$2.exports = nullthrows;
-      nullthrows$2.exports.default = nullthrows;
-      Object.defineProperty(nullthrows$2.exports, "__esModule", {
-        value: true,
-      });
-      var nullthrows$1 = /* @__PURE__ */ getDefaultExportFromCjs(
-        nullthrows$2.exports
-      );
-      const getFragmentDependencies = (
-        operationString,
-        fragmentDefinitions
-      ) => {
-        if (!fragmentDefinitions) {
-          return [];
-        }
-        let parsedOperation;
-        try {
-          parsedOperation = parse$1(operationString);
-        } catch (error2) {
-          return [];
-        }
-        return getFragmentDependenciesForAST(
-          parsedOperation,
-          fragmentDefinitions
-        );
-      };
-      const getFragmentDependenciesForAST = (
-        parsedOperation,
-        fragmentDefinitions
-      ) => {
-        if (!fragmentDefinitions) {
-          return [];
-        }
-        const existingFrags = /* @__PURE__ */ new Map();
-        const referencedFragNames = /* @__PURE__ */ new Set();
-        visit(parsedOperation, {
-          FragmentDefinition(node) {
-            existingFrags.set(node.name.value, true);
-          },
-          FragmentSpread(node) {
-            if (!referencedFragNames.has(node.name.value)) {
-              referencedFragNames.add(node.name.value);
-            }
-          },
-        });
-        const asts = /* @__PURE__ */ new Set();
-        referencedFragNames.forEach((name2) => {
-          if (!existingFrags.has(name2) && fragmentDefinitions.has(name2)) {
-            asts.add(nullthrows$1(fragmentDefinitions.get(name2)));
-          }
-        });
-        const referencedFragments = [];
-        asts.forEach((ast2) => {
-          visit(ast2, {
-            FragmentSpread(node) {
-              if (
-                !referencedFragNames.has(node.name.value) &&
-                fragmentDefinitions.get(node.name.value)
-              ) {
-                asts.add(
-                  nullthrows$1(fragmentDefinitions.get(node.name.value))
-                );
-                referencedFragNames.add(node.name.value);
-              }
-            },
-          });
-          if (!existingFrags.has(ast2.name.value)) {
-            referencedFragments.push(ast2);
-          }
-        });
-        return referencedFragments;
-      };
-      function text$3(into, newText) {
-        into.push(newText);
-      }
-      function renderType$4(into, t2) {
-        if (isNonNullType(t2)) {
-          renderType$4(into, t2.ofType);
-          text$3(into, "!");
-        } else if (isListType(t2)) {
-          text$3(into, "[");
-          renderType$4(into, t2.ofType);
-          text$3(into, "]");
-        } else {
-          text$3(into, t2.name);
-        }
-      }
-      function renderTypeToString(t2, useMarkdown) {
-        const into = [];
-        if (useMarkdown) {
-          text$3(into, "```graphql\n");
-        }
-        renderType$4(into, t2);
-        if (useMarkdown) {
-          text$3(into, "\n```");
-        }
-        return into.join("");
-      }
-      const scalarTypesMap = {
-        Int: "integer",
-        String: "string",
-        Float: "number",
-        ID: "string",
-        Boolean: "boolean",
-        DateTime: "string",
-      };
-      function getJSONSchemaFromGraphQLType(type2, options) {
-        var _a2;
-        let required = false;
-        let definition = /* @__PURE__ */ Object.create(null);
-        const definitions = /* @__PURE__ */ Object.create(null);
-        if ("defaultValue" in type2 && type2.defaultValue !== void 0) {
-          definition.default = type2.defaultValue;
-        }
-        if (isEnumType(type2)) {
-          definition.type = "string";
-          definition.enum = type2.getValues().map((val) => val.name);
-        }
-        if (isScalarType(type2)) {
-          definition.type =
-            (_a2 = scalarTypesMap[type2.name]) != null ? _a2 : "any";
-        }
-        if (isListType(type2)) {
-          definition.type = "array";
-          const { definition: def, definitions: defs } =
-            getJSONSchemaFromGraphQLType(type2.ofType, options);
-          if (def.$ref) {
-            definition.items = { $ref: def.$ref };
-          } else {
-            definition.items = def;
-          }
-          if (defs) {
-            Object.keys(defs).forEach((defName) => {
-              definitions[defName] = defs[defName];
-            });
-          }
-        }
-        if (isNonNullType(type2)) {
-          required = true;
-          const { definition: def, definitions: defs } =
-            getJSONSchemaFromGraphQLType(type2.ofType, options);
-          definition = def;
-          if (defs) {
-            Object.keys(defs).forEach((defName) => {
-              definitions[defName] = defs[defName];
-            });
-          }
-        }
-        if (isInputObjectType(type2)) {
-          definition.$ref = `#/definitions/${type2.name}`;
-          const fields = type2.getFields();
-          const fieldDef = {
-            type: "object",
-            properties: {},
-            required: [],
-          };
-          if (type2.description) {
-            fieldDef.description =
-              type2.description +
-              `
-` +
-              renderTypeToString(type2);
-            if (options == null ? void 0 : options.useMarkdownDescription) {
-              fieldDef.markdownDescription =
-                type2.description +
-                `
-` +
-                renderTypeToString(type2, true);
-            }
-          } else {
-            fieldDef.description = renderTypeToString(type2);
-            if (options == null ? void 0 : options.useMarkdownDescription) {
-              fieldDef.markdownDescription = renderTypeToString(type2, true);
-            }
-          }
-          Object.keys(fields).forEach((fieldName) => {
-            const field = fields[fieldName];
-            const {
-              required: fieldRequired,
-              definition: typeDefinition,
-              definitions: typeDefinitions,
-            } = getJSONSchemaFromGraphQLType(field.type, options);
-            const { definition: fieldDefinition } =
-              getJSONSchemaFromGraphQLType(field, options);
-            fieldDef.properties[fieldName] = __spreadValues(
-              __spreadValues({}, typeDefinition),
-              fieldDefinition
-            );
-            const renderedField = renderTypeToString(field.type);
-            fieldDef.properties[fieldName].description = field.description
-              ? field.description + "\n" + renderedField
-              : renderedField;
-            if (options == null ? void 0 : options.useMarkdownDescription) {
-              const renderedFieldMarkdown = renderTypeToString(
-                field.type,
-                true
-              );
-              fieldDef.properties[fieldName].markdownDescription =
-                field.description
-                  ? field.description + "\n" + renderedFieldMarkdown
-                  : renderedFieldMarkdown;
-            }
-            if (fieldRequired) {
-              fieldDef.required.push(fieldName);
-            }
-            if (typeDefinitions) {
-              Object.keys(typeDefinitions).map((defName) => {
-                definitions[defName] = typeDefinitions[defName];
-              });
-            }
-          });
-          definitions[type2.name] = fieldDef;
-        }
-        if (
-          "description" in type2 &&
-          !isScalarType(type2) &&
-          type2.description &&
-          !definition.description
-        ) {
-          definition.description =
-            type2.description + "\n" + renderTypeToString(type2);
-          if (options == null ? void 0 : options.useMarkdownDescription) {
-            definition.markdownDescription =
-              type2.description + "\n" + renderTypeToString(type2, true);
-          }
-        } else {
-          definition.description = renderTypeToString(type2);
-          if (options == null ? void 0 : options.useMarkdownDescription) {
-            definition.markdownDescription = renderTypeToString(type2, true);
-          }
-        }
-        return { required, definition, definitions };
-      }
-      function getVariablesJSONSchema(variableToType, options) {
-        const jsonSchema = {
-          $schema: "https://json-schema.org/draft/2020-12/schema",
-          type: "object",
-          properties: {},
-          required: [],
-        };
-        if (variableToType) {
-          Object.entries(variableToType).forEach(([variableName, type2]) => {
-            var _a2;
-            const { definition, required, definitions } =
-              getJSONSchemaFromGraphQLType(type2, options);
-            jsonSchema.properties[variableName] = definition;
-            if (required) {
-              (_a2 = jsonSchema.required) == null
-                ? void 0
-                : _a2.push(variableName);
-            }
-            if (definitions) {
-              jsonSchema.definitions = __spreadValues(
-                __spreadValues(
-                  {},
-                  jsonSchema == null ? void 0 : jsonSchema.definitions
-                ),
-                definitions
-              );
-            }
-          });
-        }
-        return jsonSchema;
-      }
-      function getASTNodeAtPosition(query, ast2, point) {
-        const offset = pointToOffset(query, point);
-        let nodeContainingPosition;
-        visit(ast2, {
-          enter(node) {
-            if (
-              node.kind !== "Name" &&
-              node.loc &&
-              node.loc.start <= offset &&
-              offset <= node.loc.end
-            ) {
-              nodeContainingPosition = node;
-            } else {
-              return false;
-            }
-          },
-          leave(node) {
-            if (
-              node.loc &&
-              node.loc.start <= offset &&
-              offset <= node.loc.end
-            ) {
-              return false;
-            }
-          },
-        });
-        return nodeContainingPosition;
-      }
-      function pointToOffset(text3, point) {
-        const linesUntilPosition = text3.split("\n").slice(0, point.line);
-        return (
-          point.character +
-          linesUntilPosition
-            .map((line) => line.length + 1)
-            .reduce((a, b) => a + b, 0)
-        );
-      }
-      class Range {
-        constructor(start2, end2) {
-          this.containsPosition = (position) => {
-            if (this.start.line === position.line) {
-              return this.start.character <= position.character;
-            } else if (this.end.line === position.line) {
-              return this.end.character >= position.character;
-            } else {
-              return (
-                this.start.line <= position.line &&
-                this.end.line >= position.line
-              );
-            }
-          };
-          this.start = start2;
-          this.end = end2;
-        }
-        setStart(line, character) {
-          this.start = new Position(line, character);
-        }
-        setEnd(line, character) {
-          this.end = new Position(line, character);
-        }
-      }
-      class Position {
-        constructor(line, character) {
-          this.lessThanOrEqualTo = (position) =>
-            this.line < position.line ||
-            (this.line === position.line &&
-              this.character <= position.character);
-          this.line = line;
-          this.character = character;
-        }
-        setLine(line) {
-          this.line = line;
-        }
-        setCharacter(character) {
-          this.character = character;
-        }
-      }
-      function offsetToPosition(text3, loc) {
-        const EOL = "\n";
-        const buf = text3.slice(0, loc);
-        const lines = buf.split(EOL).length - 1;
-        const lastLineIndex = buf.lastIndexOf(EOL);
-        return new Position(lines, loc - lastLineIndex - 1);
-      }
-      function locToRange(text3, loc) {
-        const start2 = offsetToPosition(text3, loc.start);
-        const end2 = offsetToPosition(text3, loc.end);
-        return new Range(start2, end2);
-      }
-      const specifiedSDLRules = [
-        LoneSchemaDefinitionRule,
-        UniqueOperationTypesRule,
-        UniqueTypeNamesRule,
-        UniqueEnumValueNamesRule,
-        UniqueFieldDefinitionNamesRule,
-        UniqueDirectiveNamesRule,
-        KnownTypeNamesRule,
-        KnownDirectivesRule,
-        UniqueDirectivesPerLocationRule,
-        PossibleTypeExtensionsRule,
-        UniqueArgumentNamesRule,
-        UniqueInputFieldNamesRule,
-      ];
-      function validateWithCustomRules(
-        schema,
-        ast2,
-        customRules,
-        isRelayCompatMode,
-        isSchemaDocument
-      ) {
-        const rules = specifiedRules.filter((rule) => {
-          if (
-            rule === NoUnusedFragmentsRule ||
-            rule === ExecutableDefinitionsRule
-          ) {
-            return false;
-          }
-          if (isRelayCompatMode && rule === KnownFragmentNamesRule) {
-            return false;
-          }
-          return true;
-        });
-        if (customRules) {
-          Array.prototype.push.apply(rules, customRules);
-        }
-        if (isSchemaDocument) {
-          Array.prototype.push.apply(rules, specifiedSDLRules);
-        }
-        const errors2 = validate(schema, ast2, rules);
-        return errors2.filter((error2) => {
-          if (
-            error2.message.indexOf("Unknown directive") !== -1 &&
-            error2.nodes
-          ) {
-            const node = error2.nodes[0];
-            if (node && node.kind === Kind.DIRECTIVE) {
-              const name2 = node.name.value;
-              if (name2 === "arguments" || name2 === "argumentDefinitions") {
-                return false;
-              }
-            }
-          }
-          return true;
-        });
-      }
-      function collectVariables(schema, documentAST) {
-        const variableToType = /* @__PURE__ */ Object.create(null);
-        documentAST.definitions.forEach((definition) => {
-          if (definition.kind === "OperationDefinition") {
-            const variableDefinitions = definition.variableDefinitions;
-            if (variableDefinitions) {
-              variableDefinitions.forEach(({ variable, type: type2 }) => {
-                const inputType = typeFromAST(schema, type2);
-                if (inputType) {
-                  variableToType[variable.name.value] = inputType;
-                } else if (type2.kind === Kind.NAMED_TYPE) {
-                  if (type2.name.value === "Float") {
-                    variableToType[variable.name.value] = GraphQLFloat;
-                  }
-                }
-              });
-            }
-          }
-        });
-        return variableToType;
-      }
-      function getOperationASTFacts(documentAST, schema) {
-        const variableToType = schema
-          ? collectVariables(schema, documentAST)
-          : void 0;
-        const operations = [];
-        visit(documentAST, {
-          OperationDefinition(node) {
-            operations.push(node);
-          },
-        });
-        return { variableToType, operations };
-      }
-      function getOperationFacts(schema, documentString) {
-        if (!documentString) {
-          return;
-        }
-        try {
-          const documentAST = parse$1(documentString);
-          return __spreadProps(
-            __spreadValues({}, getOperationASTFacts(documentAST, schema)),
-            {
-              documentAST,
-            }
-          );
-        } catch {
-          return;
-        }
-      }
-      const getQueryFacts = getOperationFacts;
-      const LANGUAGE = "GraphQL";
-      function assert(value, message) {
-        if (!value) {
-          throw new Error(message);
-        }
-      }
-      function getRange$1(text3, node) {
-        const location2 = node.loc;
-        assert(location2, "Expected ASTNode to have a location.");
-        return locToRange(text3, location2);
-      }
-      function getPosition(text3, node) {
-        const location2 = node.loc;
-        assert(location2, "Expected ASTNode to have a location.");
-        return offsetToPosition(text3, location2.start);
-      }
-      async function getDefinitionQueryResultForNamedType(
-        text3,
-        node,
-        dependencies
-      ) {
-        const name2 = node.name.value;
-        const defNodes = dependencies.filter(
-          ({ definition }) => definition.name && definition.name.value === name2
-        );
-        if (defNodes.length === 0) {
-          throw Error(`Definition not found for GraphQL type ${name2}`);
-        }
-        const definitions = defNodes.map(({ filePath, content, definition }) =>
-          getDefinitionForNodeDefinition(filePath || "", content, definition)
-        );
-        return {
-          definitions,
-          queryRange: definitions.map((_) => getRange$1(text3, node)),
-        };
-      }
-      async function getDefinitionQueryResultForFragmentSpread(
-        text3,
-        fragment,
-        dependencies
-      ) {
-        const name2 = fragment.name.value;
-        const defNodes = dependencies.filter(
-          ({ definition }) => definition.name.value === name2
-        );
-        if (defNodes.length === 0) {
-          throw Error(`Definition not found for GraphQL fragment ${name2}`);
-        }
-        const definitions = defNodes.map(({ filePath, content, definition }) =>
-          getDefinitionForFragmentDefinition(
-            filePath || "",
-            content,
-            definition
-          )
-        );
-        return {
-          definitions,
-          queryRange: definitions.map((_) => getRange$1(text3, fragment)),
-        };
-      }
-      function getDefinitionQueryResultForDefinitionNode(
-        path,
-        text3,
-        definition
-      ) {
-        return {
-          definitions: [
-            getDefinitionForFragmentDefinition(path, text3, definition),
-          ],
-          queryRange: definition.name
-            ? [getRange$1(text3, definition.name)]
-            : [],
-        };
-      }
-      function getDefinitionForFragmentDefinition(path, text3, definition) {
-        const name2 = definition.name;
-        if (!name2) {
-          throw Error("Expected ASTNode to have a Name.");
-        }
-        return {
-          path,
-          position: getPosition(text3, definition),
-          range: getRange$1(text3, definition),
-          name: name2.value || "",
-          language: LANGUAGE,
-          projectRoot: path,
-        };
-      }
-      function getDefinitionForNodeDefinition(path, text3, definition) {
-        const name2 = definition.name;
-        assert(name2, "Expected ASTNode to have a Name.");
-        return {
-          path,
-          position: getPosition(text3, definition),
-          range: getRange$1(text3, definition),
-          name: name2.value || "",
-          language: LANGUAGE,
-          projectRoot: path,
-        };
-      }
-      const SEVERITY$1 = {
-        Error: "Error",
-        Warning: "Warning",
-        Information: "Information",
-        Hint: "Hint",
-      };
-      const DIAGNOSTIC_SEVERITY = {
-        [SEVERITY$1.Error]: 1,
-        [SEVERITY$1.Warning]: 2,
-        [SEVERITY$1.Information]: 3,
-        [SEVERITY$1.Hint]: 4,
-      };
-      const invariant$1 = (condition, message) => {
-        if (!condition) {
-          throw new Error(message);
-        }
-      };
-      function getDiagnostics(
-        query,
-        schema = null,
-        customRules,
-        isRelayCompatMode,
-        externalFragments
-      ) {
-        let ast2 = null;
-        if (externalFragments) {
-          if (typeof externalFragments === "string") {
-            query += "\n\n" + externalFragments;
-          } else {
-            query +=
-              "\n\n" +
-              externalFragments.reduce((agg, node) => {
-                agg += print(node) + "\n\n";
-                return agg;
-              }, "");
-          }
-        }
-        try {
-          ast2 = parse$1(query);
-        } catch (error2) {
-          const range2 = getRange(error2.locations[0], query);
-          return [
-            {
-              severity: DIAGNOSTIC_SEVERITY.Error,
-              message: error2.message,
-              source: "GraphQL: Syntax",
-              range: range2,
-            },
-          ];
-        }
-        return validateQuery(ast2, schema, customRules, isRelayCompatMode);
-      }
-      function validateQuery(
-        ast2,
-        schema = null,
-        customRules,
-        isRelayCompatMode
-      ) {
-        if (!schema) {
-          return [];
-        }
-        const validationErrorAnnotations = mapCat$1(
-          validateWithCustomRules(schema, ast2, customRules, isRelayCompatMode),
-          (error2) =>
-            annotations(error2, DIAGNOSTIC_SEVERITY.Error, "Validation")
-        );
-        const deprecationWarningAnnotations = mapCat$1(
-          validate(schema, ast2, [NoDeprecatedCustomRule]),
-          (error2) =>
-            annotations(error2, DIAGNOSTIC_SEVERITY.Warning, "Deprecation")
-        );
-        return validationErrorAnnotations.concat(deprecationWarningAnnotations);
-      }
-      function mapCat$1(array, mapper) {
-        return Array.prototype.concat.apply([], array.map(mapper));
-      }
-      function annotations(error2, severity, type2) {
-        if (!error2.nodes) {
-          return [];
-        }
-        const highlightedNodes = [];
-        error2.nodes.forEach((node) => {
-          const highlightNode =
-            node.kind !== "Variable" && "name" in node && node.name !== void 0
-              ? node.name
-              : "variable" in node && node.variable !== void 0
-              ? node.variable
-              : node;
-          if (highlightNode) {
-            invariant$1(
-              error2.locations,
-              "GraphQL validation error requires locations."
-            );
-            const loc = error2.locations[0];
-            const highlightLoc = getLocation(highlightNode);
-            const end2 = loc.column + (highlightLoc.end - highlightLoc.start);
-            highlightedNodes.push({
-              source: `GraphQL: ${type2}`,
-              message: error2.message,
-              severity,
-              range: new Range(
-                new Position(loc.line - 1, loc.column - 1),
-                new Position(loc.line - 1, end2)
-              ),
-            });
-          }
-        });
-        return highlightedNodes;
-      }
-      function getRange(location2, queryText) {
-        const parser = onlineParser();
-        const state = parser.startState();
-        const lines = queryText.split("\n");
-        invariant$1(
-          lines.length >= location2.line,
-          "Query text must have more lines than where the error happened"
-        );
-        let stream = null;
-        for (let i = 0; i < location2.line; i++) {
-          stream = new CharacterStream(lines[i]);
-          while (!stream.eol()) {
-            const style = parser.token(stream, state);
-            if (style === "invalidchar") {
-              break;
-            }
-          }
-        }
-        invariant$1(stream, "Expected Parser stream to be available.");
-        const line = location2.line - 1;
-        const start2 = stream.getStartOfToken();
-        const end2 = stream.getCurrentPosition();
-        return new Range(new Position(line, start2), new Position(line, end2));
-      }
-      function getLocation(node) {
-        const typeCastedNode = node;
-        const location2 = typeCastedNode.loc;
-        invariant$1(location2, "Expected ASTNode to have a location.");
-        return location2;
-      }
-      const { INLINE_FRAGMENT } = Kind;
-      function getOutline(documentText) {
-        let ast2;
-        try {
-          ast2 = parse$1(documentText);
-        } catch (error2) {
-          return null;
-        }
-        const visitorFns = outlineTreeConverter(documentText);
-        const outlineTrees = visit(ast2, {
-          leave(node) {
-            if (visitorFns !== void 0 && node.kind in visitorFns) {
-              return visitorFns[node.kind](node);
-            }
-            return null;
-          },
-        });
-        return { outlineTrees };
-      }
-      function outlineTreeConverter(docText) {
-        const meta = (node) => {
-          return {
-            representativeName: node.name,
-            startPosition: offsetToPosition(docText, node.loc.start),
-            endPosition: offsetToPosition(docText, node.loc.end),
-            kind: node.kind,
-            children:
-              node.selectionSet ||
-              node.fields ||
-              node.values ||
-              node.arguments ||
-              [],
-          };
-        };
-        return {
-          Field: (node) => {
-            const tokenizedText = node.alias
-              ? [buildToken("plain", node.alias), buildToken("plain", ": ")]
-              : [];
-            tokenizedText.push(buildToken("plain", node.name));
-            return __spreadValues({ tokenizedText }, meta(node));
-          },
-          OperationDefinition: (node) =>
-            __spreadValues(
-              {
-                tokenizedText: [
-                  buildToken("keyword", node.operation),
-                  buildToken("whitespace", " "),
-                  buildToken("class-name", node.name),
-                ],
-              },
-              meta(node)
-            ),
-          Document: (node) => node.definitions,
-          SelectionSet: (node) =>
-            concatMap(node.selections, (child) => {
-              return child.kind === INLINE_FRAGMENT
-                ? child.selectionSet
-                : child;
-            }),
-          Name: (node) => node.value,
-          FragmentDefinition: (node) =>
-            __spreadValues(
-              {
-                tokenizedText: [
-                  buildToken("keyword", "fragment"),
-                  buildToken("whitespace", " "),
-                  buildToken("class-name", node.name),
-                ],
-              },
-              meta(node)
-            ),
-          InterfaceTypeDefinition: (node) =>
-            __spreadValues(
-              {
-                tokenizedText: [
-                  buildToken("keyword", "interface"),
-                  buildToken("whitespace", " "),
-                  buildToken("class-name", node.name),
-                ],
-              },
-              meta(node)
-            ),
-          EnumTypeDefinition: (node) =>
-            __spreadValues(
-              {
-                tokenizedText: [
-                  buildToken("keyword", "enum"),
-                  buildToken("whitespace", " "),
-                  buildToken("class-name", node.name),
-                ],
-              },
-              meta(node)
-            ),
-          EnumValueDefinition: (node) =>
-            __spreadValues(
-              {
-                tokenizedText: [buildToken("plain", node.name)],
-              },
-              meta(node)
-            ),
-          ObjectTypeDefinition: (node) =>
-            __spreadValues(
-              {
-                tokenizedText: [
-                  buildToken("keyword", "type"),
-                  buildToken("whitespace", " "),
-                  buildToken("class-name", node.name),
-                ],
-              },
-              meta(node)
-            ),
-          InputObjectTypeDefinition: (node) =>
-            __spreadValues(
-              {
-                tokenizedText: [
-                  buildToken("keyword", "input"),
-                  buildToken("whitespace", " "),
-                  buildToken("class-name", node.name),
-                ],
-              },
-              meta(node)
-            ),
-          FragmentSpread: (node) =>
-            __spreadValues(
-              {
-                tokenizedText: [
-                  buildToken("plain", "..."),
-                  buildToken("class-name", node.name),
-                ],
-              },
-              meta(node)
-            ),
-          InputValueDefinition: (node) => {
-            return __spreadValues(
-              {
-                tokenizedText: [buildToken("plain", node.name)],
-              },
-              meta(node)
-            );
-          },
-          FieldDefinition: (node) => {
-            return __spreadValues(
-              {
-                tokenizedText: [buildToken("plain", node.name)],
-              },
-              meta(node)
-            );
-          },
-          InlineFragment: (node) => node.selectionSet,
-        };
-      }
-      function buildToken(kind2, value) {
-        return { kind: kind2, value };
-      }
-      function concatMap(arr, fn) {
-        const res = [];
-        for (let i = 0; i < arr.length; i++) {
-          const x2 = fn(arr[i], i);
-          if (Array.isArray(x2)) {
-            res.push(...x2);
-          } else {
-            res.push(x2);
-          }
-        }
-        return res;
-      }
-      function getHoverInformation(
-        schema,
-        queryText,
-        cursor,
-        contextToken,
-        config2
-      ) {
-        const token2 = contextToken || getTokenAtPosition(queryText, cursor);
-        if (!schema || !token2 || !token2.state) {
-          return "";
-        }
-        const state = token2.state;
-        const kind2 = state.kind;
-        const step = state.step;
-        const typeInfo = getTypeInfo$3(schema, token2.state);
-        const options = __spreadProps(__spreadValues({}, config2), { schema });
-        if (
-          (kind2 === "Field" && step === 0 && typeInfo.fieldDef) ||
-          (kind2 === "AliasedField" && step === 2 && typeInfo.fieldDef)
-        ) {
-          const into = [];
-          renderMdCodeStart(into, options);
-          renderField$1(into, typeInfo, options);
-          renderMdCodeEnd(into, options);
-          renderDescription$1(into, options, typeInfo.fieldDef);
-          return into.join("").trim();
-        } else if (
-          kind2 === "Directive" &&
-          step === 1 &&
-          typeInfo.directiveDef
-        ) {
-          const into = [];
-          renderMdCodeStart(into, options);
-          renderDirective$1(into, typeInfo);
-          renderMdCodeEnd(into, options);
-          renderDescription$1(into, options, typeInfo.directiveDef);
-          return into.join("").trim();
-        } else if (kind2 === "Argument" && step === 0 && typeInfo.argDef) {
-          const into = [];
-          renderMdCodeStart(into, options);
-          renderArg$1(into, typeInfo, options);
-          renderMdCodeEnd(into, options);
-          renderDescription$1(into, options, typeInfo.argDef);
-          return into.join("").trim();
-        } else if (
-          kind2 === "EnumValue" &&
-          typeInfo.enumValue &&
-          "description" in typeInfo.enumValue
-        ) {
-          const into = [];
-          renderMdCodeStart(into, options);
-          renderEnumValue$1(into, typeInfo, options);
-          renderMdCodeEnd(into, options);
-          renderDescription$1(into, options, typeInfo.enumValue);
-          return into.join("").trim();
-        } else if (
-          kind2 === "NamedType" &&
-          typeInfo.type &&
-          "description" in typeInfo.type
-        ) {
-          const into = [];
-          renderMdCodeStart(into, options);
-          renderType$3(into, typeInfo, options, typeInfo.type);
-          renderMdCodeEnd(into, options);
-          renderDescription$1(into, options, typeInfo.type);
-          return into.join("").trim();
-        }
-        return "";
-      }
-      function renderMdCodeStart(into, options) {
-        if (options.useMarkdown) {
-          text$2(into, "```graphql\n");
-        }
-      }
-      function renderMdCodeEnd(into, options) {
-        if (options.useMarkdown) {
-          text$2(into, "\n```");
-        }
-      }
-      function renderField$1(into, typeInfo, options) {
-        renderQualifiedField$1(into, typeInfo, options);
-        renderTypeAnnotation$1(into, typeInfo, options, typeInfo.type);
-      }
-      function renderQualifiedField$1(into, typeInfo, options) {
-        if (!typeInfo.fieldDef) {
-          return;
-        }
-        const fieldName = typeInfo.fieldDef.name;
-        if (fieldName.slice(0, 2) !== "__") {
-          renderType$3(into, typeInfo, options, typeInfo.parentType);
-          text$2(into, ".");
-        }
-        text$2(into, fieldName);
-      }
-      function renderDirective$1(into, typeInfo, _options) {
-        if (!typeInfo.directiveDef) {
-          return;
-        }
-        const name2 = "@" + typeInfo.directiveDef.name;
-        text$2(into, name2);
-      }
-      function renderArg$1(into, typeInfo, options) {
-        if (typeInfo.directiveDef) {
-          renderDirective$1(into, typeInfo);
-        } else if (typeInfo.fieldDef) {
-          renderQualifiedField$1(into, typeInfo, options);
-        }
-        if (!typeInfo.argDef) {
-          return;
-        }
-        const name2 = typeInfo.argDef.name;
-        text$2(into, "(");
-        text$2(into, name2);
-        renderTypeAnnotation$1(into, typeInfo, options, typeInfo.inputType);
-        text$2(into, ")");
-      }
-      function renderTypeAnnotation$1(into, typeInfo, options, t2) {
-        text$2(into, ": ");
-        renderType$3(into, typeInfo, options, t2);
-      }
-      function renderEnumValue$1(into, typeInfo, options) {
-        if (!typeInfo.enumValue) {
-          return;
-        }
-        const name2 = typeInfo.enumValue.name;
-        renderType$3(into, typeInfo, options, typeInfo.inputType);
-        text$2(into, ".");
-        text$2(into, name2);
-      }
-      function renderType$3(into, typeInfo, options, t2) {
-        if (!t2) {
-          return;
-        }
-        if (t2 instanceof GraphQLNonNull) {
-          renderType$3(into, typeInfo, options, t2.ofType);
-          text$2(into, "!");
-        } else if (t2 instanceof GraphQLList) {
-          text$2(into, "[");
-          renderType$3(into, typeInfo, options, t2.ofType);
-          text$2(into, "]");
-        } else {
-          text$2(into, t2.name);
-        }
-      }
-      function renderDescription$1(into, options, def) {
-        if (!def) {
-          return;
-        }
-        const description =
-          typeof def.description === "string" ? def.description : null;
-        if (description) {
-          text$2(into, "\n\n");
-          text$2(into, description);
-        }
-        renderDeprecation$1(into, options, def);
-      }
-      function renderDeprecation$1(into, _options, def) {
-        if (!def) {
-          return;
-        }
-        const reason = def.deprecationReason ? def.deprecationReason : null;
-        if (!reason) {
-          return;
-        }
-        text$2(into, "\n\n");
-        text$2(into, "Deprecated: ");
-        text$2(into, reason);
-      }
-      function text$2(into, content) {
-        into.push(content);
-      }
-      const FileChangeTypeKind = {
-        Created: 1,
-        Changed: 2,
-        Deleted: 3,
-      };
-      var CompletionItemKind;
-      (function (CompletionItemKind2) {
-        CompletionItemKind2.Text = 1;
-        CompletionItemKind2.Method = 2;
-        CompletionItemKind2.Function = 3;
-        CompletionItemKind2.Constructor = 4;
-        CompletionItemKind2.Field = 5;
-        CompletionItemKind2.Variable = 6;
-        CompletionItemKind2.Class = 7;
-        CompletionItemKind2.Interface = 8;
-        CompletionItemKind2.Module = 9;
-        CompletionItemKind2.Property = 10;
-        CompletionItemKind2.Unit = 11;
-        CompletionItemKind2.Value = 12;
-        CompletionItemKind2.Enum = 13;
-        CompletionItemKind2.Keyword = 14;
-        CompletionItemKind2.Snippet = 15;
-        CompletionItemKind2.Color = 16;
-        CompletionItemKind2.File = 17;
-        CompletionItemKind2.Reference = 18;
-        CompletionItemKind2.Folder = 19;
-        CompletionItemKind2.EnumMember = 20;
-        CompletionItemKind2.Constant = 21;
-        CompletionItemKind2.Struct = 22;
-        CompletionItemKind2.Event = 23;
-        CompletionItemKind2.Operator = 24;
-        CompletionItemKind2.TypeParameter = 25;
-      })(CompletionItemKind || (CompletionItemKind = {}));
-      var esm = /* @__PURE__ */ Object.freeze({
-        __proto__: null,
-        [Symbol.toStringTag]: "Module",
-        getAutocompleteSuggestions,
-        getDefinitionQueryResultForDefinitionNode,
-        getDefinitionQueryResultForFragmentSpread,
-        getDefinitionQueryResultForNamedType,
-        getDefinitionState,
-        getDiagnostics,
-        getFieldDef: getFieldDef$1,
-        getFragmentDefinitions,
-        getHoverInformation,
-        getOutline,
-        getRange,
-        getTokenAtPosition,
-        getTypeInfo: getTypeInfo$3,
-        getVariableCompletions,
-        SEVERITY: SEVERITY$1,
-        DIAGNOSTIC_SEVERITY,
-        canUseDirective,
-        SuggestionCommand,
-        validateQuery,
-        onlineParser,
-        ParseRules: ParseRules$2,
-        CharacterStream,
-        RuleKinds,
-        LexRules: LexRules$2,
-        isIgnored,
-        p,
-        list: list$1,
-        t,
-        opt,
-        get CompletionItemKind() {
-          return CompletionItemKind;
-        },
-        FileChangeTypeKind,
-        getASTNodeAtPosition,
-        getFragmentDependencies,
-        getFragmentDependenciesForAST,
-        getOperationASTFacts,
-        getOperationFacts,
-        getQueryFacts,
-        getVariablesJSONSchema,
-        offsetToPosition,
-        pointToOffset,
-        Position,
-        collectVariables,
-        validateWithCustomRules,
-        Range,
-      });
-      var __extends$f =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var ExecuteButton = (function (_super2) {
-        __extends$f(ExecuteButton2, _super2);
-        function ExecuteButton2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this._onClick = function () {
-            if (_this.props.isRunning) {
-              _this.props.onStop();
-            } else {
-              _this.props.onRun();
-            }
-          };
-          _this._onOptionSelected = function (operation) {
-            _this.setState({ optionsOpen: false });
-            _this.props.onRun(operation.name && operation.name.value);
-          };
-          _this._onOptionsOpen = function (downEvent) {
-            var initialPress = true;
-            var downTarget = downEvent.currentTarget;
-            _this.setState({ highlight: null, optionsOpen: true });
-            var onMouseUp = function (upEvent) {
-              var _a2;
-              if (initialPress && upEvent.target === downTarget) {
-                initialPress = false;
-              } else {
-                document.removeEventListener("mouseup", onMouseUp);
-                onMouseUp = null;
-                var isOptionsMenuClicked =
-                  upEvent.currentTarget &&
-                  ((_a2 = downTarget.parentNode) === null || _a2 === void 0
-                    ? void 0
-                    : _a2.compareDocumentPosition(upEvent.currentTarget)) &&
-                  Node.DOCUMENT_POSITION_CONTAINED_BY;
-                if (!isOptionsMenuClicked) {
-                  _this.setState({ optionsOpen: false });
-                }
-              }
-            };
-            document.addEventListener("mouseup", onMouseUp);
-          };
-          _this.state = {
-            optionsOpen: false,
-            highlight: null,
-          };
-          return _this;
-        }
-        ExecuteButton2.prototype.render = function () {
-          var _this = this;
-          var operations = this.props.operations || [];
-          var optionsOpen = this.state.optionsOpen;
-          var hasOptions = operations && operations.length > 1;
-          var options = null;
-          if (hasOptions && optionsOpen) {
-            var highlight_1 = this.state.highlight;
-            options = React$1.createElement(
-              "ul",
-              { className: "execute-options" },
-              operations.map(function (operation, i) {
-                var opName = operation.name
-                  ? operation.name.value
-                  : "<Unnamed " + operation.operation + ">";
-                return React$1.createElement(
-                  "li",
-                  {
-                    key: opName + "-" + i,
-                    className: operation === highlight_1 ? "selected" : void 0,
-                    onMouseOver: function () {
-                      return _this.setState({ highlight: operation });
-                    },
-                    onMouseOut: function () {
-                      return _this.setState({ highlight: null });
-                    },
-                    onMouseUp: function () {
-                      return _this._onOptionSelected(operation);
-                    },
-                  },
-                  opName
-                );
-              })
-            );
-          }
-          var onClick;
-          if (this.props.isRunning || !hasOptions) {
-            onClick = this._onClick;
-          }
-          var onMouseDown = function () {};
-          if (!this.props.isRunning && hasOptions && !optionsOpen) {
-            onMouseDown = this._onOptionsOpen;
-          }
-          var pathJSX = this.props.isRunning
-            ? React$1.createElement("path", {
-                d: "M 10 10 L 23 10 L 23 23 L 10 23 z",
-              })
-            : React$1.createElement("path", { d: "M 11 9 L 24 16 L 11 23 z" });
-          return React$1.createElement(
-            "div",
-            { className: "execute-button-wrap" },
-            React$1.createElement(
-              "button",
-              {
-                type: "button",
-                className: "execute-button",
-                onMouseDown,
-                onClick,
-                title: "Execute Query (Ctrl-Enter)",
-              },
-              React$1.createElement(
-                "svg",
-                { width: "34", height: "34" },
-                pathJSX
-              )
-            ),
-            options
-          );
-        };
-        return ExecuteButton2;
-      })(React$1.Component);
-      var __extends$e =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      function tokenToURL(token2) {
-        if (token2.type !== "string") {
-          return;
-        }
-        var value = token2.string.slice(1).slice(0, -1).trim();
-        try {
-          var location_1 = window.location;
-          return new URL(value, location_1.protocol + "//" + location_1.host);
-        } catch (err) {
-          return;
-        }
-      }
-      function isImageURL(url) {
-        return /(bmp|gif|jpeg|jpg|png|svg)$/.test(url.pathname);
-      }
-      var ImagePreview = (function (_super2) {
-        __extends$e(ImagePreview2, _super2);
-        function ImagePreview2() {
-          var _this =
-            (_super2 !== null && _super2.apply(this, arguments)) || this;
-          _this._node = null;
-          _this.state = {
-            width: null,
-            height: null,
-            src: null,
-            mime: null,
-          };
-          return _this;
-        }
-        ImagePreview2.shouldRender = function (token2) {
-          var url = tokenToURL(token2);
-          return url ? isImageURL(url) : false;
-        };
-        ImagePreview2.prototype.componentDidMount = function () {
-          this._updateMetadata();
-        };
-        ImagePreview2.prototype.componentDidUpdate = function () {
-          this._updateMetadata();
-        };
-        ImagePreview2.prototype.render = function () {
-          var _this = this;
-          var _a2;
-          var dims = null;
-          if (this.state.width !== null && this.state.height !== null) {
-            var dimensions = this.state.width + "x" + this.state.height;
-            if (this.state.mime !== null) {
-              dimensions += " " + this.state.mime;
-            }
-            dims = React$1.createElement("div", null, dimensions);
-          }
-          return React$1.createElement(
-            "div",
-            null,
-            React$1.createElement("img", {
-              onLoad: function () {
-                return _this._updateMetadata();
-              },
-              ref: function (node) {
-                _this._node = node;
-              },
-              src:
-                (_a2 = tokenToURL(this.props.token)) === null || _a2 === void 0
-                  ? void 0
-                  : _a2.href,
-            }),
-            dims
-          );
-        };
-        ImagePreview2.prototype._updateMetadata = function () {
-          var _this = this;
-          if (!this._node) {
-            return;
-          }
-          var width = this._node.naturalWidth;
-          var height = this._node.naturalHeight;
-          var src = this._node.src;
-          if (src !== this.state.src) {
-            this.setState({ src });
-            fetch(src, { method: "HEAD" }).then(function (response) {
-              _this.setState({
-                mime: response.headers.get("Content-Type"),
-              });
-            });
-          }
-          if (width !== this.state.width || height !== this.state.height) {
-            this.setState({ height, width });
-          }
-        };
-        return ImagePreview2;
-      })(React$1.Component);
-      var __extends$d =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var ToolbarButton = (function (_super2) {
-        __extends$d(ToolbarButton2, _super2);
-        function ToolbarButton2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this.handleClick = function () {
-            try {
-              _this.props.onClick();
-              _this.setState({ error: null });
-            } catch (error2) {
-              _this.setState({ error: error2 });
-            }
-          };
-          _this.state = { error: null };
-          return _this;
-        }
-        ToolbarButton2.prototype.render = function () {
-          var error2 = this.state.error;
-          return React$1.createElement(
-            "button",
-            {
-              className: "toolbar-button" + (error2 ? " error" : ""),
-              onClick: this.handleClick,
-              title: error2 ? error2.message : this.props.title,
-              "aria-invalid": error2 ? "true" : "false",
-            },
-            this.props.label
-          );
-        };
-        return ToolbarButton2;
-      })(React$1.Component);
-      function ToolbarGroup(_a2) {
-        var children = _a2.children;
-        return React$1.createElement(
-          "div",
-          { className: "toolbar-button-group" },
-          children
-        );
-      }
-      var __extends$c =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var ToolbarMenu = (function (_super2) {
-        __extends$c(ToolbarMenu2, _super2);
-        function ToolbarMenu2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this._node = null;
-          _this._listener = null;
-          _this.handleOpen = function (e) {
-            preventDefault$1(e);
-            _this.setState({ visible: true });
-            _this._subscribe();
-          };
-          _this.state = { visible: false };
-          return _this;
-        }
-        ToolbarMenu2.prototype.componentWillUnmount = function () {
-          this._release();
-        };
-        ToolbarMenu2.prototype.render = function () {
-          var _this = this;
-          var visible = this.state.visible;
-          return React$1.createElement(
-            "a",
-            {
-              className: "toolbar-menu toolbar-button",
-              onClick: this.handleOpen.bind(this),
-              onMouseDown: preventDefault$1,
-              ref: function (node) {
-                if (node) {
-                  _this._node = node;
-                }
-              },
-              title: this.props.title,
-            },
-            this.props.label,
-            React$1.createElement(
-              "svg",
-              { width: "14", height: "8" },
-              React$1.createElement("path", {
-                fill: "#666",
-                d: "M 5 1.5 L 14 1.5 L 9.5 7 z",
-              })
-            ),
-            React$1.createElement(
-              "ul",
-              { className: "toolbar-menu-items" + (visible ? " open" : "") },
-              this.props.children
-            )
-          );
-        };
-        ToolbarMenu2.prototype._subscribe = function () {
-          if (!this._listener) {
-            this._listener = this.handleClick.bind(this);
-            document.addEventListener("click", this._listener);
-          }
-        };
-        ToolbarMenu2.prototype._release = function () {
-          if (this._listener) {
-            document.removeEventListener("click", this._listener);
-            this._listener = null;
-          }
-        };
-        ToolbarMenu2.prototype.handleClick = function (e) {
-          if (this._node !== e.target) {
-            e.preventDefault();
-            this.setState({ visible: false });
-            this._release();
-          }
-        };
-        return ToolbarMenu2;
-      })(React$1.Component);
-      var ToolbarMenuItem = function (_a2) {
-        var onSelect = _a2.onSelect,
-          title = _a2.title,
-          label = _a2.label;
-        return React$1.createElement(
-          "li",
-          {
-            onMouseOver: function (e) {
-              e.currentTarget.className = "hover";
-            },
-            onMouseOut: function (e) {
-              e.currentTarget.className = "";
-            },
-            onMouseDown: preventDefault$1,
-            onMouseUp: onSelect,
-            title,
-          },
-          label
-        );
-      };
-      function preventDefault$1(e) {
-        e.preventDefault();
-      }
-      var utils$1 = {};
-      const Aacute = "\xC1";
-      const aacute = "\xE1";
-      const Abreve = "\u0102";
-      const abreve = "\u0103";
-      const ac = "\u223E";
-      const acd = "\u223F";
-      const acE = "\u223E\u0333";
-      const Acirc = "\xC2";
-      const acirc = "\xE2";
-      const acute = "\xB4";
-      const Acy = "\u0410";
-      const acy = "\u0430";
-      const AElig = "\xC6";
-      const aelig = "\xE6";
-      const af = "\u2061";
-      const Afr = "\u{1D504}";
-      const afr = "\u{1D51E}";
-      const Agrave = "\xC0";
-      const agrave = "\xE0";
-      const alefsym = "\u2135";
-      const aleph = "\u2135";
-      const Alpha = "\u0391";
-      const alpha = "\u03B1";
-      const Amacr = "\u0100";
-      const amacr = "\u0101";
-      const amalg = "\u2A3F";
-      const amp = "&";
-      const AMP = "&";
-      const andand = "\u2A55";
-      const And = "\u2A53";
-      const and = "\u2227";
-      const andd = "\u2A5C";
-      const andslope = "\u2A58";
-      const andv = "\u2A5A";
-      const ang = "\u2220";
-      const ange = "\u29A4";
-      const angle = "\u2220";
-      const angmsdaa = "\u29A8";
-      const angmsdab = "\u29A9";
-      const angmsdac = "\u29AA";
-      const angmsdad = "\u29AB";
-      const angmsdae = "\u29AC";
-      const angmsdaf = "\u29AD";
-      const angmsdag = "\u29AE";
-      const angmsdah = "\u29AF";
-      const angmsd = "\u2221";
-      const angrt = "\u221F";
-      const angrtvb = "\u22BE";
-      const angrtvbd = "\u299D";
-      const angsph = "\u2222";
-      const angst = "\xC5";
-      const angzarr = "\u237C";
-      const Aogon = "\u0104";
-      const aogon = "\u0105";
-      const Aopf = "\u{1D538}";
-      const aopf = "\u{1D552}";
-      const apacir = "\u2A6F";
-      const ap = "\u2248";
-      const apE = "\u2A70";
-      const ape = "\u224A";
-      const apid = "\u224B";
-      const apos = "'";
-      const ApplyFunction = "\u2061";
-      const approx = "\u2248";
-      const approxeq = "\u224A";
-      const Aring = "\xC5";
-      const aring = "\xE5";
-      const Ascr = "\u{1D49C}";
-      const ascr = "\u{1D4B6}";
-      const Assign = "\u2254";
-      const ast = "*";
-      const asymp = "\u2248";
-      const asympeq = "\u224D";
-      const Atilde = "\xC3";
-      const atilde = "\xE3";
-      const Auml = "\xC4";
-      const auml = "\xE4";
-      const awconint = "\u2233";
-      const awint = "\u2A11";
-      const backcong = "\u224C";
-      const backepsilon = "\u03F6";
-      const backprime = "\u2035";
-      const backsim = "\u223D";
-      const backsimeq = "\u22CD";
-      const Backslash = "\u2216";
-      const Barv = "\u2AE7";
-      const barvee = "\u22BD";
-      const barwed = "\u2305";
-      const Barwed = "\u2306";
-      const barwedge = "\u2305";
-      const bbrk = "\u23B5";
-      const bbrktbrk = "\u23B6";
-      const bcong = "\u224C";
-      const Bcy = "\u0411";
-      const bcy = "\u0431";
-      const bdquo = "\u201E";
-      const becaus = "\u2235";
-      const because = "\u2235";
-      const Because = "\u2235";
-      const bemptyv = "\u29B0";
-      const bepsi = "\u03F6";
-      const bernou = "\u212C";
-      const Bernoullis = "\u212C";
-      const Beta = "\u0392";
-      const beta = "\u03B2";
-      const beth = "\u2136";
-      const between = "\u226C";
-      const Bfr = "\u{1D505}";
-      const bfr = "\u{1D51F}";
-      const bigcap = "\u22C2";
-      const bigcirc = "\u25EF";
-      const bigcup = "\u22C3";
-      const bigodot = "\u2A00";
-      const bigoplus = "\u2A01";
-      const bigotimes = "\u2A02";
-      const bigsqcup = "\u2A06";
-      const bigstar = "\u2605";
-      const bigtriangledown = "\u25BD";
-      const bigtriangleup = "\u25B3";
-      const biguplus = "\u2A04";
-      const bigvee = "\u22C1";
-      const bigwedge = "\u22C0";
-      const bkarow = "\u290D";
-      const blacklozenge = "\u29EB";
-      const blacksquare = "\u25AA";
-      const blacktriangle = "\u25B4";
-      const blacktriangledown = "\u25BE";
-      const blacktriangleleft = "\u25C2";
-      const blacktriangleright = "\u25B8";
-      const blank = "\u2423";
-      const blk12 = "\u2592";
-      const blk14 = "\u2591";
-      const blk34 = "\u2593";
-      const block$2 = "\u2588";
-      const bne = "=\u20E5";
-      const bnequiv = "\u2261\u20E5";
-      const bNot = "\u2AED";
-      const bnot = "\u2310";
-      const Bopf = "\u{1D539}";
-      const bopf = "\u{1D553}";
-      const bot = "\u22A5";
-      const bottom = "\u22A5";
-      const bowtie = "\u22C8";
-      const boxbox = "\u29C9";
-      const boxdl = "\u2510";
-      const boxdL = "\u2555";
-      const boxDl = "\u2556";
-      const boxDL = "\u2557";
-      const boxdr = "\u250C";
-      const boxdR = "\u2552";
-      const boxDr = "\u2553";
-      const boxDR = "\u2554";
-      const boxh = "\u2500";
-      const boxH = "\u2550";
-      const boxhd = "\u252C";
-      const boxHd = "\u2564";
-      const boxhD = "\u2565";
-      const boxHD = "\u2566";
-      const boxhu = "\u2534";
-      const boxHu = "\u2567";
-      const boxhU = "\u2568";
-      const boxHU = "\u2569";
-      const boxminus = "\u229F";
-      const boxplus = "\u229E";
-      const boxtimes = "\u22A0";
-      const boxul = "\u2518";
-      const boxuL = "\u255B";
-      const boxUl = "\u255C";
-      const boxUL = "\u255D";
-      const boxur = "\u2514";
-      const boxuR = "\u2558";
-      const boxUr = "\u2559";
-      const boxUR = "\u255A";
-      const boxv = "\u2502";
-      const boxV = "\u2551";
-      const boxvh = "\u253C";
-      const boxvH = "\u256A";
-      const boxVh = "\u256B";
-      const boxVH = "\u256C";
-      const boxvl = "\u2524";
-      const boxvL = "\u2561";
-      const boxVl = "\u2562";
-      const boxVL = "\u2563";
-      const boxvr = "\u251C";
-      const boxvR = "\u255E";
-      const boxVr = "\u255F";
-      const boxVR = "\u2560";
-      const bprime = "\u2035";
-      const breve = "\u02D8";
-      const Breve = "\u02D8";
-      const brvbar = "\xA6";
-      const bscr = "\u{1D4B7}";
-      const Bscr = "\u212C";
-      const bsemi = "\u204F";
-      const bsim = "\u223D";
-      const bsime = "\u22CD";
-      const bsolb = "\u29C5";
-      const bsol = "\\";
-      const bsolhsub = "\u27C8";
-      const bull = "\u2022";
-      const bullet = "\u2022";
-      const bump = "\u224E";
-      const bumpE = "\u2AAE";
-      const bumpe = "\u224F";
-      const Bumpeq = "\u224E";
-      const bumpeq = "\u224F";
-      const Cacute = "\u0106";
-      const cacute = "\u0107";
-      const capand = "\u2A44";
-      const capbrcup = "\u2A49";
-      const capcap = "\u2A4B";
-      const cap = "\u2229";
-      const Cap = "\u22D2";
-      const capcup = "\u2A47";
-      const capdot = "\u2A40";
-      const CapitalDifferentialD = "\u2145";
-      const caps = "\u2229\uFE00";
-      const caret = "\u2041";
-      const caron = "\u02C7";
-      const Cayleys = "\u212D";
-      const ccaps = "\u2A4D";
-      const Ccaron = "\u010C";
-      const ccaron = "\u010D";
-      const Ccedil = "\xC7";
-      const ccedil = "\xE7";
-      const Ccirc = "\u0108";
-      const ccirc = "\u0109";
-      const Cconint = "\u2230";
-      const ccups = "\u2A4C";
-      const ccupssm = "\u2A50";
-      const Cdot = "\u010A";
-      const cdot = "\u010B";
-      const cedil = "\xB8";
-      const Cedilla = "\xB8";
-      const cemptyv = "\u29B2";
-      const cent = "\xA2";
-      const centerdot = "\xB7";
-      const CenterDot = "\xB7";
-      const cfr = "\u{1D520}";
-      const Cfr = "\u212D";
-      const CHcy = "\u0427";
-      const chcy = "\u0447";
-      const check = "\u2713";
-      const checkmark = "\u2713";
-      const Chi = "\u03A7";
-      const chi = "\u03C7";
-      const circ = "\u02C6";
-      const circeq = "\u2257";
-      const circlearrowleft = "\u21BA";
-      const circlearrowright = "\u21BB";
-      const circledast = "\u229B";
-      const circledcirc = "\u229A";
-      const circleddash = "\u229D";
-      const CircleDot = "\u2299";
-      const circledR = "\xAE";
-      const circledS = "\u24C8";
-      const CircleMinus = "\u2296";
-      const CirclePlus = "\u2295";
-      const CircleTimes = "\u2297";
-      const cir = "\u25CB";
-      const cirE = "\u29C3";
-      const cire = "\u2257";
-      const cirfnint = "\u2A10";
-      const cirmid = "\u2AEF";
-      const cirscir = "\u29C2";
-      const ClockwiseContourIntegral = "\u2232";
-      const CloseCurlyDoubleQuote = "\u201D";
-      const CloseCurlyQuote = "\u2019";
-      const clubs = "\u2663";
-      const clubsuit = "\u2663";
-      const colon = ":";
-      const Colon = "\u2237";
-      const Colone = "\u2A74";
-      const colone = "\u2254";
-      const coloneq = "\u2254";
-      const comma = ",";
-      const commat = "@";
-      const comp = "\u2201";
-      const compfn = "\u2218";
-      const complement = "\u2201";
-      const complexes = "\u2102";
-      const cong = "\u2245";
-      const congdot = "\u2A6D";
-      const Congruent = "\u2261";
-      const conint = "\u222E";
-      const Conint = "\u222F";
-      const ContourIntegral = "\u222E";
-      const copf = "\u{1D554}";
-      const Copf = "\u2102";
-      const coprod = "\u2210";
-      const Coproduct = "\u2210";
-      const copy = "\xA9";
-      const COPY = "\xA9";
-      const copysr = "\u2117";
-      const CounterClockwiseContourIntegral = "\u2233";
-      const crarr = "\u21B5";
-      const cross = "\u2717";
-      const Cross = "\u2A2F";
-      const Cscr = "\u{1D49E}";
-      const cscr = "\u{1D4B8}";
-      const csub = "\u2ACF";
-      const csube = "\u2AD1";
-      const csup = "\u2AD0";
-      const csupe = "\u2AD2";
-      const ctdot = "\u22EF";
-      const cudarrl = "\u2938";
-      const cudarrr = "\u2935";
-      const cuepr = "\u22DE";
-      const cuesc = "\u22DF";
-      const cularr = "\u21B6";
-      const cularrp = "\u293D";
-      const cupbrcap = "\u2A48";
-      const cupcap = "\u2A46";
-      const CupCap = "\u224D";
-      const cup = "\u222A";
-      const Cup = "\u22D3";
-      const cupcup = "\u2A4A";
-      const cupdot = "\u228D";
-      const cupor = "\u2A45";
-      const cups = "\u222A\uFE00";
-      const curarr = "\u21B7";
-      const curarrm = "\u293C";
-      const curlyeqprec = "\u22DE";
-      const curlyeqsucc = "\u22DF";
-      const curlyvee = "\u22CE";
-      const curlywedge = "\u22CF";
-      const curren = "\xA4";
-      const curvearrowleft = "\u21B6";
-      const curvearrowright = "\u21B7";
-      const cuvee = "\u22CE";
-      const cuwed = "\u22CF";
-      const cwconint = "\u2232";
-      const cwint = "\u2231";
-      const cylcty = "\u232D";
-      const dagger = "\u2020";
-      const Dagger = "\u2021";
-      const daleth = "\u2138";
-      const darr = "\u2193";
-      const Darr = "\u21A1";
-      const dArr = "\u21D3";
-      const dash = "\u2010";
-      const Dashv = "\u2AE4";
-      const dashv = "\u22A3";
-      const dbkarow = "\u290F";
-      const dblac = "\u02DD";
-      const Dcaron = "\u010E";
-      const dcaron = "\u010F";
-      const Dcy = "\u0414";
-      const dcy = "\u0434";
-      const ddagger = "\u2021";
-      const ddarr = "\u21CA";
-      const DD = "\u2145";
-      const dd = "\u2146";
-      const DDotrahd = "\u2911";
-      const ddotseq = "\u2A77";
-      const deg = "\xB0";
-      const Del = "\u2207";
-      const Delta = "\u0394";
-      const delta = "\u03B4";
-      const demptyv = "\u29B1";
-      const dfisht = "\u297F";
-      const Dfr = "\u{1D507}";
-      const dfr = "\u{1D521}";
-      const dHar = "\u2965";
-      const dharl = "\u21C3";
-      const dharr = "\u21C2";
-      const DiacriticalAcute = "\xB4";
-      const DiacriticalDot = "\u02D9";
-      const DiacriticalDoubleAcute = "\u02DD";
-      const DiacriticalGrave = "`";
-      const DiacriticalTilde = "\u02DC";
-      const diam = "\u22C4";
-      const diamond = "\u22C4";
-      const Diamond = "\u22C4";
-      const diamondsuit = "\u2666";
-      const diams = "\u2666";
-      const die = "\xA8";
-      const DifferentialD = "\u2146";
-      const digamma = "\u03DD";
-      const disin = "\u22F2";
-      const div = "\xF7";
-      const divide = "\xF7";
-      const divideontimes = "\u22C7";
-      const divonx = "\u22C7";
-      const DJcy = "\u0402";
-      const djcy = "\u0452";
-      const dlcorn = "\u231E";
-      const dlcrop = "\u230D";
-      const dollar = "$";
-      const Dopf = "\u{1D53B}";
-      const dopf = "\u{1D555}";
-      const Dot = "\xA8";
-      const dot = "\u02D9";
-      const DotDot = "\u20DC";
-      const doteq = "\u2250";
-      const doteqdot = "\u2251";
-      const DotEqual = "\u2250";
-      const dotminus = "\u2238";
-      const dotplus = "\u2214";
-      const dotsquare = "\u22A1";
-      const doublebarwedge = "\u2306";
-      const DoubleContourIntegral = "\u222F";
-      const DoubleDot = "\xA8";
-      const DoubleDownArrow = "\u21D3";
-      const DoubleLeftArrow = "\u21D0";
-      const DoubleLeftRightArrow = "\u21D4";
-      const DoubleLeftTee = "\u2AE4";
-      const DoubleLongLeftArrow = "\u27F8";
-      const DoubleLongLeftRightArrow = "\u27FA";
-      const DoubleLongRightArrow = "\u27F9";
-      const DoubleRightArrow = "\u21D2";
-      const DoubleRightTee = "\u22A8";
-      const DoubleUpArrow = "\u21D1";
-      const DoubleUpDownArrow = "\u21D5";
-      const DoubleVerticalBar = "\u2225";
-      const DownArrowBar = "\u2913";
-      const downarrow = "\u2193";
-      const DownArrow = "\u2193";
-      const Downarrow = "\u21D3";
-      const DownArrowUpArrow = "\u21F5";
-      const DownBreve = "\u0311";
-      const downdownarrows = "\u21CA";
-      const downharpoonleft = "\u21C3";
-      const downharpoonright = "\u21C2";
-      const DownLeftRightVector = "\u2950";
-      const DownLeftTeeVector = "\u295E";
-      const DownLeftVectorBar = "\u2956";
-      const DownLeftVector = "\u21BD";
-      const DownRightTeeVector = "\u295F";
-      const DownRightVectorBar = "\u2957";
-      const DownRightVector = "\u21C1";
-      const DownTeeArrow = "\u21A7";
-      const DownTee = "\u22A4";
-      const drbkarow = "\u2910";
-      const drcorn = "\u231F";
-      const drcrop = "\u230C";
-      const Dscr = "\u{1D49F}";
-      const dscr = "\u{1D4B9}";
-      const DScy = "\u0405";
-      const dscy = "\u0455";
-      const dsol = "\u29F6";
-      const Dstrok = "\u0110";
-      const dstrok = "\u0111";
-      const dtdot = "\u22F1";
-      const dtri = "\u25BF";
-      const dtrif = "\u25BE";
-      const duarr = "\u21F5";
-      const duhar = "\u296F";
-      const dwangle = "\u29A6";
-      const DZcy = "\u040F";
-      const dzcy = "\u045F";
-      const dzigrarr = "\u27FF";
-      const Eacute = "\xC9";
-      const eacute = "\xE9";
-      const easter = "\u2A6E";
-      const Ecaron = "\u011A";
-      const ecaron = "\u011B";
-      const Ecirc = "\xCA";
-      const ecirc = "\xEA";
-      const ecir = "\u2256";
-      const ecolon = "\u2255";
-      const Ecy = "\u042D";
-      const ecy = "\u044D";
-      const eDDot = "\u2A77";
-      const Edot = "\u0116";
-      const edot = "\u0117";
-      const eDot = "\u2251";
-      const ee = "\u2147";
-      const efDot = "\u2252";
-      const Efr = "\u{1D508}";
-      const efr = "\u{1D522}";
-      const eg = "\u2A9A";
-      const Egrave = "\xC8";
-      const egrave = "\xE8";
-      const egs = "\u2A96";
-      const egsdot = "\u2A98";
-      const el = "\u2A99";
-      const Element = "\u2208";
-      const elinters = "\u23E7";
-      const ell = "\u2113";
-      const els = "\u2A95";
-      const elsdot = "\u2A97";
-      const Emacr = "\u0112";
-      const emacr = "\u0113";
-      const empty = "\u2205";
-      const emptyset = "\u2205";
-      const EmptySmallSquare = "\u25FB";
-      const emptyv = "\u2205";
-      const EmptyVerySmallSquare = "\u25AB";
-      const emsp13 = "\u2004";
-      const emsp14 = "\u2005";
-      const emsp = "\u2003";
-      const ENG = "\u014A";
-      const eng = "\u014B";
-      const ensp = "\u2002";
-      const Eogon = "\u0118";
-      const eogon = "\u0119";
-      const Eopf = "\u{1D53C}";
-      const eopf = "\u{1D556}";
-      const epar = "\u22D5";
-      const eparsl = "\u29E3";
-      const eplus = "\u2A71";
-      const epsi = "\u03B5";
-      const Epsilon = "\u0395";
-      const epsilon = "\u03B5";
-      const epsiv = "\u03F5";
-      const eqcirc = "\u2256";
-      const eqcolon = "\u2255";
-      const eqsim = "\u2242";
-      const eqslantgtr = "\u2A96";
-      const eqslantless = "\u2A95";
-      const Equal = "\u2A75";
-      const equals = "=";
-      const EqualTilde = "\u2242";
-      const equest = "\u225F";
-      const Equilibrium = "\u21CC";
-      const equiv = "\u2261";
-      const equivDD = "\u2A78";
-      const eqvparsl = "\u29E5";
-      const erarr = "\u2971";
-      const erDot = "\u2253";
-      const escr = "\u212F";
-      const Escr = "\u2130";
-      const esdot = "\u2250";
-      const Esim = "\u2A73";
-      const esim = "\u2242";
-      const Eta = "\u0397";
-      const eta = "\u03B7";
-      const ETH = "\xD0";
-      const eth = "\xF0";
-      const Euml = "\xCB";
-      const euml = "\xEB";
-      const euro = "\u20AC";
-      const excl = "!";
-      const exist = "\u2203";
-      const Exists = "\u2203";
-      const expectation = "\u2130";
-      const exponentiale = "\u2147";
-      const ExponentialE = "\u2147";
-      const fallingdotseq = "\u2252";
-      const Fcy = "\u0424";
-      const fcy = "\u0444";
-      const female = "\u2640";
-      const ffilig = "\uFB03";
-      const fflig = "\uFB00";
-      const ffllig = "\uFB04";
-      const Ffr = "\u{1D509}";
-      const ffr = "\u{1D523}";
-      const filig = "\uFB01";
-      const FilledSmallSquare = "\u25FC";
-      const FilledVerySmallSquare = "\u25AA";
-      const fjlig = "fj";
-      const flat = "\u266D";
-      const fllig = "\uFB02";
-      const fltns = "\u25B1";
-      const fnof = "\u0192";
-      const Fopf = "\u{1D53D}";
-      const fopf = "\u{1D557}";
-      const forall = "\u2200";
-      const ForAll = "\u2200";
-      const fork = "\u22D4";
-      const forkv = "\u2AD9";
-      const Fouriertrf = "\u2131";
-      const fpartint = "\u2A0D";
-      const frac12 = "\xBD";
-      const frac13 = "\u2153";
-      const frac14 = "\xBC";
-      const frac15 = "\u2155";
-      const frac16 = "\u2159";
-      const frac18 = "\u215B";
-      const frac23 = "\u2154";
-      const frac25 = "\u2156";
-      const frac34 = "\xBE";
-      const frac35 = "\u2157";
-      const frac38 = "\u215C";
-      const frac45 = "\u2158";
-      const frac56 = "\u215A";
-      const frac58 = "\u215D";
-      const frac78 = "\u215E";
-      const frasl = "\u2044";
-      const frown = "\u2322";
-      const fscr = "\u{1D4BB}";
-      const Fscr = "\u2131";
-      const gacute = "\u01F5";
-      const Gamma = "\u0393";
-      const gamma = "\u03B3";
-      const Gammad = "\u03DC";
-      const gammad = "\u03DD";
-      const gap = "\u2A86";
-      const Gbreve = "\u011E";
-      const gbreve = "\u011F";
-      const Gcedil = "\u0122";
-      const Gcirc = "\u011C";
-      const gcirc = "\u011D";
-      const Gcy = "\u0413";
-      const gcy = "\u0433";
-      const Gdot = "\u0120";
-      const gdot = "\u0121";
-      const ge = "\u2265";
-      const gE = "\u2267";
-      const gEl = "\u2A8C";
-      const gel = "\u22DB";
-      const geq = "\u2265";
-      const geqq = "\u2267";
-      const geqslant = "\u2A7E";
-      const gescc = "\u2AA9";
-      const ges = "\u2A7E";
-      const gesdot = "\u2A80";
-      const gesdoto = "\u2A82";
-      const gesdotol = "\u2A84";
-      const gesl = "\u22DB\uFE00";
-      const gesles = "\u2A94";
-      const Gfr = "\u{1D50A}";
-      const gfr = "\u{1D524}";
-      const gg = "\u226B";
-      const Gg = "\u22D9";
-      const ggg = "\u22D9";
-      const gimel = "\u2137";
-      const GJcy = "\u0403";
-      const gjcy = "\u0453";
-      const gla = "\u2AA5";
-      const gl = "\u2277";
-      const glE = "\u2A92";
-      const glj = "\u2AA4";
-      const gnap = "\u2A8A";
-      const gnapprox = "\u2A8A";
-      const gne = "\u2A88";
-      const gnE = "\u2269";
-      const gneq = "\u2A88";
-      const gneqq = "\u2269";
-      const gnsim = "\u22E7";
-      const Gopf = "\u{1D53E}";
-      const gopf = "\u{1D558}";
-      const grave = "`";
-      const GreaterEqual = "\u2265";
-      const GreaterEqualLess = "\u22DB";
-      const GreaterFullEqual = "\u2267";
-      const GreaterGreater = "\u2AA2";
-      const GreaterLess = "\u2277";
-      const GreaterSlantEqual = "\u2A7E";
-      const GreaterTilde = "\u2273";
-      const Gscr = "\u{1D4A2}";
-      const gscr = "\u210A";
-      const gsim = "\u2273";
-      const gsime = "\u2A8E";
-      const gsiml = "\u2A90";
-      const gtcc = "\u2AA7";
-      const gtcir = "\u2A7A";
-      const gt = ">";
-      const GT = ">";
-      const Gt = "\u226B";
-      const gtdot = "\u22D7";
-      const gtlPar = "\u2995";
-      const gtquest = "\u2A7C";
-      const gtrapprox = "\u2A86";
-      const gtrarr = "\u2978";
-      const gtrdot = "\u22D7";
-      const gtreqless = "\u22DB";
-      const gtreqqless = "\u2A8C";
-      const gtrless = "\u2277";
-      const gtrsim = "\u2273";
-      const gvertneqq = "\u2269\uFE00";
-      const gvnE = "\u2269\uFE00";
-      const Hacek = "\u02C7";
-      const hairsp = "\u200A";
-      const half = "\xBD";
-      const hamilt = "\u210B";
-      const HARDcy = "\u042A";
-      const hardcy = "\u044A";
-      const harrcir = "\u2948";
-      const harr = "\u2194";
-      const hArr = "\u21D4";
-      const harrw = "\u21AD";
-      const Hat = "^";
-      const hbar = "\u210F";
-      const Hcirc = "\u0124";
-      const hcirc = "\u0125";
-      const hearts = "\u2665";
-      const heartsuit = "\u2665";
-      const hellip = "\u2026";
-      const hercon = "\u22B9";
-      const hfr = "\u{1D525}";
-      const Hfr = "\u210C";
-      const HilbertSpace = "\u210B";
-      const hksearow = "\u2925";
-      const hkswarow = "\u2926";
-      const hoarr = "\u21FF";
-      const homtht = "\u223B";
-      const hookleftarrow = "\u21A9";
-      const hookrightarrow = "\u21AA";
-      const hopf = "\u{1D559}";
-      const Hopf = "\u210D";
-      const horbar = "\u2015";
-      const HorizontalLine = "\u2500";
-      const hscr = "\u{1D4BD}";
-      const Hscr = "\u210B";
-      const hslash = "\u210F";
-      const Hstrok = "\u0126";
-      const hstrok = "\u0127";
-      const HumpDownHump = "\u224E";
-      const HumpEqual = "\u224F";
-      const hybull = "\u2043";
-      const hyphen = "\u2010";
-      const Iacute = "\xCD";
-      const iacute = "\xED";
-      const ic = "\u2063";
-      const Icirc = "\xCE";
-      const icirc = "\xEE";
-      const Icy = "\u0418";
-      const icy = "\u0438";
-      const Idot = "\u0130";
-      const IEcy = "\u0415";
-      const iecy = "\u0435";
-      const iexcl = "\xA1";
-      const iff = "\u21D4";
-      const ifr = "\u{1D526}";
-      const Ifr = "\u2111";
-      const Igrave = "\xCC";
-      const igrave = "\xEC";
-      const ii = "\u2148";
-      const iiiint = "\u2A0C";
-      const iiint = "\u222D";
-      const iinfin = "\u29DC";
-      const iiota = "\u2129";
-      const IJlig = "\u0132";
-      const ijlig = "\u0133";
-      const Imacr = "\u012A";
-      const imacr = "\u012B";
-      const image$1 = "\u2111";
-      const ImaginaryI = "\u2148";
-      const imagline = "\u2110";
-      const imagpart = "\u2111";
-      const imath = "\u0131";
-      const Im = "\u2111";
-      const imof = "\u22B7";
-      const imped = "\u01B5";
-      const Implies = "\u21D2";
-      const incare = "\u2105";
-      const infin = "\u221E";
-      const infintie = "\u29DD";
-      const inodot = "\u0131";
-      const intcal = "\u22BA";
-      const int = "\u222B";
-      const Int = "\u222C";
-      const integers = "\u2124";
-      const Integral = "\u222B";
-      const intercal = "\u22BA";
-      const Intersection = "\u22C2";
-      const intlarhk = "\u2A17";
-      const intprod = "\u2A3C";
-      const InvisibleComma = "\u2063";
-      const InvisibleTimes = "\u2062";
-      const IOcy = "\u0401";
-      const iocy = "\u0451";
-      const Iogon = "\u012E";
-      const iogon = "\u012F";
-      const Iopf = "\u{1D540}";
-      const iopf = "\u{1D55A}";
-      const Iota = "\u0399";
-      const iota = "\u03B9";
-      const iprod = "\u2A3C";
-      const iquest = "\xBF";
-      const iscr = "\u{1D4BE}";
-      const Iscr = "\u2110";
-      const isin = "\u2208";
-      const isindot = "\u22F5";
-      const isinE = "\u22F9";
-      const isins = "\u22F4";
-      const isinsv = "\u22F3";
-      const isinv = "\u2208";
-      const it = "\u2062";
-      const Itilde = "\u0128";
-      const itilde = "\u0129";
-      const Iukcy = "\u0406";
-      const iukcy = "\u0456";
-      const Iuml = "\xCF";
-      const iuml = "\xEF";
-      const Jcirc = "\u0134";
-      const jcirc = "\u0135";
-      const Jcy = "\u0419";
-      const jcy = "\u0439";
-      const Jfr = "\u{1D50D}";
-      const jfr = "\u{1D527}";
-      const jmath = "\u0237";
-      const Jopf = "\u{1D541}";
-      const jopf = "\u{1D55B}";
-      const Jscr = "\u{1D4A5}";
-      const jscr = "\u{1D4BF}";
-      const Jsercy = "\u0408";
-      const jsercy = "\u0458";
-      const Jukcy = "\u0404";
-      const jukcy = "\u0454";
-      const Kappa = "\u039A";
-      const kappa = "\u03BA";
-      const kappav = "\u03F0";
-      const Kcedil = "\u0136";
-      const kcedil = "\u0137";
-      const Kcy = "\u041A";
-      const kcy = "\u043A";
-      const Kfr = "\u{1D50E}";
-      const kfr = "\u{1D528}";
-      const kgreen = "\u0138";
-      const KHcy = "\u0425";
-      const khcy = "\u0445";
-      const KJcy = "\u040C";
-      const kjcy = "\u045C";
-      const Kopf = "\u{1D542}";
-      const kopf = "\u{1D55C}";
-      const Kscr = "\u{1D4A6}";
-      const kscr = "\u{1D4C0}";
-      const lAarr = "\u21DA";
-      const Lacute = "\u0139";
-      const lacute = "\u013A";
-      const laemptyv = "\u29B4";
-      const lagran = "\u2112";
-      const Lambda = "\u039B";
-      const lambda = "\u03BB";
-      const lang = "\u27E8";
-      const Lang = "\u27EA";
-      const langd = "\u2991";
-      const langle = "\u27E8";
-      const lap = "\u2A85";
-      const Laplacetrf = "\u2112";
-      const laquo = "\xAB";
-      const larrb = "\u21E4";
-      const larrbfs = "\u291F";
-      const larr = "\u2190";
-      const Larr = "\u219E";
-      const lArr = "\u21D0";
-      const larrfs = "\u291D";
-      const larrhk = "\u21A9";
-      const larrlp = "\u21AB";
-      const larrpl = "\u2939";
-      const larrsim = "\u2973";
-      const larrtl = "\u21A2";
-      const latail = "\u2919";
-      const lAtail = "\u291B";
-      const lat = "\u2AAB";
-      const late = "\u2AAD";
-      const lates = "\u2AAD\uFE00";
-      const lbarr = "\u290C";
-      const lBarr = "\u290E";
-      const lbbrk = "\u2772";
-      const lbrace = "{";
-      const lbrack = "[";
-      const lbrke = "\u298B";
-      const lbrksld = "\u298F";
-      const lbrkslu = "\u298D";
-      const Lcaron = "\u013D";
-      const lcaron = "\u013E";
-      const Lcedil = "\u013B";
-      const lcedil = "\u013C";
-      const lceil = "\u2308";
-      const lcub = "{";
-      const Lcy = "\u041B";
-      const lcy = "\u043B";
-      const ldca = "\u2936";
-      const ldquo = "\u201C";
-      const ldquor = "\u201E";
-      const ldrdhar = "\u2967";
-      const ldrushar = "\u294B";
-      const ldsh = "\u21B2";
-      const le = "\u2264";
-      const lE = "\u2266";
-      const LeftAngleBracket = "\u27E8";
-      const LeftArrowBar = "\u21E4";
-      const leftarrow = "\u2190";
-      const LeftArrow = "\u2190";
-      const Leftarrow = "\u21D0";
-      const LeftArrowRightArrow = "\u21C6";
-      const leftarrowtail = "\u21A2";
-      const LeftCeiling = "\u2308";
-      const LeftDoubleBracket = "\u27E6";
-      const LeftDownTeeVector = "\u2961";
-      const LeftDownVectorBar = "\u2959";
-      const LeftDownVector = "\u21C3";
-      const LeftFloor = "\u230A";
-      const leftharpoondown = "\u21BD";
-      const leftharpoonup = "\u21BC";
-      const leftleftarrows = "\u21C7";
-      const leftrightarrow = "\u2194";
-      const LeftRightArrow = "\u2194";
-      const Leftrightarrow = "\u21D4";
-      const leftrightarrows = "\u21C6";
-      const leftrightharpoons = "\u21CB";
-      const leftrightsquigarrow = "\u21AD";
-      const LeftRightVector = "\u294E";
-      const LeftTeeArrow = "\u21A4";
-      const LeftTee = "\u22A3";
-      const LeftTeeVector = "\u295A";
-      const leftthreetimes = "\u22CB";
-      const LeftTriangleBar = "\u29CF";
-      const LeftTriangle = "\u22B2";
-      const LeftTriangleEqual = "\u22B4";
-      const LeftUpDownVector = "\u2951";
-      const LeftUpTeeVector = "\u2960";
-      const LeftUpVectorBar = "\u2958";
-      const LeftUpVector = "\u21BF";
-      const LeftVectorBar = "\u2952";
-      const LeftVector = "\u21BC";
-      const lEg = "\u2A8B";
-      const leg = "\u22DA";
-      const leq = "\u2264";
-      const leqq = "\u2266";
-      const leqslant = "\u2A7D";
-      const lescc = "\u2AA8";
-      const les = "\u2A7D";
-      const lesdot = "\u2A7F";
-      const lesdoto = "\u2A81";
-      const lesdotor = "\u2A83";
-      const lesg = "\u22DA\uFE00";
-      const lesges = "\u2A93";
-      const lessapprox = "\u2A85";
-      const lessdot = "\u22D6";
-      const lesseqgtr = "\u22DA";
-      const lesseqqgtr = "\u2A8B";
-      const LessEqualGreater = "\u22DA";
-      const LessFullEqual = "\u2266";
-      const LessGreater = "\u2276";
-      const lessgtr = "\u2276";
-      const LessLess = "\u2AA1";
-      const lesssim = "\u2272";
-      const LessSlantEqual = "\u2A7D";
-      const LessTilde = "\u2272";
-      const lfisht = "\u297C";
-      const lfloor = "\u230A";
-      const Lfr = "\u{1D50F}";
-      const lfr = "\u{1D529}";
-      const lg = "\u2276";
-      const lgE = "\u2A91";
-      const lHar = "\u2962";
-      const lhard = "\u21BD";
-      const lharu = "\u21BC";
-      const lharul = "\u296A";
-      const lhblk = "\u2584";
-      const LJcy = "\u0409";
-      const ljcy = "\u0459";
-      const llarr = "\u21C7";
-      const ll = "\u226A";
-      const Ll = "\u22D8";
-      const llcorner = "\u231E";
-      const Lleftarrow = "\u21DA";
-      const llhard = "\u296B";
-      const lltri = "\u25FA";
-      const Lmidot = "\u013F";
-      const lmidot = "\u0140";
-      const lmoustache = "\u23B0";
-      const lmoust = "\u23B0";
-      const lnap = "\u2A89";
-      const lnapprox = "\u2A89";
-      const lne = "\u2A87";
-      const lnE = "\u2268";
-      const lneq = "\u2A87";
-      const lneqq = "\u2268";
-      const lnsim = "\u22E6";
-      const loang = "\u27EC";
-      const loarr = "\u21FD";
-      const lobrk = "\u27E6";
-      const longleftarrow = "\u27F5";
-      const LongLeftArrow = "\u27F5";
-      const Longleftarrow = "\u27F8";
-      const longleftrightarrow = "\u27F7";
-      const LongLeftRightArrow = "\u27F7";
-      const Longleftrightarrow = "\u27FA";
-      const longmapsto = "\u27FC";
-      const longrightarrow = "\u27F6";
-      const LongRightArrow = "\u27F6";
-      const Longrightarrow = "\u27F9";
-      const looparrowleft = "\u21AB";
-      const looparrowright = "\u21AC";
-      const lopar = "\u2985";
-      const Lopf = "\u{1D543}";
-      const lopf = "\u{1D55D}";
-      const loplus = "\u2A2D";
-      const lotimes = "\u2A34";
-      const lowast = "\u2217";
-      const lowbar = "_";
-      const LowerLeftArrow = "\u2199";
-      const LowerRightArrow = "\u2198";
-      const loz = "\u25CA";
-      const lozenge = "\u25CA";
-      const lozf = "\u29EB";
-      const lpar = "(";
-      const lparlt = "\u2993";
-      const lrarr = "\u21C6";
-      const lrcorner = "\u231F";
-      const lrhar = "\u21CB";
-      const lrhard = "\u296D";
-      const lrm = "\u200E";
-      const lrtri = "\u22BF";
-      const lsaquo = "\u2039";
-      const lscr = "\u{1D4C1}";
-      const Lscr = "\u2112";
-      const lsh = "\u21B0";
-      const Lsh = "\u21B0";
-      const lsim = "\u2272";
-      const lsime = "\u2A8D";
-      const lsimg = "\u2A8F";
-      const lsqb = "[";
-      const lsquo = "\u2018";
-      const lsquor = "\u201A";
-      const Lstrok = "\u0141";
-      const lstrok = "\u0142";
-      const ltcc = "\u2AA6";
-      const ltcir = "\u2A79";
-      const lt = "<";
-      const LT = "<";
-      const Lt = "\u226A";
-      const ltdot = "\u22D6";
-      const lthree = "\u22CB";
-      const ltimes = "\u22C9";
-      const ltlarr = "\u2976";
-      const ltquest = "\u2A7B";
-      const ltri = "\u25C3";
-      const ltrie = "\u22B4";
-      const ltrif = "\u25C2";
-      const ltrPar = "\u2996";
-      const lurdshar = "\u294A";
-      const luruhar = "\u2966";
-      const lvertneqq = "\u2268\uFE00";
-      const lvnE = "\u2268\uFE00";
-      const macr = "\xAF";
-      const male = "\u2642";
-      const malt = "\u2720";
-      const maltese = "\u2720";
-      const map$1 = "\u21A6";
-      const mapsto = "\u21A6";
-      const mapstodown = "\u21A7";
-      const mapstoleft = "\u21A4";
-      const mapstoup = "\u21A5";
-      const marker = "\u25AE";
-      const mcomma = "\u2A29";
-      const Mcy = "\u041C";
-      const mcy = "\u043C";
-      const mdash = "\u2014";
-      const mDDot = "\u223A";
-      const measuredangle = "\u2221";
-      const MediumSpace = "\u205F";
-      const Mellintrf = "\u2133";
-      const Mfr = "\u{1D510}";
-      const mfr = "\u{1D52A}";
-      const mho = "\u2127";
-      const micro = "\xB5";
-      const midast = "*";
-      const midcir = "\u2AF0";
-      const mid = "\u2223";
-      const middot = "\xB7";
-      const minusb = "\u229F";
-      const minus = "\u2212";
-      const minusd = "\u2238";
-      const minusdu = "\u2A2A";
-      const MinusPlus = "\u2213";
-      const mlcp = "\u2ADB";
-      const mldr = "\u2026";
-      const mnplus = "\u2213";
-      const models = "\u22A7";
-      const Mopf = "\u{1D544}";
-      const mopf = "\u{1D55E}";
-      const mp = "\u2213";
-      const mscr = "\u{1D4C2}";
-      const Mscr = "\u2133";
-      const mstpos = "\u223E";
-      const Mu = "\u039C";
-      const mu = "\u03BC";
-      const multimap = "\u22B8";
-      const mumap = "\u22B8";
-      const nabla = "\u2207";
-      const Nacute = "\u0143";
-      const nacute = "\u0144";
-      const nang = "\u2220\u20D2";
-      const nap = "\u2249";
-      const napE = "\u2A70\u0338";
-      const napid = "\u224B\u0338";
-      const napos = "\u0149";
-      const napprox = "\u2249";
-      const natural = "\u266E";
-      const naturals = "\u2115";
-      const natur = "\u266E";
-      const nbsp = "\xA0";
-      const nbump = "\u224E\u0338";
-      const nbumpe = "\u224F\u0338";
-      const ncap = "\u2A43";
-      const Ncaron = "\u0147";
-      const ncaron = "\u0148";
-      const Ncedil = "\u0145";
-      const ncedil = "\u0146";
-      const ncong = "\u2247";
-      const ncongdot = "\u2A6D\u0338";
-      const ncup = "\u2A42";
-      const Ncy = "\u041D";
-      const ncy = "\u043D";
-      const ndash = "\u2013";
-      const nearhk = "\u2924";
-      const nearr = "\u2197";
-      const neArr = "\u21D7";
-      const nearrow = "\u2197";
-      const ne = "\u2260";
-      const nedot = "\u2250\u0338";
-      const NegativeMediumSpace = "\u200B";
-      const NegativeThickSpace = "\u200B";
-      const NegativeThinSpace = "\u200B";
-      const NegativeVeryThinSpace = "\u200B";
-      const nequiv = "\u2262";
-      const nesear = "\u2928";
-      const nesim = "\u2242\u0338";
-      const NestedGreaterGreater = "\u226B";
-      const NestedLessLess = "\u226A";
-      const NewLine = "\n";
-      const nexist = "\u2204";
-      const nexists = "\u2204";
-      const Nfr = "\u{1D511}";
-      const nfr = "\u{1D52B}";
-      const ngE = "\u2267\u0338";
-      const nge = "\u2271";
-      const ngeq = "\u2271";
-      const ngeqq = "\u2267\u0338";
-      const ngeqslant = "\u2A7E\u0338";
-      const nges = "\u2A7E\u0338";
-      const nGg = "\u22D9\u0338";
-      const ngsim = "\u2275";
-      const nGt = "\u226B\u20D2";
-      const ngt = "\u226F";
-      const ngtr = "\u226F";
-      const nGtv = "\u226B\u0338";
-      const nharr = "\u21AE";
-      const nhArr = "\u21CE";
-      const nhpar = "\u2AF2";
-      const ni = "\u220B";
-      const nis = "\u22FC";
-      const nisd = "\u22FA";
-      const niv = "\u220B";
-      const NJcy = "\u040A";
-      const njcy = "\u045A";
-      const nlarr = "\u219A";
-      const nlArr = "\u21CD";
-      const nldr = "\u2025";
-      const nlE = "\u2266\u0338";
-      const nle = "\u2270";
-      const nleftarrow = "\u219A";
-      const nLeftarrow = "\u21CD";
-      const nleftrightarrow = "\u21AE";
-      const nLeftrightarrow = "\u21CE";
-      const nleq = "\u2270";
-      const nleqq = "\u2266\u0338";
-      const nleqslant = "\u2A7D\u0338";
-      const nles = "\u2A7D\u0338";
-      const nless = "\u226E";
-      const nLl = "\u22D8\u0338";
-      const nlsim = "\u2274";
-      const nLt = "\u226A\u20D2";
-      const nlt = "\u226E";
-      const nltri = "\u22EA";
-      const nltrie = "\u22EC";
-      const nLtv = "\u226A\u0338";
-      const nmid = "\u2224";
-      const NoBreak = "\u2060";
-      const NonBreakingSpace = "\xA0";
-      const nopf = "\u{1D55F}";
-      const Nopf = "\u2115";
-      const Not = "\u2AEC";
-      const not = "\xAC";
-      const NotCongruent = "\u2262";
-      const NotCupCap = "\u226D";
-      const NotDoubleVerticalBar = "\u2226";
-      const NotElement = "\u2209";
-      const NotEqual = "\u2260";
-      const NotEqualTilde = "\u2242\u0338";
-      const NotExists = "\u2204";
-      const NotGreater = "\u226F";
-      const NotGreaterEqual = "\u2271";
-      const NotGreaterFullEqual = "\u2267\u0338";
-      const NotGreaterGreater = "\u226B\u0338";
-      const NotGreaterLess = "\u2279";
-      const NotGreaterSlantEqual = "\u2A7E\u0338";
-      const NotGreaterTilde = "\u2275";
-      const NotHumpDownHump = "\u224E\u0338";
-      const NotHumpEqual = "\u224F\u0338";
-      const notin = "\u2209";
-      const notindot = "\u22F5\u0338";
-      const notinE = "\u22F9\u0338";
-      const notinva = "\u2209";
-      const notinvb = "\u22F7";
-      const notinvc = "\u22F6";
-      const NotLeftTriangleBar = "\u29CF\u0338";
-      const NotLeftTriangle = "\u22EA";
-      const NotLeftTriangleEqual = "\u22EC";
-      const NotLess = "\u226E";
-      const NotLessEqual = "\u2270";
-      const NotLessGreater = "\u2278";
-      const NotLessLess = "\u226A\u0338";
-      const NotLessSlantEqual = "\u2A7D\u0338";
-      const NotLessTilde = "\u2274";
-      const NotNestedGreaterGreater = "\u2AA2\u0338";
-      const NotNestedLessLess = "\u2AA1\u0338";
-      const notni = "\u220C";
-      const notniva = "\u220C";
-      const notnivb = "\u22FE";
-      const notnivc = "\u22FD";
-      const NotPrecedes = "\u2280";
-      const NotPrecedesEqual = "\u2AAF\u0338";
-      const NotPrecedesSlantEqual = "\u22E0";
-      const NotReverseElement = "\u220C";
-      const NotRightTriangleBar = "\u29D0\u0338";
-      const NotRightTriangle = "\u22EB";
-      const NotRightTriangleEqual = "\u22ED";
-      const NotSquareSubset = "\u228F\u0338";
-      const NotSquareSubsetEqual = "\u22E2";
-      const NotSquareSuperset = "\u2290\u0338";
-      const NotSquareSupersetEqual = "\u22E3";
-      const NotSubset = "\u2282\u20D2";
-      const NotSubsetEqual = "\u2288";
-      const NotSucceeds = "\u2281";
-      const NotSucceedsEqual = "\u2AB0\u0338";
-      const NotSucceedsSlantEqual = "\u22E1";
-      const NotSucceedsTilde = "\u227F\u0338";
-      const NotSuperset = "\u2283\u20D2";
-      const NotSupersetEqual = "\u2289";
-      const NotTilde = "\u2241";
-      const NotTildeEqual = "\u2244";
-      const NotTildeFullEqual = "\u2247";
-      const NotTildeTilde = "\u2249";
-      const NotVerticalBar = "\u2224";
-      const nparallel = "\u2226";
-      const npar = "\u2226";
-      const nparsl = "\u2AFD\u20E5";
-      const npart = "\u2202\u0338";
-      const npolint = "\u2A14";
-      const npr = "\u2280";
-      const nprcue = "\u22E0";
-      const nprec = "\u2280";
-      const npreceq = "\u2AAF\u0338";
-      const npre = "\u2AAF\u0338";
-      const nrarrc = "\u2933\u0338";
-      const nrarr = "\u219B";
-      const nrArr = "\u21CF";
-      const nrarrw = "\u219D\u0338";
-      const nrightarrow = "\u219B";
-      const nRightarrow = "\u21CF";
-      const nrtri = "\u22EB";
-      const nrtrie = "\u22ED";
-      const nsc = "\u2281";
-      const nsccue = "\u22E1";
-      const nsce = "\u2AB0\u0338";
-      const Nscr = "\u{1D4A9}";
-      const nscr = "\u{1D4C3}";
-      const nshortmid = "\u2224";
-      const nshortparallel = "\u2226";
-      const nsim = "\u2241";
-      const nsime = "\u2244";
-      const nsimeq = "\u2244";
-      const nsmid = "\u2224";
-      const nspar = "\u2226";
-      const nsqsube = "\u22E2";
-      const nsqsupe = "\u22E3";
-      const nsub = "\u2284";
-      const nsubE = "\u2AC5\u0338";
-      const nsube = "\u2288";
-      const nsubset = "\u2282\u20D2";
-      const nsubseteq = "\u2288";
-      const nsubseteqq = "\u2AC5\u0338";
-      const nsucc = "\u2281";
-      const nsucceq = "\u2AB0\u0338";
-      const nsup = "\u2285";
-      const nsupE = "\u2AC6\u0338";
-      const nsupe = "\u2289";
-      const nsupset = "\u2283\u20D2";
-      const nsupseteq = "\u2289";
-      const nsupseteqq = "\u2AC6\u0338";
-      const ntgl = "\u2279";
-      const Ntilde = "\xD1";
-      const ntilde = "\xF1";
-      const ntlg = "\u2278";
-      const ntriangleleft = "\u22EA";
-      const ntrianglelefteq = "\u22EC";
-      const ntriangleright = "\u22EB";
-      const ntrianglerighteq = "\u22ED";
-      const Nu = "\u039D";
-      const nu = "\u03BD";
-      const num = "#";
-      const numero = "\u2116";
-      const numsp = "\u2007";
-      const nvap = "\u224D\u20D2";
-      const nvdash = "\u22AC";
-      const nvDash = "\u22AD";
-      const nVdash = "\u22AE";
-      const nVDash = "\u22AF";
-      const nvge = "\u2265\u20D2";
-      const nvgt = ">\u20D2";
-      const nvHarr = "\u2904";
-      const nvinfin = "\u29DE";
-      const nvlArr = "\u2902";
-      const nvle = "\u2264\u20D2";
-      const nvlt = "<\u20D2";
-      const nvltrie = "\u22B4\u20D2";
-      const nvrArr = "\u2903";
-      const nvrtrie = "\u22B5\u20D2";
-      const nvsim = "\u223C\u20D2";
-      const nwarhk = "\u2923";
-      const nwarr = "\u2196";
-      const nwArr = "\u21D6";
-      const nwarrow = "\u2196";
-      const nwnear = "\u2927";
-      const Oacute = "\xD3";
-      const oacute = "\xF3";
-      const oast = "\u229B";
-      const Ocirc = "\xD4";
-      const ocirc = "\xF4";
-      const ocir = "\u229A";
-      const Ocy = "\u041E";
-      const ocy = "\u043E";
-      const odash = "\u229D";
-      const Odblac = "\u0150";
-      const odblac = "\u0151";
-      const odiv = "\u2A38";
-      const odot = "\u2299";
-      const odsold = "\u29BC";
-      const OElig = "\u0152";
-      const oelig = "\u0153";
-      const ofcir = "\u29BF";
-      const Ofr = "\u{1D512}";
-      const ofr = "\u{1D52C}";
-      const ogon = "\u02DB";
-      const Ograve = "\xD2";
-      const ograve = "\xF2";
-      const ogt = "\u29C1";
-      const ohbar = "\u29B5";
-      const ohm = "\u03A9";
-      const oint = "\u222E";
-      const olarr = "\u21BA";
-      const olcir = "\u29BE";
-      const olcross = "\u29BB";
-      const oline = "\u203E";
-      const olt = "\u29C0";
-      const Omacr = "\u014C";
-      const omacr = "\u014D";
-      const Omega = "\u03A9";
-      const omega = "\u03C9";
-      const Omicron = "\u039F";
-      const omicron = "\u03BF";
-      const omid = "\u29B6";
-      const ominus = "\u2296";
-      const Oopf = "\u{1D546}";
-      const oopf = "\u{1D560}";
-      const opar = "\u29B7";
-      const OpenCurlyDoubleQuote = "\u201C";
-      const OpenCurlyQuote = "\u2018";
-      const operp = "\u29B9";
-      const oplus = "\u2295";
-      const orarr = "\u21BB";
-      const Or = "\u2A54";
-      const or = "\u2228";
-      const ord = "\u2A5D";
-      const order = "\u2134";
-      const orderof = "\u2134";
-      const ordf = "\xAA";
-      const ordm = "\xBA";
-      const origof = "\u22B6";
-      const oror = "\u2A56";
-      const orslope = "\u2A57";
-      const orv = "\u2A5B";
-      const oS = "\u24C8";
-      const Oscr = "\u{1D4AA}";
-      const oscr = "\u2134";
-      const Oslash = "\xD8";
-      const oslash = "\xF8";
-      const osol = "\u2298";
-      const Otilde = "\xD5";
-      const otilde = "\xF5";
-      const otimesas = "\u2A36";
-      const Otimes = "\u2A37";
-      const otimes = "\u2297";
-      const Ouml = "\xD6";
-      const ouml = "\xF6";
-      const ovbar = "\u233D";
-      const OverBar = "\u203E";
-      const OverBrace = "\u23DE";
-      const OverBracket = "\u23B4";
-      const OverParenthesis = "\u23DC";
-      const para = "\xB6";
-      const parallel = "\u2225";
-      const par = "\u2225";
-      const parsim = "\u2AF3";
-      const parsl = "\u2AFD";
-      const part = "\u2202";
-      const PartialD = "\u2202";
-      const Pcy = "\u041F";
-      const pcy = "\u043F";
-      const percnt = "%";
-      const period = ".";
-      const permil = "\u2030";
-      const perp = "\u22A5";
-      const pertenk = "\u2031";
-      const Pfr = "\u{1D513}";
-      const pfr = "\u{1D52D}";
-      const Phi = "\u03A6";
-      const phi = "\u03C6";
-      const phiv = "\u03D5";
-      const phmmat = "\u2133";
-      const phone = "\u260E";
-      const Pi = "\u03A0";
-      const pi = "\u03C0";
-      const pitchfork = "\u22D4";
-      const piv = "\u03D6";
-      const planck = "\u210F";
-      const planckh = "\u210E";
-      const plankv = "\u210F";
-      const plusacir = "\u2A23";
-      const plusb = "\u229E";
-      const pluscir = "\u2A22";
-      const plus = "+";
-      const plusdo = "\u2214";
-      const plusdu = "\u2A25";
-      const pluse = "\u2A72";
-      const PlusMinus = "\xB1";
-      const plusmn = "\xB1";
-      const plussim = "\u2A26";
-      const plustwo = "\u2A27";
-      const pm = "\xB1";
-      const Poincareplane = "\u210C";
-      const pointint = "\u2A15";
-      const popf = "\u{1D561}";
-      const Popf = "\u2119";
-      const pound = "\xA3";
-      const prap = "\u2AB7";
-      const Pr = "\u2ABB";
-      const pr = "\u227A";
-      const prcue = "\u227C";
-      const precapprox = "\u2AB7";
-      const prec = "\u227A";
-      const preccurlyeq = "\u227C";
-      const Precedes = "\u227A";
-      const PrecedesEqual = "\u2AAF";
-      const PrecedesSlantEqual = "\u227C";
-      const PrecedesTilde = "\u227E";
-      const preceq = "\u2AAF";
-      const precnapprox = "\u2AB9";
-      const precneqq = "\u2AB5";
-      const precnsim = "\u22E8";
-      const pre = "\u2AAF";
-      const prE = "\u2AB3";
-      const precsim = "\u227E";
-      const prime = "\u2032";
-      const Prime = "\u2033";
-      const primes = "\u2119";
-      const prnap = "\u2AB9";
-      const prnE = "\u2AB5";
-      const prnsim = "\u22E8";
-      const prod = "\u220F";
-      const Product = "\u220F";
-      const profalar = "\u232E";
-      const profline = "\u2312";
-      const profsurf = "\u2313";
-      const prop = "\u221D";
-      const Proportional = "\u221D";
-      const Proportion = "\u2237";
-      const propto = "\u221D";
-      const prsim = "\u227E";
-      const prurel = "\u22B0";
-      const Pscr = "\u{1D4AB}";
-      const pscr = "\u{1D4C5}";
-      const Psi = "\u03A8";
-      const psi = "\u03C8";
-      const puncsp = "\u2008";
-      const Qfr = "\u{1D514}";
-      const qfr = "\u{1D52E}";
-      const qint = "\u2A0C";
-      const qopf = "\u{1D562}";
-      const Qopf = "\u211A";
-      const qprime = "\u2057";
-      const Qscr = "\u{1D4AC}";
-      const qscr = "\u{1D4C6}";
-      const quaternions = "\u210D";
-      const quatint = "\u2A16";
-      const quest = "?";
-      const questeq = "\u225F";
-      const quot = '"';
-      const QUOT = '"';
-      const rAarr = "\u21DB";
-      const race = "\u223D\u0331";
-      const Racute = "\u0154";
-      const racute = "\u0155";
-      const radic = "\u221A";
-      const raemptyv = "\u29B3";
-      const rang = "\u27E9";
-      const Rang = "\u27EB";
-      const rangd = "\u2992";
-      const range = "\u29A5";
-      const rangle = "\u27E9";
-      const raquo = "\xBB";
-      const rarrap = "\u2975";
-      const rarrb = "\u21E5";
-      const rarrbfs = "\u2920";
-      const rarrc = "\u2933";
-      const rarr = "\u2192";
-      const Rarr = "\u21A0";
-      const rArr = "\u21D2";
-      const rarrfs = "\u291E";
-      const rarrhk = "\u21AA";
-      const rarrlp = "\u21AC";
-      const rarrpl = "\u2945";
-      const rarrsim = "\u2974";
-      const Rarrtl = "\u2916";
-      const rarrtl = "\u21A3";
-      const rarrw = "\u219D";
-      const ratail = "\u291A";
-      const rAtail = "\u291C";
-      const ratio = "\u2236";
-      const rationals = "\u211A";
-      const rbarr = "\u290D";
-      const rBarr = "\u290F";
-      const RBarr = "\u2910";
-      const rbbrk = "\u2773";
-      const rbrace = "}";
-      const rbrack = "]";
-      const rbrke = "\u298C";
-      const rbrksld = "\u298E";
-      const rbrkslu = "\u2990";
-      const Rcaron = "\u0158";
-      const rcaron = "\u0159";
-      const Rcedil = "\u0156";
-      const rcedil = "\u0157";
-      const rceil = "\u2309";
-      const rcub = "}";
-      const Rcy = "\u0420";
-      const rcy = "\u0440";
-      const rdca = "\u2937";
-      const rdldhar = "\u2969";
-      const rdquo = "\u201D";
-      const rdquor = "\u201D";
-      const rdsh = "\u21B3";
-      const real = "\u211C";
-      const realine = "\u211B";
-      const realpart = "\u211C";
-      const reals = "\u211D";
-      const Re = "\u211C";
-      const rect = "\u25AD";
-      const reg = "\xAE";
-      const REG = "\xAE";
-      const ReverseElement = "\u220B";
-      const ReverseEquilibrium = "\u21CB";
-      const ReverseUpEquilibrium = "\u296F";
-      const rfisht = "\u297D";
-      const rfloor = "\u230B";
-      const rfr = "\u{1D52F}";
-      const Rfr = "\u211C";
-      const rHar = "\u2964";
-      const rhard = "\u21C1";
-      const rharu = "\u21C0";
-      const rharul = "\u296C";
-      const Rho = "\u03A1";
-      const rho = "\u03C1";
-      const rhov = "\u03F1";
-      const RightAngleBracket = "\u27E9";
-      const RightArrowBar = "\u21E5";
-      const rightarrow = "\u2192";
-      const RightArrow = "\u2192";
-      const Rightarrow = "\u21D2";
-      const RightArrowLeftArrow = "\u21C4";
-      const rightarrowtail = "\u21A3";
-      const RightCeiling = "\u2309";
-      const RightDoubleBracket = "\u27E7";
-      const RightDownTeeVector = "\u295D";
-      const RightDownVectorBar = "\u2955";
-      const RightDownVector = "\u21C2";
-      const RightFloor = "\u230B";
-      const rightharpoondown = "\u21C1";
-      const rightharpoonup = "\u21C0";
-      const rightleftarrows = "\u21C4";
-      const rightleftharpoons = "\u21CC";
-      const rightrightarrows = "\u21C9";
-      const rightsquigarrow = "\u219D";
-      const RightTeeArrow = "\u21A6";
-      const RightTee = "\u22A2";
-      const RightTeeVector = "\u295B";
-      const rightthreetimes = "\u22CC";
-      const RightTriangleBar = "\u29D0";
-      const RightTriangle = "\u22B3";
-      const RightTriangleEqual = "\u22B5";
-      const RightUpDownVector = "\u294F";
-      const RightUpTeeVector = "\u295C";
-      const RightUpVectorBar = "\u2954";
-      const RightUpVector = "\u21BE";
-      const RightVectorBar = "\u2953";
-      const RightVector = "\u21C0";
-      const ring = "\u02DA";
-      const risingdotseq = "\u2253";
-      const rlarr = "\u21C4";
-      const rlhar = "\u21CC";
-      const rlm = "\u200F";
-      const rmoustache = "\u23B1";
-      const rmoust = "\u23B1";
-      const rnmid = "\u2AEE";
-      const roang = "\u27ED";
-      const roarr = "\u21FE";
-      const robrk = "\u27E7";
-      const ropar = "\u2986";
-      const ropf = "\u{1D563}";
-      const Ropf = "\u211D";
-      const roplus = "\u2A2E";
-      const rotimes = "\u2A35";
-      const RoundImplies = "\u2970";
-      const rpar = ")";
-      const rpargt = "\u2994";
-      const rppolint = "\u2A12";
-      const rrarr = "\u21C9";
-      const Rrightarrow = "\u21DB";
-      const rsaquo = "\u203A";
-      const rscr = "\u{1D4C7}";
-      const Rscr = "\u211B";
-      const rsh = "\u21B1";
-      const Rsh = "\u21B1";
-      const rsqb = "]";
-      const rsquo = "\u2019";
-      const rsquor = "\u2019";
-      const rthree = "\u22CC";
-      const rtimes = "\u22CA";
-      const rtri = "\u25B9";
-      const rtrie = "\u22B5";
-      const rtrif = "\u25B8";
-      const rtriltri = "\u29CE";
-      const RuleDelayed = "\u29F4";
-      const ruluhar = "\u2968";
-      const rx = "\u211E";
-      const Sacute = "\u015A";
-      const sacute = "\u015B";
-      const sbquo = "\u201A";
-      const scap = "\u2AB8";
-      const Scaron = "\u0160";
-      const scaron = "\u0161";
-      const Sc = "\u2ABC";
-      const sc = "\u227B";
-      const sccue = "\u227D";
-      const sce = "\u2AB0";
-      const scE = "\u2AB4";
-      const Scedil = "\u015E";
-      const scedil = "\u015F";
-      const Scirc = "\u015C";
-      const scirc = "\u015D";
-      const scnap = "\u2ABA";
-      const scnE = "\u2AB6";
-      const scnsim = "\u22E9";
-      const scpolint = "\u2A13";
-      const scsim = "\u227F";
-      const Scy = "\u0421";
-      const scy = "\u0441";
-      const sdotb = "\u22A1";
-      const sdot = "\u22C5";
-      const sdote = "\u2A66";
-      const searhk = "\u2925";
-      const searr = "\u2198";
-      const seArr = "\u21D8";
-      const searrow = "\u2198";
-      const sect = "\xA7";
-      const semi = ";";
-      const seswar = "\u2929";
-      const setminus = "\u2216";
-      const setmn = "\u2216";
-      const sext = "\u2736";
-      const Sfr = "\u{1D516}";
-      const sfr = "\u{1D530}";
-      const sfrown = "\u2322";
-      const sharp = "\u266F";
-      const SHCHcy = "\u0429";
-      const shchcy = "\u0449";
-      const SHcy = "\u0428";
-      const shcy = "\u0448";
-      const ShortDownArrow = "\u2193";
-      const ShortLeftArrow = "\u2190";
-      const shortmid = "\u2223";
-      const shortparallel = "\u2225";
-      const ShortRightArrow = "\u2192";
-      const ShortUpArrow = "\u2191";
-      const shy = "\xAD";
-      const Sigma = "\u03A3";
-      const sigma = "\u03C3";
-      const sigmaf = "\u03C2";
-      const sigmav = "\u03C2";
-      const sim = "\u223C";
-      const simdot = "\u2A6A";
-      const sime = "\u2243";
-      const simeq = "\u2243";
-      const simg = "\u2A9E";
-      const simgE = "\u2AA0";
-      const siml = "\u2A9D";
-      const simlE = "\u2A9F";
-      const simne = "\u2246";
-      const simplus = "\u2A24";
-      const simrarr = "\u2972";
-      const slarr = "\u2190";
-      const SmallCircle = "\u2218";
-      const smallsetminus = "\u2216";
-      const smashp = "\u2A33";
-      const smeparsl = "\u29E4";
-      const smid = "\u2223";
-      const smile = "\u2323";
-      const smt = "\u2AAA";
-      const smte = "\u2AAC";
-      const smtes = "\u2AAC\uFE00";
-      const SOFTcy = "\u042C";
-      const softcy = "\u044C";
-      const solbar = "\u233F";
-      const solb = "\u29C4";
-      const sol = "/";
-      const Sopf = "\u{1D54A}";
-      const sopf = "\u{1D564}";
-      const spades = "\u2660";
-      const spadesuit = "\u2660";
-      const spar = "\u2225";
-      const sqcap = "\u2293";
-      const sqcaps = "\u2293\uFE00";
-      const sqcup = "\u2294";
-      const sqcups = "\u2294\uFE00";
-      const Sqrt = "\u221A";
-      const sqsub = "\u228F";
-      const sqsube = "\u2291";
-      const sqsubset = "\u228F";
-      const sqsubseteq = "\u2291";
-      const sqsup = "\u2290";
-      const sqsupe = "\u2292";
-      const sqsupset = "\u2290";
-      const sqsupseteq = "\u2292";
-      const square = "\u25A1";
-      const Square = "\u25A1";
-      const SquareIntersection = "\u2293";
-      const SquareSubset = "\u228F";
-      const SquareSubsetEqual = "\u2291";
-      const SquareSuperset = "\u2290";
-      const SquareSupersetEqual = "\u2292";
-      const SquareUnion = "\u2294";
-      const squarf = "\u25AA";
-      const squ = "\u25A1";
-      const squf = "\u25AA";
-      const srarr = "\u2192";
-      const Sscr = "\u{1D4AE}";
-      const sscr = "\u{1D4C8}";
-      const ssetmn = "\u2216";
-      const ssmile = "\u2323";
-      const sstarf = "\u22C6";
-      const Star = "\u22C6";
-      const star = "\u2606";
-      const starf = "\u2605";
-      const straightepsilon = "\u03F5";
-      const straightphi = "\u03D5";
-      const strns = "\xAF";
-      const sub = "\u2282";
-      const Sub = "\u22D0";
-      const subdot = "\u2ABD";
-      const subE = "\u2AC5";
-      const sube = "\u2286";
-      const subedot = "\u2AC3";
-      const submult = "\u2AC1";
-      const subnE = "\u2ACB";
-      const subne = "\u228A";
-      const subplus = "\u2ABF";
-      const subrarr = "\u2979";
-      const subset = "\u2282";
-      const Subset = "\u22D0";
-      const subseteq = "\u2286";
-      const subseteqq = "\u2AC5";
-      const SubsetEqual = "\u2286";
-      const subsetneq = "\u228A";
-      const subsetneqq = "\u2ACB";
-      const subsim = "\u2AC7";
-      const subsub = "\u2AD5";
-      const subsup = "\u2AD3";
-      const succapprox = "\u2AB8";
-      const succ = "\u227B";
-      const succcurlyeq = "\u227D";
-      const Succeeds = "\u227B";
-      const SucceedsEqual = "\u2AB0";
-      const SucceedsSlantEqual = "\u227D";
-      const SucceedsTilde = "\u227F";
-      const succeq = "\u2AB0";
-      const succnapprox = "\u2ABA";
-      const succneqq = "\u2AB6";
-      const succnsim = "\u22E9";
-      const succsim = "\u227F";
-      const SuchThat = "\u220B";
-      const sum = "\u2211";
-      const Sum = "\u2211";
-      const sung = "\u266A";
-      const sup1 = "\xB9";
-      const sup2 = "\xB2";
-      const sup3 = "\xB3";
-      const sup = "\u2283";
-      const Sup = "\u22D1";
-      const supdot = "\u2ABE";
-      const supdsub = "\u2AD8";
-      const supE = "\u2AC6";
-      const supe = "\u2287";
-      const supedot = "\u2AC4";
-      const Superset = "\u2283";
-      const SupersetEqual = "\u2287";
-      const suphsol = "\u27C9";
-      const suphsub = "\u2AD7";
-      const suplarr = "\u297B";
-      const supmult = "\u2AC2";
-      const supnE = "\u2ACC";
-      const supne = "\u228B";
-      const supplus = "\u2AC0";
-      const supset = "\u2283";
-      const Supset = "\u22D1";
-      const supseteq = "\u2287";
-      const supseteqq = "\u2AC6";
-      const supsetneq = "\u228B";
-      const supsetneqq = "\u2ACC";
-      const supsim = "\u2AC8";
-      const supsub = "\u2AD4";
-      const supsup = "\u2AD6";
-      const swarhk = "\u2926";
-      const swarr = "\u2199";
-      const swArr = "\u21D9";
-      const swarrow = "\u2199";
-      const swnwar = "\u292A";
-      const szlig = "\xDF";
-      const Tab$1 = "	";
-      const target = "\u2316";
-      const Tau = "\u03A4";
-      const tau = "\u03C4";
-      const tbrk = "\u23B4";
-      const Tcaron = "\u0164";
-      const tcaron = "\u0165";
-      const Tcedil = "\u0162";
-      const tcedil = "\u0163";
-      const Tcy = "\u0422";
-      const tcy = "\u0442";
-      const tdot = "\u20DB";
-      const telrec = "\u2315";
-      const Tfr = "\u{1D517}";
-      const tfr = "\u{1D531}";
-      const there4 = "\u2234";
-      const therefore = "\u2234";
-      const Therefore = "\u2234";
-      const Theta = "\u0398";
-      const theta = "\u03B8";
-      const thetasym = "\u03D1";
-      const thetav = "\u03D1";
-      const thickapprox = "\u2248";
-      const thicksim = "\u223C";
-      const ThickSpace = "\u205F\u200A";
-      const ThinSpace = "\u2009";
-      const thinsp = "\u2009";
-      const thkap = "\u2248";
-      const thksim = "\u223C";
-      const THORN = "\xDE";
-      const thorn = "\xFE";
-      const tilde = "\u02DC";
-      const Tilde = "\u223C";
-      const TildeEqual = "\u2243";
-      const TildeFullEqual = "\u2245";
-      const TildeTilde = "\u2248";
-      const timesbar = "\u2A31";
-      const timesb = "\u22A0";
-      const times = "\xD7";
-      const timesd = "\u2A30";
-      const tint = "\u222D";
-      const toea = "\u2928";
-      const topbot = "\u2336";
-      const topcir = "\u2AF1";
-      const top = "\u22A4";
-      const Topf = "\u{1D54B}";
-      const topf = "\u{1D565}";
-      const topfork = "\u2ADA";
-      const tosa = "\u2929";
-      const tprime = "\u2034";
-      const trade = "\u2122";
-      const TRADE = "\u2122";
-      const triangle = "\u25B5";
-      const triangledown = "\u25BF";
-      const triangleleft = "\u25C3";
-      const trianglelefteq = "\u22B4";
-      const triangleq = "\u225C";
-      const triangleright = "\u25B9";
-      const trianglerighteq = "\u22B5";
-      const tridot = "\u25EC";
-      const trie = "\u225C";
-      const triminus = "\u2A3A";
-      const TripleDot = "\u20DB";
-      const triplus = "\u2A39";
-      const trisb = "\u29CD";
-      const tritime = "\u2A3B";
-      const trpezium = "\u23E2";
-      const Tscr = "\u{1D4AF}";
-      const tscr = "\u{1D4C9}";
-      const TScy = "\u0426";
-      const tscy = "\u0446";
-      const TSHcy = "\u040B";
-      const tshcy = "\u045B";
-      const Tstrok = "\u0166";
-      const tstrok = "\u0167";
-      const twixt = "\u226C";
-      const twoheadleftarrow = "\u219E";
-      const twoheadrightarrow = "\u21A0";
-      const Uacute = "\xDA";
-      const uacute = "\xFA";
-      const uarr = "\u2191";
-      const Uarr = "\u219F";
-      const uArr = "\u21D1";
-      const Uarrocir = "\u2949";
-      const Ubrcy = "\u040E";
-      const ubrcy = "\u045E";
-      const Ubreve = "\u016C";
-      const ubreve = "\u016D";
-      const Ucirc = "\xDB";
-      const ucirc = "\xFB";
-      const Ucy = "\u0423";
-      const ucy = "\u0443";
-      const udarr = "\u21C5";
-      const Udblac = "\u0170";
-      const udblac = "\u0171";
-      const udhar = "\u296E";
-      const ufisht = "\u297E";
-      const Ufr = "\u{1D518}";
-      const ufr = "\u{1D532}";
-      const Ugrave = "\xD9";
-      const ugrave = "\xF9";
-      const uHar = "\u2963";
-      const uharl = "\u21BF";
-      const uharr = "\u21BE";
-      const uhblk = "\u2580";
-      const ulcorn = "\u231C";
-      const ulcorner = "\u231C";
-      const ulcrop = "\u230F";
-      const ultri = "\u25F8";
-      const Umacr = "\u016A";
-      const umacr = "\u016B";
-      const uml = "\xA8";
-      const UnderBar = "_";
-      const UnderBrace = "\u23DF";
-      const UnderBracket = "\u23B5";
-      const UnderParenthesis = "\u23DD";
-      const Union = "\u22C3";
-      const UnionPlus = "\u228E";
-      const Uogon = "\u0172";
-      const uogon = "\u0173";
-      const Uopf = "\u{1D54C}";
-      const uopf = "\u{1D566}";
-      const UpArrowBar = "\u2912";
-      const uparrow = "\u2191";
-      const UpArrow = "\u2191";
-      const Uparrow = "\u21D1";
-      const UpArrowDownArrow = "\u21C5";
-      const updownarrow = "\u2195";
-      const UpDownArrow = "\u2195";
-      const Updownarrow = "\u21D5";
-      const UpEquilibrium = "\u296E";
-      const upharpoonleft = "\u21BF";
-      const upharpoonright = "\u21BE";
-      const uplus = "\u228E";
-      const UpperLeftArrow = "\u2196";
-      const UpperRightArrow = "\u2197";
-      const upsi = "\u03C5";
-      const Upsi = "\u03D2";
-      const upsih = "\u03D2";
-      const Upsilon = "\u03A5";
-      const upsilon = "\u03C5";
-      const UpTeeArrow = "\u21A5";
-      const UpTee = "\u22A5";
-      const upuparrows = "\u21C8";
-      const urcorn = "\u231D";
-      const urcorner = "\u231D";
-      const urcrop = "\u230E";
-      const Uring = "\u016E";
-      const uring = "\u016F";
-      const urtri = "\u25F9";
-      const Uscr = "\u{1D4B0}";
-      const uscr = "\u{1D4CA}";
-      const utdot = "\u22F0";
-      const Utilde = "\u0168";
-      const utilde = "\u0169";
-      const utri = "\u25B5";
-      const utrif = "\u25B4";
-      const uuarr = "\u21C8";
-      const Uuml = "\xDC";
-      const uuml = "\xFC";
-      const uwangle = "\u29A7";
-      const vangrt = "\u299C";
-      const varepsilon = "\u03F5";
-      const varkappa = "\u03F0";
-      const varnothing = "\u2205";
-      const varphi = "\u03D5";
-      const varpi = "\u03D6";
-      const varpropto = "\u221D";
-      const varr = "\u2195";
-      const vArr = "\u21D5";
-      const varrho = "\u03F1";
-      const varsigma = "\u03C2";
-      const varsubsetneq = "\u228A\uFE00";
-      const varsubsetneqq = "\u2ACB\uFE00";
-      const varsupsetneq = "\u228B\uFE00";
-      const varsupsetneqq = "\u2ACC\uFE00";
-      const vartheta = "\u03D1";
-      const vartriangleleft = "\u22B2";
-      const vartriangleright = "\u22B3";
-      const vBar = "\u2AE8";
-      const Vbar = "\u2AEB";
-      const vBarv = "\u2AE9";
-      const Vcy = "\u0412";
-      const vcy = "\u0432";
-      const vdash = "\u22A2";
-      const vDash = "\u22A8";
-      const Vdash = "\u22A9";
-      const VDash = "\u22AB";
-      const Vdashl = "\u2AE6";
-      const veebar = "\u22BB";
-      const vee = "\u2228";
-      const Vee = "\u22C1";
-      const veeeq = "\u225A";
-      const vellip = "\u22EE";
-      const verbar = "|";
-      const Verbar = "\u2016";
-      const vert = "|";
-      const Vert = "\u2016";
-      const VerticalBar = "\u2223";
-      const VerticalLine = "|";
-      const VerticalSeparator = "\u2758";
-      const VerticalTilde = "\u2240";
-      const VeryThinSpace = "\u200A";
-      const Vfr = "\u{1D519}";
-      const vfr = "\u{1D533}";
-      const vltri = "\u22B2";
-      const vnsub = "\u2282\u20D2";
-      const vnsup = "\u2283\u20D2";
-      const Vopf = "\u{1D54D}";
-      const vopf = "\u{1D567}";
-      const vprop = "\u221D";
-      const vrtri = "\u22B3";
-      const Vscr = "\u{1D4B1}";
-      const vscr = "\u{1D4CB}";
-      const vsubnE = "\u2ACB\uFE00";
-      const vsubne = "\u228A\uFE00";
-      const vsupnE = "\u2ACC\uFE00";
-      const vsupne = "\u228B\uFE00";
-      const Vvdash = "\u22AA";
-      const vzigzag = "\u299A";
-      const Wcirc = "\u0174";
-      const wcirc = "\u0175";
-      const wedbar = "\u2A5F";
-      const wedge = "\u2227";
-      const Wedge = "\u22C0";
-      const wedgeq = "\u2259";
-      const weierp = "\u2118";
-      const Wfr = "\u{1D51A}";
-      const wfr = "\u{1D534}";
-      const Wopf = "\u{1D54E}";
-      const wopf = "\u{1D568}";
-      const wp = "\u2118";
-      const wr = "\u2240";
-      const wreath = "\u2240";
-      const Wscr = "\u{1D4B2}";
-      const wscr = "\u{1D4CC}";
-      const xcap = "\u22C2";
-      const xcirc = "\u25EF";
-      const xcup = "\u22C3";
-      const xdtri = "\u25BD";
-      const Xfr = "\u{1D51B}";
-      const xfr = "\u{1D535}";
-      const xharr = "\u27F7";
-      const xhArr = "\u27FA";
-      const Xi = "\u039E";
-      const xi = "\u03BE";
-      const xlarr = "\u27F5";
-      const xlArr = "\u27F8";
-      const xmap = "\u27FC";
-      const xnis = "\u22FB";
-      const xodot = "\u2A00";
-      const Xopf = "\u{1D54F}";
-      const xopf = "\u{1D569}";
-      const xoplus = "\u2A01";
-      const xotime = "\u2A02";
-      const xrarr = "\u27F6";
-      const xrArr = "\u27F9";
-      const Xscr = "\u{1D4B3}";
-      const xscr = "\u{1D4CD}";
-      const xsqcup = "\u2A06";
-      const xuplus = "\u2A04";
-      const xutri = "\u25B3";
-      const xvee = "\u22C1";
-      const xwedge = "\u22C0";
-      const Yacute = "\xDD";
-      const yacute = "\xFD";
-      const YAcy = "\u042F";
-      const yacy = "\u044F";
-      const Ycirc = "\u0176";
-      const ycirc = "\u0177";
-      const Ycy = "\u042B";
-      const ycy = "\u044B";
-      const yen = "\xA5";
-      const Yfr = "\u{1D51C}";
-      const yfr = "\u{1D536}";
-      const YIcy = "\u0407";
-      const yicy = "\u0457";
-      const Yopf = "\u{1D550}";
-      const yopf = "\u{1D56A}";
-      const Yscr = "\u{1D4B4}";
-      const yscr = "\u{1D4CE}";
-      const YUcy = "\u042E";
-      const yucy = "\u044E";
-      const yuml = "\xFF";
-      const Yuml = "\u0178";
-      const Zacute = "\u0179";
-      const zacute = "\u017A";
-      const Zcaron = "\u017D";
-      const zcaron = "\u017E";
-      const Zcy = "\u0417";
-      const zcy = "\u0437";
-      const Zdot = "\u017B";
-      const zdot = "\u017C";
-      const zeetrf = "\u2128";
-      const ZeroWidthSpace = "\u200B";
-      const Zeta = "\u0396";
-      const zeta = "\u03B6";
-      const zfr = "\u{1D537}";
-      const Zfr = "\u2128";
-      const ZHcy = "\u0416";
-      const zhcy = "\u0436";
-      const zigrarr = "\u21DD";
-      const zopf = "\u{1D56B}";
-      const Zopf = "\u2124";
-      const Zscr = "\u{1D4B5}";
-      const zscr = "\u{1D4CF}";
-      const zwj = "\u200D";
-      const zwnj = "\u200C";
-      var require$$0 = {
-        Aacute,
-        aacute,
-        Abreve,
-        abreve,
-        ac,
-        acd,
-        acE,
-        Acirc,
-        acirc,
-        acute,
-        Acy,
-        acy,
-        AElig,
-        aelig,
-        af,
-        Afr,
-        afr,
-        Agrave,
-        agrave,
-        alefsym,
-        aleph,
-        Alpha,
-        alpha,
-        Amacr,
-        amacr,
-        amalg,
-        amp,
-        AMP,
-        andand,
-        And,
-        and,
-        andd,
-        andslope,
-        andv,
-        ang,
-        ange,
-        angle,
-        angmsdaa,
-        angmsdab,
-        angmsdac,
-        angmsdad,
-        angmsdae,
-        angmsdaf,
-        angmsdag,
-        angmsdah,
-        angmsd,
-        angrt,
-        angrtvb,
-        angrtvbd,
-        angsph,
-        angst,
-        angzarr,
-        Aogon,
-        aogon,
-        Aopf,
-        aopf,
-        apacir,
-        ap,
-        apE,
-        ape,
-        apid,
-        apos,
-        ApplyFunction,
-        approx,
-        approxeq,
-        Aring,
-        aring,
-        Ascr,
-        ascr,
-        Assign,
-        ast,
-        asymp,
-        asympeq,
-        Atilde,
-        atilde,
-        Auml,
-        auml,
-        awconint,
-        awint,
-        backcong,
-        backepsilon,
-        backprime,
-        backsim,
-        backsimeq,
-        Backslash,
-        Barv,
-        barvee,
-        barwed,
-        Barwed,
-        barwedge,
-        bbrk,
-        bbrktbrk,
-        bcong,
-        Bcy,
-        bcy,
-        bdquo,
-        becaus,
-        because,
-        Because,
-        bemptyv,
-        bepsi,
-        bernou,
-        Bernoullis,
-        Beta,
-        beta,
-        beth,
-        between,
-        Bfr,
-        bfr,
-        bigcap,
-        bigcirc,
-        bigcup,
-        bigodot,
-        bigoplus,
-        bigotimes,
-        bigsqcup,
-        bigstar,
-        bigtriangledown,
-        bigtriangleup,
-        biguplus,
-        bigvee,
-        bigwedge,
-        bkarow,
-        blacklozenge,
-        blacksquare,
-        blacktriangle,
-        blacktriangledown,
-        blacktriangleleft,
-        blacktriangleright,
-        blank,
-        blk12,
-        blk14,
-        blk34,
-        block: block$2,
-        bne,
-        bnequiv,
-        bNot,
-        bnot,
-        Bopf,
-        bopf,
-        bot,
-        bottom,
-        bowtie,
-        boxbox,
-        boxdl,
-        boxdL,
-        boxDl,
-        boxDL,
-        boxdr,
-        boxdR,
-        boxDr,
-        boxDR,
-        boxh,
-        boxH,
-        boxhd,
-        boxHd,
-        boxhD,
-        boxHD,
-        boxhu,
-        boxHu,
-        boxhU,
-        boxHU,
-        boxminus,
-        boxplus,
-        boxtimes,
-        boxul,
-        boxuL,
-        boxUl,
-        boxUL,
-        boxur,
-        boxuR,
-        boxUr,
-        boxUR,
-        boxv,
-        boxV,
-        boxvh,
-        boxvH,
-        boxVh,
-        boxVH,
-        boxvl,
-        boxvL,
-        boxVl,
-        boxVL,
-        boxvr,
-        boxvR,
-        boxVr,
-        boxVR,
-        bprime,
-        breve,
-        Breve,
-        brvbar,
-        bscr,
-        Bscr,
-        bsemi,
-        bsim,
-        bsime,
-        bsolb,
-        bsol,
-        bsolhsub,
-        bull,
-        bullet,
-        bump,
-        bumpE,
-        bumpe,
-        Bumpeq,
-        bumpeq,
-        Cacute,
-        cacute,
-        capand,
-        capbrcup,
-        capcap,
-        cap,
-        Cap,
-        capcup,
-        capdot,
-        CapitalDifferentialD,
-        caps,
-        caret,
-        caron,
-        Cayleys,
-        ccaps,
-        Ccaron,
-        ccaron,
-        Ccedil,
-        ccedil,
-        Ccirc,
-        ccirc,
-        Cconint,
-        ccups,
-        ccupssm,
-        Cdot,
-        cdot,
-        cedil,
-        Cedilla,
-        cemptyv,
-        cent,
-        centerdot,
-        CenterDot,
-        cfr,
-        Cfr,
-        CHcy,
-        chcy,
-        check,
-        checkmark,
-        Chi,
-        chi,
-        circ,
-        circeq,
-        circlearrowleft,
-        circlearrowright,
-        circledast,
-        circledcirc,
-        circleddash,
-        CircleDot,
-        circledR,
-        circledS,
-        CircleMinus,
-        CirclePlus,
-        CircleTimes,
-        cir,
-        cirE,
-        cire,
-        cirfnint,
-        cirmid,
-        cirscir,
-        ClockwiseContourIntegral,
-        CloseCurlyDoubleQuote,
-        CloseCurlyQuote,
-        clubs,
-        clubsuit,
-        colon,
-        Colon,
-        Colone,
-        colone,
-        coloneq,
-        comma,
-        commat,
-        comp,
-        compfn,
-        complement,
-        complexes,
-        cong,
-        congdot,
-        Congruent,
-        conint,
-        Conint,
-        ContourIntegral,
-        copf,
-        Copf,
-        coprod,
-        Coproduct,
-        copy,
-        COPY,
-        copysr,
-        CounterClockwiseContourIntegral,
-        crarr,
-        cross,
-        Cross,
-        Cscr,
-        cscr,
-        csub,
-        csube,
-        csup,
-        csupe,
-        ctdot,
-        cudarrl,
-        cudarrr,
-        cuepr,
-        cuesc,
-        cularr,
-        cularrp,
-        cupbrcap,
-        cupcap,
-        CupCap,
-        cup,
-        Cup,
-        cupcup,
-        cupdot,
-        cupor,
-        cups,
-        curarr,
-        curarrm,
-        curlyeqprec,
-        curlyeqsucc,
-        curlyvee,
-        curlywedge,
-        curren,
-        curvearrowleft,
-        curvearrowright,
-        cuvee,
-        cuwed,
-        cwconint,
-        cwint,
-        cylcty,
-        dagger,
-        Dagger,
-        daleth,
-        darr,
-        Darr,
-        dArr,
-        dash,
-        Dashv,
-        dashv,
-        dbkarow,
-        dblac,
-        Dcaron,
-        dcaron,
-        Dcy,
-        dcy,
-        ddagger,
-        ddarr,
-        DD,
-        dd,
-        DDotrahd,
-        ddotseq,
-        deg,
-        Del,
-        Delta,
-        delta,
-        demptyv,
-        dfisht,
-        Dfr,
-        dfr,
-        dHar,
-        dharl,
-        dharr,
-        DiacriticalAcute,
-        DiacriticalDot,
-        DiacriticalDoubleAcute,
-        DiacriticalGrave,
-        DiacriticalTilde,
-        diam,
-        diamond,
-        Diamond,
-        diamondsuit,
-        diams,
-        die,
-        DifferentialD,
-        digamma,
-        disin,
-        div,
-        divide,
-        divideontimes,
-        divonx,
-        DJcy,
-        djcy,
-        dlcorn,
-        dlcrop,
-        dollar,
-        Dopf,
-        dopf,
-        Dot,
-        dot,
-        DotDot,
-        doteq,
-        doteqdot,
-        DotEqual,
-        dotminus,
-        dotplus,
-        dotsquare,
-        doublebarwedge,
-        DoubleContourIntegral,
-        DoubleDot,
-        DoubleDownArrow,
-        DoubleLeftArrow,
-        DoubleLeftRightArrow,
-        DoubleLeftTee,
-        DoubleLongLeftArrow,
-        DoubleLongLeftRightArrow,
-        DoubleLongRightArrow,
-        DoubleRightArrow,
-        DoubleRightTee,
-        DoubleUpArrow,
-        DoubleUpDownArrow,
-        DoubleVerticalBar,
-        DownArrowBar,
-        downarrow,
-        DownArrow,
-        Downarrow,
-        DownArrowUpArrow,
-        DownBreve,
-        downdownarrows,
-        downharpoonleft,
-        downharpoonright,
-        DownLeftRightVector,
-        DownLeftTeeVector,
-        DownLeftVectorBar,
-        DownLeftVector,
-        DownRightTeeVector,
-        DownRightVectorBar,
-        DownRightVector,
-        DownTeeArrow,
-        DownTee,
-        drbkarow,
-        drcorn,
-        drcrop,
-        Dscr,
-        dscr,
-        DScy,
-        dscy,
-        dsol,
-        Dstrok,
-        dstrok,
-        dtdot,
-        dtri,
-        dtrif,
-        duarr,
-        duhar,
-        dwangle,
-        DZcy,
-        dzcy,
-        dzigrarr,
-        Eacute,
-        eacute,
-        easter,
-        Ecaron,
-        ecaron,
-        Ecirc,
-        ecirc,
-        ecir,
-        ecolon,
-        Ecy,
-        ecy,
-        eDDot,
-        Edot,
-        edot,
-        eDot,
-        ee,
-        efDot,
-        Efr,
-        efr,
-        eg,
-        Egrave,
-        egrave,
-        egs,
-        egsdot,
-        el,
-        Element,
-        elinters,
-        ell,
-        els,
-        elsdot,
-        Emacr,
-        emacr,
-        empty,
-        emptyset,
-        EmptySmallSquare,
-        emptyv,
-        EmptyVerySmallSquare,
-        emsp13,
-        emsp14,
-        emsp,
-        ENG,
-        eng,
-        ensp,
-        Eogon,
-        eogon,
-        Eopf,
-        eopf,
-        epar,
-        eparsl,
-        eplus,
-        epsi,
-        Epsilon,
-        epsilon,
-        epsiv,
-        eqcirc,
-        eqcolon,
-        eqsim,
-        eqslantgtr,
-        eqslantless,
-        Equal,
-        equals,
-        EqualTilde,
-        equest,
-        Equilibrium,
-        equiv,
-        equivDD,
-        eqvparsl,
-        erarr,
-        erDot,
-        escr,
-        Escr,
-        esdot,
-        Esim,
-        esim,
-        Eta,
-        eta,
-        ETH,
-        eth,
-        Euml,
-        euml,
-        euro,
-        excl,
-        exist,
-        Exists,
-        expectation,
-        exponentiale,
-        ExponentialE,
-        fallingdotseq,
-        Fcy,
-        fcy,
-        female,
-        ffilig,
-        fflig,
-        ffllig,
-        Ffr,
-        ffr,
-        filig,
-        FilledSmallSquare,
-        FilledVerySmallSquare,
-        fjlig,
-        flat,
-        fllig,
-        fltns,
-        fnof,
-        Fopf,
-        fopf,
-        forall,
-        ForAll,
-        fork,
-        forkv,
-        Fouriertrf,
-        fpartint,
-        frac12,
-        frac13,
-        frac14,
-        frac15,
-        frac16,
-        frac18,
-        frac23,
-        frac25,
-        frac34,
-        frac35,
-        frac38,
-        frac45,
-        frac56,
-        frac58,
-        frac78,
-        frasl,
-        frown,
-        fscr,
-        Fscr,
-        gacute,
-        Gamma,
-        gamma,
-        Gammad,
-        gammad,
-        gap,
-        Gbreve,
-        gbreve,
-        Gcedil,
-        Gcirc,
-        gcirc,
-        Gcy,
-        gcy,
-        Gdot,
-        gdot,
-        ge,
-        gE,
-        gEl,
-        gel,
-        geq,
-        geqq,
-        geqslant,
-        gescc,
-        ges,
-        gesdot,
-        gesdoto,
-        gesdotol,
-        gesl,
-        gesles,
-        Gfr,
-        gfr,
-        gg,
-        Gg,
-        ggg,
-        gimel,
-        GJcy,
-        gjcy,
-        gla,
-        gl,
-        glE,
-        glj,
-        gnap,
-        gnapprox,
-        gne,
-        gnE,
-        gneq,
-        gneqq,
-        gnsim,
-        Gopf,
-        gopf,
-        grave,
-        GreaterEqual,
-        GreaterEqualLess,
-        GreaterFullEqual,
-        GreaterGreater,
-        GreaterLess,
-        GreaterSlantEqual,
-        GreaterTilde,
-        Gscr,
-        gscr,
-        gsim,
-        gsime,
-        gsiml,
-        gtcc,
-        gtcir,
-        gt,
-        GT,
-        Gt,
-        gtdot,
-        gtlPar,
-        gtquest,
-        gtrapprox,
-        gtrarr,
-        gtrdot,
-        gtreqless,
-        gtreqqless,
-        gtrless,
-        gtrsim,
-        gvertneqq,
-        gvnE,
-        Hacek,
-        hairsp,
-        half,
-        hamilt,
-        HARDcy,
-        hardcy,
-        harrcir,
-        harr,
-        hArr,
-        harrw,
-        Hat,
-        hbar,
-        Hcirc,
-        hcirc,
-        hearts,
-        heartsuit,
-        hellip,
-        hercon,
-        hfr,
-        Hfr,
-        HilbertSpace,
-        hksearow,
-        hkswarow,
-        hoarr,
-        homtht,
-        hookleftarrow,
-        hookrightarrow,
-        hopf,
-        Hopf,
-        horbar,
-        HorizontalLine,
-        hscr,
-        Hscr,
-        hslash,
-        Hstrok,
-        hstrok,
-        HumpDownHump,
-        HumpEqual,
-        hybull,
-        hyphen,
-        Iacute,
-        iacute,
-        ic,
-        Icirc,
-        icirc,
-        Icy,
-        icy,
-        Idot,
-        IEcy,
-        iecy,
-        iexcl,
-        iff,
-        ifr,
-        Ifr,
-        Igrave,
-        igrave,
-        ii,
-        iiiint,
-        iiint,
-        iinfin,
-        iiota,
-        IJlig,
-        ijlig,
-        Imacr,
-        imacr,
-        image: image$1,
-        ImaginaryI,
-        imagline,
-        imagpart,
-        imath,
-        Im,
-        imof,
-        imped,
-        Implies,
-        incare,
-        in: "\u2208",
-        infin,
-        infintie,
-        inodot,
-        intcal,
-        int,
-        Int,
-        integers,
-        Integral,
-        intercal,
-        Intersection,
-        intlarhk,
-        intprod,
-        InvisibleComma,
-        InvisibleTimes,
-        IOcy,
-        iocy,
-        Iogon,
-        iogon,
-        Iopf,
-        iopf,
-        Iota,
-        iota,
-        iprod,
-        iquest,
-        iscr,
-        Iscr,
-        isin,
-        isindot,
-        isinE,
-        isins,
-        isinsv,
-        isinv,
-        it,
-        Itilde,
-        itilde,
-        Iukcy,
-        iukcy,
-        Iuml,
-        iuml,
-        Jcirc,
-        jcirc,
-        Jcy,
-        jcy,
-        Jfr,
-        jfr,
-        jmath,
-        Jopf,
-        jopf,
-        Jscr,
-        jscr,
-        Jsercy,
-        jsercy,
-        Jukcy,
-        jukcy,
-        Kappa,
-        kappa,
-        kappav,
-        Kcedil,
-        kcedil,
-        Kcy,
-        kcy,
-        Kfr,
-        kfr,
-        kgreen,
-        KHcy,
-        khcy,
-        KJcy,
-        kjcy,
-        Kopf,
-        kopf,
-        Kscr,
-        kscr,
-        lAarr,
-        Lacute,
-        lacute,
-        laemptyv,
-        lagran,
-        Lambda,
-        lambda,
-        lang,
-        Lang,
-        langd,
-        langle,
-        lap,
-        Laplacetrf,
-        laquo,
-        larrb,
-        larrbfs,
-        larr,
-        Larr,
-        lArr,
-        larrfs,
-        larrhk,
-        larrlp,
-        larrpl,
-        larrsim,
-        larrtl,
-        latail,
-        lAtail,
-        lat,
-        late,
-        lates,
-        lbarr,
-        lBarr,
-        lbbrk,
-        lbrace,
-        lbrack,
-        lbrke,
-        lbrksld,
-        lbrkslu,
-        Lcaron,
-        lcaron,
-        Lcedil,
-        lcedil,
-        lceil,
-        lcub,
-        Lcy,
-        lcy,
-        ldca,
-        ldquo,
-        ldquor,
-        ldrdhar,
-        ldrushar,
-        ldsh,
-        le,
-        lE,
-        LeftAngleBracket,
-        LeftArrowBar,
-        leftarrow,
-        LeftArrow,
-        Leftarrow,
-        LeftArrowRightArrow,
-        leftarrowtail,
-        LeftCeiling,
-        LeftDoubleBracket,
-        LeftDownTeeVector,
-        LeftDownVectorBar,
-        LeftDownVector,
-        LeftFloor,
-        leftharpoondown,
-        leftharpoonup,
-        leftleftarrows,
-        leftrightarrow,
-        LeftRightArrow,
-        Leftrightarrow,
-        leftrightarrows,
-        leftrightharpoons,
-        leftrightsquigarrow,
-        LeftRightVector,
-        LeftTeeArrow,
-        LeftTee,
-        LeftTeeVector,
-        leftthreetimes,
-        LeftTriangleBar,
-        LeftTriangle,
-        LeftTriangleEqual,
-        LeftUpDownVector,
-        LeftUpTeeVector,
-        LeftUpVectorBar,
-        LeftUpVector,
-        LeftVectorBar,
-        LeftVector,
-        lEg,
-        leg,
-        leq,
-        leqq,
-        leqslant,
-        lescc,
-        les,
-        lesdot,
-        lesdoto,
-        lesdotor,
-        lesg,
-        lesges,
-        lessapprox,
-        lessdot,
-        lesseqgtr,
-        lesseqqgtr,
-        LessEqualGreater,
-        LessFullEqual,
-        LessGreater,
-        lessgtr,
-        LessLess,
-        lesssim,
-        LessSlantEqual,
-        LessTilde,
-        lfisht,
-        lfloor,
-        Lfr,
-        lfr,
-        lg,
-        lgE,
-        lHar,
-        lhard,
-        lharu,
-        lharul,
-        lhblk,
-        LJcy,
-        ljcy,
-        llarr,
-        ll,
-        Ll,
-        llcorner,
-        Lleftarrow,
-        llhard,
-        lltri,
-        Lmidot,
-        lmidot,
-        lmoustache,
-        lmoust,
-        lnap,
-        lnapprox,
-        lne,
-        lnE,
-        lneq,
-        lneqq,
-        lnsim,
-        loang,
-        loarr,
-        lobrk,
-        longleftarrow,
-        LongLeftArrow,
-        Longleftarrow,
-        longleftrightarrow,
-        LongLeftRightArrow,
-        Longleftrightarrow,
-        longmapsto,
-        longrightarrow,
-        LongRightArrow,
-        Longrightarrow,
-        looparrowleft,
-        looparrowright,
-        lopar,
-        Lopf,
-        lopf,
-        loplus,
-        lotimes,
-        lowast,
-        lowbar,
-        LowerLeftArrow,
-        LowerRightArrow,
-        loz,
-        lozenge,
-        lozf,
-        lpar,
-        lparlt,
-        lrarr,
-        lrcorner,
-        lrhar,
-        lrhard,
-        lrm,
-        lrtri,
-        lsaquo,
-        lscr,
-        Lscr,
-        lsh,
-        Lsh,
-        lsim,
-        lsime,
-        lsimg,
-        lsqb,
-        lsquo,
-        lsquor,
-        Lstrok,
-        lstrok,
-        ltcc,
-        ltcir,
-        lt,
-        LT,
-        Lt,
-        ltdot,
-        lthree,
-        ltimes,
-        ltlarr,
-        ltquest,
-        ltri,
-        ltrie,
-        ltrif,
-        ltrPar,
-        lurdshar,
-        luruhar,
-        lvertneqq,
-        lvnE,
-        macr,
-        male,
-        malt,
-        maltese,
-        Map: "\u2905",
-        map: map$1,
-        mapsto,
-        mapstodown,
-        mapstoleft,
-        mapstoup,
-        marker,
-        mcomma,
-        Mcy,
-        mcy,
-        mdash,
-        mDDot,
-        measuredangle,
-        MediumSpace,
-        Mellintrf,
-        Mfr,
-        mfr,
-        mho,
-        micro,
-        midast,
-        midcir,
-        mid,
-        middot,
-        minusb,
-        minus,
-        minusd,
-        minusdu,
-        MinusPlus,
-        mlcp,
-        mldr,
-        mnplus,
-        models,
-        Mopf,
-        mopf,
-        mp,
-        mscr,
-        Mscr,
-        mstpos,
-        Mu,
-        mu,
-        multimap,
-        mumap,
-        nabla,
-        Nacute,
-        nacute,
-        nang,
-        nap,
-        napE,
-        napid,
-        napos,
-        napprox,
-        natural,
-        naturals,
-        natur,
-        nbsp,
-        nbump,
-        nbumpe,
-        ncap,
-        Ncaron,
-        ncaron,
-        Ncedil,
-        ncedil,
-        ncong,
-        ncongdot,
-        ncup,
-        Ncy,
-        ncy,
-        ndash,
-        nearhk,
-        nearr,
-        neArr,
-        nearrow,
-        ne,
-        nedot,
-        NegativeMediumSpace,
-        NegativeThickSpace,
-        NegativeThinSpace,
-        NegativeVeryThinSpace,
-        nequiv,
-        nesear,
-        nesim,
-        NestedGreaterGreater,
-        NestedLessLess,
-        NewLine,
-        nexist,
-        nexists,
-        Nfr,
-        nfr,
-        ngE,
-        nge,
-        ngeq,
-        ngeqq,
-        ngeqslant,
-        nges,
-        nGg,
-        ngsim,
-        nGt,
-        ngt,
-        ngtr,
-        nGtv,
-        nharr,
-        nhArr,
-        nhpar,
-        ni,
-        nis,
-        nisd,
-        niv,
-        NJcy,
-        njcy,
-        nlarr,
-        nlArr,
-        nldr,
-        nlE,
-        nle,
-        nleftarrow,
-        nLeftarrow,
-        nleftrightarrow,
-        nLeftrightarrow,
-        nleq,
-        nleqq,
-        nleqslant,
-        nles,
-        nless,
-        nLl,
-        nlsim,
-        nLt,
-        nlt,
-        nltri,
-        nltrie,
-        nLtv,
-        nmid,
-        NoBreak,
-        NonBreakingSpace,
-        nopf,
-        Nopf,
-        Not,
-        not,
-        NotCongruent,
-        NotCupCap,
-        NotDoubleVerticalBar,
-        NotElement,
-        NotEqual,
-        NotEqualTilde,
-        NotExists,
-        NotGreater,
-        NotGreaterEqual,
-        NotGreaterFullEqual,
-        NotGreaterGreater,
-        NotGreaterLess,
-        NotGreaterSlantEqual,
-        NotGreaterTilde,
-        NotHumpDownHump,
-        NotHumpEqual,
-        notin,
-        notindot,
-        notinE,
-        notinva,
-        notinvb,
-        notinvc,
-        NotLeftTriangleBar,
-        NotLeftTriangle,
-        NotLeftTriangleEqual,
-        NotLess,
-        NotLessEqual,
-        NotLessGreater,
-        NotLessLess,
-        NotLessSlantEqual,
-        NotLessTilde,
-        NotNestedGreaterGreater,
-        NotNestedLessLess,
-        notni,
-        notniva,
-        notnivb,
-        notnivc,
-        NotPrecedes,
-        NotPrecedesEqual,
-        NotPrecedesSlantEqual,
-        NotReverseElement,
-        NotRightTriangleBar,
-        NotRightTriangle,
-        NotRightTriangleEqual,
-        NotSquareSubset,
-        NotSquareSubsetEqual,
-        NotSquareSuperset,
-        NotSquareSupersetEqual,
-        NotSubset,
-        NotSubsetEqual,
-        NotSucceeds,
-        NotSucceedsEqual,
-        NotSucceedsSlantEqual,
-        NotSucceedsTilde,
-        NotSuperset,
-        NotSupersetEqual,
-        NotTilde,
-        NotTildeEqual,
-        NotTildeFullEqual,
-        NotTildeTilde,
-        NotVerticalBar,
-        nparallel,
-        npar,
-        nparsl,
-        npart,
-        npolint,
-        npr,
-        nprcue,
-        nprec,
-        npreceq,
-        npre,
-        nrarrc,
-        nrarr,
-        nrArr,
-        nrarrw,
-        nrightarrow,
-        nRightarrow,
-        nrtri,
-        nrtrie,
-        nsc,
-        nsccue,
-        nsce,
-        Nscr,
-        nscr,
-        nshortmid,
-        nshortparallel,
-        nsim,
-        nsime,
-        nsimeq,
-        nsmid,
-        nspar,
-        nsqsube,
-        nsqsupe,
-        nsub,
-        nsubE,
-        nsube,
-        nsubset,
-        nsubseteq,
-        nsubseteqq,
-        nsucc,
-        nsucceq,
-        nsup,
-        nsupE,
-        nsupe,
-        nsupset,
-        nsupseteq,
-        nsupseteqq,
-        ntgl,
-        Ntilde,
-        ntilde,
-        ntlg,
-        ntriangleleft,
-        ntrianglelefteq,
-        ntriangleright,
-        ntrianglerighteq,
-        Nu,
-        nu,
-        num,
-        numero,
-        numsp,
-        nvap,
-        nvdash,
-        nvDash,
-        nVdash,
-        nVDash,
-        nvge,
-        nvgt,
-        nvHarr,
-        nvinfin,
-        nvlArr,
-        nvle,
-        nvlt,
-        nvltrie,
-        nvrArr,
-        nvrtrie,
-        nvsim,
-        nwarhk,
-        nwarr,
-        nwArr,
-        nwarrow,
-        nwnear,
-        Oacute,
-        oacute,
-        oast,
-        Ocirc,
-        ocirc,
-        ocir,
-        Ocy,
-        ocy,
-        odash,
-        Odblac,
-        odblac,
-        odiv,
-        odot,
-        odsold,
-        OElig,
-        oelig,
-        ofcir,
-        Ofr,
-        ofr,
-        ogon,
-        Ograve,
-        ograve,
-        ogt,
-        ohbar,
-        ohm,
-        oint,
-        olarr,
-        olcir,
-        olcross,
-        oline,
-        olt,
-        Omacr,
-        omacr,
-        Omega,
-        omega,
-        Omicron,
-        omicron,
-        omid,
-        ominus,
-        Oopf,
-        oopf,
-        opar,
-        OpenCurlyDoubleQuote,
-        OpenCurlyQuote,
-        operp,
-        oplus,
-        orarr,
-        Or,
-        or,
-        ord,
-        order,
-        orderof,
-        ordf,
-        ordm,
-        origof,
-        oror,
-        orslope,
-        orv,
-        oS,
-        Oscr,
-        oscr,
-        Oslash,
-        oslash,
-        osol,
-        Otilde,
-        otilde,
-        otimesas,
-        Otimes,
-        otimes,
-        Ouml,
-        ouml,
-        ovbar,
-        OverBar,
-        OverBrace,
-        OverBracket,
-        OverParenthesis,
-        para,
-        parallel,
-        par,
-        parsim,
-        parsl,
-        part,
-        PartialD,
-        Pcy,
-        pcy,
-        percnt,
-        period,
-        permil,
-        perp,
-        pertenk,
-        Pfr,
-        pfr,
-        Phi,
-        phi,
-        phiv,
-        phmmat,
-        phone,
-        Pi,
-        pi,
-        pitchfork,
-        piv,
-        planck,
-        planckh,
-        plankv,
-        plusacir,
-        plusb,
-        pluscir,
-        plus,
-        plusdo,
-        plusdu,
-        pluse,
-        PlusMinus,
-        plusmn,
-        plussim,
-        plustwo,
-        pm,
-        Poincareplane,
-        pointint,
-        popf,
-        Popf,
-        pound,
-        prap,
-        Pr,
-        pr,
-        prcue,
-        precapprox,
-        prec,
-        preccurlyeq,
-        Precedes,
-        PrecedesEqual,
-        PrecedesSlantEqual,
-        PrecedesTilde,
-        preceq,
-        precnapprox,
-        precneqq,
-        precnsim,
-        pre,
-        prE,
-        precsim,
-        prime,
-        Prime,
-        primes,
-        prnap,
-        prnE,
-        prnsim,
-        prod,
-        Product,
-        profalar,
-        profline,
-        profsurf,
-        prop,
-        Proportional,
-        Proportion,
-        propto,
-        prsim,
-        prurel,
-        Pscr,
-        pscr,
-        Psi,
-        psi,
-        puncsp,
-        Qfr,
-        qfr,
-        qint,
-        qopf,
-        Qopf,
-        qprime,
-        Qscr,
-        qscr,
-        quaternions,
-        quatint,
-        quest,
-        questeq,
-        quot,
-        QUOT,
-        rAarr,
-        race,
-        Racute,
-        racute,
-        radic,
-        raemptyv,
-        rang,
-        Rang,
-        rangd,
-        range,
-        rangle,
-        raquo,
-        rarrap,
-        rarrb,
-        rarrbfs,
-        rarrc,
-        rarr,
-        Rarr,
-        rArr,
-        rarrfs,
-        rarrhk,
-        rarrlp,
-        rarrpl,
-        rarrsim,
-        Rarrtl,
-        rarrtl,
-        rarrw,
-        ratail,
-        rAtail,
-        ratio,
-        rationals,
-        rbarr,
-        rBarr,
-        RBarr,
-        rbbrk,
-        rbrace,
-        rbrack,
-        rbrke,
-        rbrksld,
-        rbrkslu,
-        Rcaron,
-        rcaron,
-        Rcedil,
-        rcedil,
-        rceil,
-        rcub,
-        Rcy,
-        rcy,
-        rdca,
-        rdldhar,
-        rdquo,
-        rdquor,
-        rdsh,
-        real,
-        realine,
-        realpart,
-        reals,
-        Re,
-        rect,
-        reg,
-        REG,
-        ReverseElement,
-        ReverseEquilibrium,
-        ReverseUpEquilibrium,
-        rfisht,
-        rfloor,
-        rfr,
-        Rfr,
-        rHar,
-        rhard,
-        rharu,
-        rharul,
-        Rho,
-        rho,
-        rhov,
-        RightAngleBracket,
-        RightArrowBar,
-        rightarrow,
-        RightArrow,
-        Rightarrow,
-        RightArrowLeftArrow,
-        rightarrowtail,
-        RightCeiling,
-        RightDoubleBracket,
-        RightDownTeeVector,
-        RightDownVectorBar,
-        RightDownVector,
-        RightFloor,
-        rightharpoondown,
-        rightharpoonup,
-        rightleftarrows,
-        rightleftharpoons,
-        rightrightarrows,
-        rightsquigarrow,
-        RightTeeArrow,
-        RightTee,
-        RightTeeVector,
-        rightthreetimes,
-        RightTriangleBar,
-        RightTriangle,
-        RightTriangleEqual,
-        RightUpDownVector,
-        RightUpTeeVector,
-        RightUpVectorBar,
-        RightUpVector,
-        RightVectorBar,
-        RightVector,
-        ring,
-        risingdotseq,
-        rlarr,
-        rlhar,
-        rlm,
-        rmoustache,
-        rmoust,
-        rnmid,
-        roang,
-        roarr,
-        robrk,
-        ropar,
-        ropf,
-        Ropf,
-        roplus,
-        rotimes,
-        RoundImplies,
-        rpar,
-        rpargt,
-        rppolint,
-        rrarr,
-        Rrightarrow,
-        rsaquo,
-        rscr,
-        Rscr,
-        rsh,
-        Rsh,
-        rsqb,
-        rsquo,
-        rsquor,
-        rthree,
-        rtimes,
-        rtri,
-        rtrie,
-        rtrif,
-        rtriltri,
-        RuleDelayed,
-        ruluhar,
-        rx,
-        Sacute,
-        sacute,
-        sbquo,
-        scap,
-        Scaron,
-        scaron,
-        Sc,
-        sc,
-        sccue,
-        sce,
-        scE,
-        Scedil,
-        scedil,
-        Scirc,
-        scirc,
-        scnap,
-        scnE,
-        scnsim,
-        scpolint,
-        scsim,
-        Scy,
-        scy,
-        sdotb,
-        sdot,
-        sdote,
-        searhk,
-        searr,
-        seArr,
-        searrow,
-        sect,
-        semi,
-        seswar,
-        setminus,
-        setmn,
-        sext,
-        Sfr,
-        sfr,
-        sfrown,
-        sharp,
-        SHCHcy,
-        shchcy,
-        SHcy,
-        shcy,
-        ShortDownArrow,
-        ShortLeftArrow,
-        shortmid,
-        shortparallel,
-        ShortRightArrow,
-        ShortUpArrow,
-        shy,
-        Sigma,
-        sigma,
-        sigmaf,
-        sigmav,
-        sim,
-        simdot,
-        sime,
-        simeq,
-        simg,
-        simgE,
-        siml,
-        simlE,
-        simne,
-        simplus,
-        simrarr,
-        slarr,
-        SmallCircle,
-        smallsetminus,
-        smashp,
-        smeparsl,
-        smid,
-        smile,
-        smt,
-        smte,
-        smtes,
-        SOFTcy,
-        softcy,
-        solbar,
-        solb,
-        sol,
-        Sopf,
-        sopf,
-        spades,
-        spadesuit,
-        spar,
-        sqcap,
-        sqcaps,
-        sqcup,
-        sqcups,
-        Sqrt,
-        sqsub,
-        sqsube,
-        sqsubset,
-        sqsubseteq,
-        sqsup,
-        sqsupe,
-        sqsupset,
-        sqsupseteq,
-        square,
-        Square,
-        SquareIntersection,
-        SquareSubset,
-        SquareSubsetEqual,
-        SquareSuperset,
-        SquareSupersetEqual,
-        SquareUnion,
-        squarf,
-        squ,
-        squf,
-        srarr,
-        Sscr,
-        sscr,
-        ssetmn,
-        ssmile,
-        sstarf,
-        Star,
-        star,
-        starf,
-        straightepsilon,
-        straightphi,
-        strns,
-        sub,
-        Sub,
-        subdot,
-        subE,
-        sube,
-        subedot,
-        submult,
-        subnE,
-        subne,
-        subplus,
-        subrarr,
-        subset,
-        Subset,
-        subseteq,
-        subseteqq,
-        SubsetEqual,
-        subsetneq,
-        subsetneqq,
-        subsim,
-        subsub,
-        subsup,
-        succapprox,
-        succ,
-        succcurlyeq,
-        Succeeds,
-        SucceedsEqual,
-        SucceedsSlantEqual,
-        SucceedsTilde,
-        succeq,
-        succnapprox,
-        succneqq,
-        succnsim,
-        succsim,
-        SuchThat,
-        sum,
-        Sum,
-        sung,
-        sup1,
-        sup2,
-        sup3,
-        sup,
-        Sup,
-        supdot,
-        supdsub,
-        supE,
-        supe,
-        supedot,
-        Superset,
-        SupersetEqual,
-        suphsol,
-        suphsub,
-        suplarr,
-        supmult,
-        supnE,
-        supne,
-        supplus,
-        supset,
-        Supset,
-        supseteq,
-        supseteqq,
-        supsetneq,
-        supsetneqq,
-        supsim,
-        supsub,
-        supsup,
-        swarhk,
-        swarr,
-        swArr,
-        swarrow,
-        swnwar,
-        szlig,
-        Tab: Tab$1,
-        target,
-        Tau,
-        tau,
-        tbrk,
-        Tcaron,
-        tcaron,
-        Tcedil,
-        tcedil,
-        Tcy,
-        tcy,
-        tdot,
-        telrec,
-        Tfr,
-        tfr,
-        there4,
-        therefore,
-        Therefore,
-        Theta,
-        theta,
-        thetasym,
-        thetav,
-        thickapprox,
-        thicksim,
-        ThickSpace,
-        ThinSpace,
-        thinsp,
-        thkap,
-        thksim,
-        THORN,
-        thorn,
-        tilde,
-        Tilde,
-        TildeEqual,
-        TildeFullEqual,
-        TildeTilde,
-        timesbar,
-        timesb,
-        times,
-        timesd,
-        tint,
-        toea,
-        topbot,
-        topcir,
-        top,
-        Topf,
-        topf,
-        topfork,
-        tosa,
-        tprime,
-        trade,
-        TRADE,
-        triangle,
-        triangledown,
-        triangleleft,
-        trianglelefteq,
-        triangleq,
-        triangleright,
-        trianglerighteq,
-        tridot,
-        trie,
-        triminus,
-        TripleDot,
-        triplus,
-        trisb,
-        tritime,
-        trpezium,
-        Tscr,
-        tscr,
-        TScy,
-        tscy,
-        TSHcy,
-        tshcy,
-        Tstrok,
-        tstrok,
-        twixt,
-        twoheadleftarrow,
-        twoheadrightarrow,
-        Uacute,
-        uacute,
-        uarr,
-        Uarr,
-        uArr,
-        Uarrocir,
-        Ubrcy,
-        ubrcy,
-        Ubreve,
-        ubreve,
-        Ucirc,
-        ucirc,
-        Ucy,
-        ucy,
-        udarr,
-        Udblac,
-        udblac,
-        udhar,
-        ufisht,
-        Ufr,
-        ufr,
-        Ugrave,
-        ugrave,
-        uHar,
-        uharl,
-        uharr,
-        uhblk,
-        ulcorn,
-        ulcorner,
-        ulcrop,
-        ultri,
-        Umacr,
-        umacr,
-        uml,
-        UnderBar,
-        UnderBrace,
-        UnderBracket,
-        UnderParenthesis,
-        Union,
-        UnionPlus,
-        Uogon,
-        uogon,
-        Uopf,
-        uopf,
-        UpArrowBar,
-        uparrow,
-        UpArrow,
-        Uparrow,
-        UpArrowDownArrow,
-        updownarrow,
-        UpDownArrow,
-        Updownarrow,
-        UpEquilibrium,
-        upharpoonleft,
-        upharpoonright,
-        uplus,
-        UpperLeftArrow,
-        UpperRightArrow,
-        upsi,
-        Upsi,
-        upsih,
-        Upsilon,
-        upsilon,
-        UpTeeArrow,
-        UpTee,
-        upuparrows,
-        urcorn,
-        urcorner,
-        urcrop,
-        Uring,
-        uring,
-        urtri,
-        Uscr,
-        uscr,
-        utdot,
-        Utilde,
-        utilde,
-        utri,
-        utrif,
-        uuarr,
-        Uuml,
-        uuml,
-        uwangle,
-        vangrt,
-        varepsilon,
-        varkappa,
-        varnothing,
-        varphi,
-        varpi,
-        varpropto,
-        varr,
-        vArr,
-        varrho,
-        varsigma,
-        varsubsetneq,
-        varsubsetneqq,
-        varsupsetneq,
-        varsupsetneqq,
-        vartheta,
-        vartriangleleft,
-        vartriangleright,
-        vBar,
-        Vbar,
-        vBarv,
-        Vcy,
-        vcy,
-        vdash,
-        vDash,
-        Vdash,
-        VDash,
-        Vdashl,
-        veebar,
-        vee,
-        Vee,
-        veeeq,
-        vellip,
-        verbar,
-        Verbar,
-        vert,
-        Vert,
-        VerticalBar,
-        VerticalLine,
-        VerticalSeparator,
-        VerticalTilde,
-        VeryThinSpace,
-        Vfr,
-        vfr,
-        vltri,
-        vnsub,
-        vnsup,
-        Vopf,
-        vopf,
-        vprop,
-        vrtri,
-        Vscr,
-        vscr,
-        vsubnE,
-        vsubne,
-        vsupnE,
-        vsupne,
-        Vvdash,
-        vzigzag,
-        Wcirc,
-        wcirc,
-        wedbar,
-        wedge,
-        Wedge,
-        wedgeq,
-        weierp,
-        Wfr,
-        wfr,
-        Wopf,
-        wopf,
-        wp,
-        wr,
-        wreath,
-        Wscr,
-        wscr,
-        xcap,
-        xcirc,
-        xcup,
-        xdtri,
-        Xfr,
-        xfr,
-        xharr,
-        xhArr,
-        Xi,
-        xi,
-        xlarr,
-        xlArr,
-        xmap,
-        xnis,
-        xodot,
-        Xopf,
-        xopf,
-        xoplus,
-        xotime,
-        xrarr,
-        xrArr,
-        Xscr,
-        xscr,
-        xsqcup,
-        xuplus,
-        xutri,
-        xvee,
-        xwedge,
-        Yacute,
-        yacute,
-        YAcy,
-        yacy,
-        Ycirc,
-        ycirc,
-        Ycy,
-        ycy,
-        yen,
-        Yfr,
-        yfr,
-        YIcy,
-        yicy,
-        Yopf,
-        yopf,
-        Yscr,
-        yscr,
-        YUcy,
-        yucy,
-        yuml,
-        Yuml,
-        Zacute,
-        zacute,
-        Zcaron,
-        zcaron,
-        Zcy,
-        zcy,
-        Zdot,
-        zdot,
-        zeetrf,
-        ZeroWidthSpace,
-        Zeta,
-        zeta,
-        zfr,
-        Zfr,
-        ZHcy,
-        zhcy,
-        zigrarr,
-        zopf,
-        Zopf,
-        Zscr,
-        zscr,
-        zwj,
-        zwnj,
-      };
-      var entities$1 = require$$0;
-      var regex$4 =
-        /[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061E\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166D\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4E\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDF55-\uDF59]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDF3C-\uDF3E]|\uD806[\uDC3B\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8]|\uD809[\uDC70-\uDC74]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]/;
-      var mdurl$1 = {};
-      var encodeCache = {};
-      function getEncodeCache(exclude) {
-        var i,
-          ch2,
-          cache = encodeCache[exclude];
-        if (cache) {
-          return cache;
-        }
-        cache = encodeCache[exclude] = [];
-        for (i = 0; i < 128; i++) {
-          ch2 = String.fromCharCode(i);
-          if (/^[0-9a-z]$/i.test(ch2)) {
-            cache.push(ch2);
-          } else {
-            cache.push("%" + ("0" + i.toString(16).toUpperCase()).slice(-2));
-          }
-        }
-        for (i = 0; i < exclude.length; i++) {
-          cache[exclude.charCodeAt(i)] = exclude[i];
-        }
-        return cache;
-      }
-      function encode$1(string2, exclude, keepEscaped) {
-        var i,
-          l2,
-          code3,
-          nextCode,
-          cache,
-          result2 = "";
-        if (typeof exclude !== "string") {
-          keepEscaped = exclude;
-          exclude = encode$1.defaultChars;
-        }
-        if (typeof keepEscaped === "undefined") {
-          keepEscaped = true;
-        }
-        cache = getEncodeCache(exclude);
-        for (i = 0, l2 = string2.length; i < l2; i++) {
-          code3 = string2.charCodeAt(i);
-          if (keepEscaped && code3 === 37 && i + 2 < l2) {
-            if (/^[0-9a-f]{2}$/i.test(string2.slice(i + 1, i + 3))) {
-              result2 += string2.slice(i, i + 3);
-              i += 2;
-              continue;
-            }
-          }
-          if (code3 < 128) {
-            result2 += cache[code3];
-            continue;
-          }
-          if (code3 >= 55296 && code3 <= 57343) {
-            if (code3 >= 55296 && code3 <= 56319 && i + 1 < l2) {
-              nextCode = string2.charCodeAt(i + 1);
-              if (nextCode >= 56320 && nextCode <= 57343) {
-                result2 += encodeURIComponent(string2[i] + string2[i + 1]);
-                i++;
-                continue;
-              }
-            }
-            result2 += "%EF%BF%BD";
-            continue;
-          }
-          result2 += encodeURIComponent(string2[i]);
-        }
-        return result2;
-      }
-      encode$1.defaultChars = ";/?:@&=+$,-_.!~*'()#";
-      encode$1.componentChars = "-_.!~*'()";
-      var encode_1 = encode$1;
-      var decodeCache = {};
-      function getDecodeCache(exclude) {
-        var i,
-          ch2,
-          cache = decodeCache[exclude];
-        if (cache) {
-          return cache;
-        }
-        cache = decodeCache[exclude] = [];
-        for (i = 0; i < 128; i++) {
-          ch2 = String.fromCharCode(i);
-          cache.push(ch2);
-        }
-        for (i = 0; i < exclude.length; i++) {
-          ch2 = exclude.charCodeAt(i);
-          cache[ch2] = "%" + ("0" + ch2.toString(16).toUpperCase()).slice(-2);
-        }
-        return cache;
-      }
-      function decode$1(string2, exclude) {
-        var cache;
-        if (typeof exclude !== "string") {
-          exclude = decode$1.defaultChars;
-        }
-        cache = getDecodeCache(exclude);
-        return string2.replace(/(%[a-f0-9]{2})+/gi, function (seq) {
-          var i,
-            l2,
-            b1,
-            b2,
-            b3,
-            b4,
-            chr,
-            result2 = "";
-          for (i = 0, l2 = seq.length; i < l2; i += 3) {
-            b1 = parseInt(seq.slice(i + 1, i + 3), 16);
-            if (b1 < 128) {
-              result2 += cache[b1];
-              continue;
-            }
-            if ((b1 & 224) === 192 && i + 3 < l2) {
-              b2 = parseInt(seq.slice(i + 4, i + 6), 16);
-              if ((b2 & 192) === 128) {
-                chr = ((b1 << 6) & 1984) | (b2 & 63);
-                if (chr < 128) {
-                  result2 += "\uFFFD\uFFFD";
-                } else {
-                  result2 += String.fromCharCode(chr);
-                }
-                i += 3;
-                continue;
-              }
-            }
-            if ((b1 & 240) === 224 && i + 6 < l2) {
-              b2 = parseInt(seq.slice(i + 4, i + 6), 16);
-              b3 = parseInt(seq.slice(i + 7, i + 9), 16);
-              if ((b2 & 192) === 128 && (b3 & 192) === 128) {
-                chr = ((b1 << 12) & 61440) | ((b2 << 6) & 4032) | (b3 & 63);
-                if (chr < 2048 || (chr >= 55296 && chr <= 57343)) {
-                  result2 += "\uFFFD\uFFFD\uFFFD";
-                } else {
-                  result2 += String.fromCharCode(chr);
-                }
-                i += 6;
-                continue;
-              }
-            }
-            if ((b1 & 248) === 240 && i + 9 < l2) {
-              b2 = parseInt(seq.slice(i + 4, i + 6), 16);
-              b3 = parseInt(seq.slice(i + 7, i + 9), 16);
-              b4 = parseInt(seq.slice(i + 10, i + 12), 16);
-              if (
-                (b2 & 192) === 128 &&
-                (b3 & 192) === 128 &&
-                (b4 & 192) === 128
-              ) {
-                chr =
-                  ((b1 << 18) & 1835008) |
-                  ((b2 << 12) & 258048) |
-                  ((b3 << 6) & 4032) |
-                  (b4 & 63);
-                if (chr < 65536 || chr > 1114111) {
-                  result2 += "\uFFFD\uFFFD\uFFFD\uFFFD";
-                } else {
-                  chr -= 65536;
-                  result2 += String.fromCharCode(
-                    55296 + (chr >> 10),
-                    56320 + (chr & 1023)
-                  );
-                }
-                i += 9;
-                continue;
-              }
-            }
-            result2 += "\uFFFD";
-          }
-          return result2;
-        });
-      }
-      decode$1.defaultChars = ";/?:@&=+$,#";
-      decode$1.componentChars = "";
-      var decode_1 = decode$1;
-      var format = function format2(url) {
-        var result2 = "";
-        result2 += url.protocol || "";
-        result2 += url.slashes ? "//" : "";
-        result2 += url.auth ? url.auth + "@" : "";
-        if (url.hostname && url.hostname.indexOf(":") !== -1) {
-          result2 += "[" + url.hostname + "]";
-        } else {
-          result2 += url.hostname || "";
-        }
-        result2 += url.port ? ":" + url.port : "";
-        result2 += url.pathname || "";
-        result2 += url.search || "";
-        result2 += url.hash || "";
-        return result2;
-      };
-      function Url() {
-        this.protocol = null;
-        this.slashes = null;
-        this.auth = null;
-        this.port = null;
-        this.hostname = null;
-        this.hash = null;
-        this.search = null;
-        this.pathname = null;
-      }
-      var protocolPattern = /^([a-z0-9.+-]+:)/i,
-        portPattern = /:[0-9]*$/,
-        simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/,
-        delims = ["<", ">", '"', "`", " ", "\r", "\n", "	"],
-        unwise = ["{", "}", "|", "\\", "^", "`"].concat(delims),
-        autoEscape = ["'"].concat(unwise),
-        nonHostChars = ["%", "/", "?", ";", "#"].concat(autoEscape),
-        hostEndingChars = ["/", "?", "#"],
-        hostnameMaxLen = 255,
-        hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/,
-        hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/,
-        hostlessProtocol = {
-          javascript: true,
-          "javascript:": true,
-        },
-        slashedProtocol = {
-          http: true,
-          https: true,
-          ftp: true,
-          gopher: true,
-          file: true,
-          "http:": true,
-          "https:": true,
-          "ftp:": true,
-          "gopher:": true,
-          "file:": true,
-        };
-      function urlParse(url, slashesDenoteHost) {
-        if (url && url instanceof Url) {
-          return url;
-        }
-        var u2 = new Url();
-        u2.parse(url, slashesDenoteHost);
-        return u2;
-      }
-      Url.prototype.parse = function (url, slashesDenoteHost) {
-        var i,
-          l2,
-          lowerProto,
-          hec,
-          slashes,
-          rest = url;
-        rest = rest.trim();
-        if (!slashesDenoteHost && url.split("#").length === 1) {
-          var simplePath = simplePathPattern.exec(rest);
-          if (simplePath) {
-            this.pathname = simplePath[1];
-            if (simplePath[2]) {
-              this.search = simplePath[2];
-            }
-            return this;
-          }
-        }
-        var proto = protocolPattern.exec(rest);
-        if (proto) {
-          proto = proto[0];
-          lowerProto = proto.toLowerCase();
-          this.protocol = proto;
-          rest = rest.substr(proto.length);
-        }
-        if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
-          slashes = rest.substr(0, 2) === "//";
-          if (slashes && !(proto && hostlessProtocol[proto])) {
-            rest = rest.substr(2);
-            this.slashes = true;
-          }
-        }
-        if (
-          !hostlessProtocol[proto] &&
-          (slashes || (proto && !slashedProtocol[proto]))
-        ) {
-          var hostEnd = -1;
-          for (i = 0; i < hostEndingChars.length; i++) {
-            hec = rest.indexOf(hostEndingChars[i]);
-            if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
-              hostEnd = hec;
-            }
-          }
-          var auth, atSign;
-          if (hostEnd === -1) {
-            atSign = rest.lastIndexOf("@");
-          } else {
-            atSign = rest.lastIndexOf("@", hostEnd);
-          }
-          if (atSign !== -1) {
-            auth = rest.slice(0, atSign);
-            rest = rest.slice(atSign + 1);
-            this.auth = auth;
-          }
-          hostEnd = -1;
-          for (i = 0; i < nonHostChars.length; i++) {
-            hec = rest.indexOf(nonHostChars[i]);
-            if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
-              hostEnd = hec;
-            }
-          }
-          if (hostEnd === -1) {
-            hostEnd = rest.length;
-          }
-          if (rest[hostEnd - 1] === ":") {
-            hostEnd--;
-          }
-          var host = rest.slice(0, hostEnd);
-          rest = rest.slice(hostEnd);
-          this.parseHost(host);
-          this.hostname = this.hostname || "";
-          var ipv6Hostname =
-            this.hostname[0] === "[" &&
-            this.hostname[this.hostname.length - 1] === "]";
-          if (!ipv6Hostname) {
-            var hostparts = this.hostname.split(/\./);
-            for (i = 0, l2 = hostparts.length; i < l2; i++) {
-              var part2 = hostparts[i];
-              if (!part2) {
-                continue;
-              }
-              if (!part2.match(hostnamePartPattern)) {
-                var newpart = "";
-                for (var j = 0, k = part2.length; j < k; j++) {
-                  if (part2.charCodeAt(j) > 127) {
-                    newpart += "x";
-                  } else {
-                    newpart += part2[j];
-                  }
-                }
-                if (!newpart.match(hostnamePartPattern)) {
-                  var validParts = hostparts.slice(0, i);
-                  var notHost = hostparts.slice(i + 1);
-                  var bit = part2.match(hostnamePartStart);
-                  if (bit) {
-                    validParts.push(bit[1]);
-                    notHost.unshift(bit[2]);
-                  }
-                  if (notHost.length) {
-                    rest = notHost.join(".") + rest;
-                  }
-                  this.hostname = validParts.join(".");
-                  break;
-                }
-              }
-            }
-          }
-          if (this.hostname.length > hostnameMaxLen) {
-            this.hostname = "";
-          }
-          if (ipv6Hostname) {
-            this.hostname = this.hostname.substr(1, this.hostname.length - 2);
-          }
-        }
-        var hash = rest.indexOf("#");
-        if (hash !== -1) {
-          this.hash = rest.substr(hash);
-          rest = rest.slice(0, hash);
-        }
-        var qm = rest.indexOf("?");
-        if (qm !== -1) {
-          this.search = rest.substr(qm);
-          rest = rest.slice(0, qm);
-        }
-        if (rest) {
-          this.pathname = rest;
-        }
-        if (slashedProtocol[lowerProto] && this.hostname && !this.pathname) {
-          this.pathname = "";
-        }
-        return this;
-      };
-      Url.prototype.parseHost = function (host) {
-        var port = portPattern.exec(host);
-        if (port) {
-          port = port[0];
-          if (port !== ":") {
-            this.port = port.substr(1);
-          }
-          host = host.substr(0, host.length - port.length);
-        }
-        if (host) {
-          this.hostname = host;
-        }
-      };
-      var parse = urlParse;
-      mdurl$1.encode = encode_1;
-      mdurl$1.decode = decode_1;
-      mdurl$1.format = format;
-      mdurl$1.parse = parse;
-      var uc_micro = {};
-      var regex$3 =
-        /[\0-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
-      var regex$2 = /[\0-\x1F\x7F-\x9F]/;
-      var regex$1 =
-        /[\xAD\u0600-\u0605\u061C\u06DD\u070F\u08E2\u180E\u200B-\u200F\u202A-\u202E\u2060-\u2064\u2066-\u206F\uFEFF\uFFF9-\uFFFB]|\uD804[\uDCBD\uDCCD]|\uD82F[\uDCA0-\uDCA3]|\uD834[\uDD73-\uDD7A]|\uDB40[\uDC01\uDC20-\uDC7F]/;
-      var regex = /[ \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/;
-      uc_micro.Any = regex$3;
-      uc_micro.Cc = regex$2;
-      uc_micro.Cf = regex$1;
-      uc_micro.P = regex$4;
-      uc_micro.Z = regex;
-      (function (exports) {
-        function _class2(obj) {
-          return Object.prototype.toString.call(obj);
-        }
-        function isString2(obj) {
-          return _class2(obj) === "[object String]";
-        }
-        var _hasOwnProperty = Object.prototype.hasOwnProperty;
-        function has2(object, key) {
-          return _hasOwnProperty.call(object, key);
-        }
-        function assign2(obj) {
-          var sources = Array.prototype.slice.call(arguments, 1);
-          sources.forEach(function (source) {
-            if (!source) {
-              return;
-            }
-            if (typeof source !== "object") {
-              throw new TypeError(source + "must be object");
-            }
-            Object.keys(source).forEach(function (key) {
-              obj[key] = source[key];
-            });
-          });
-          return obj;
-        }
-        function arrayReplaceAt2(src, pos, newElements) {
-          return [].concat(src.slice(0, pos), newElements, src.slice(pos + 1));
-        }
-        function isValidEntityCode2(c) {
-          if (c >= 55296 && c <= 57343) {
-            return false;
-          }
-          if (c >= 64976 && c <= 65007) {
-            return false;
-          }
-          if ((c & 65535) === 65535 || (c & 65535) === 65534) {
-            return false;
-          }
-          if (c >= 0 && c <= 8) {
-            return false;
-          }
-          if (c === 11) {
-            return false;
-          }
-          if (c >= 14 && c <= 31) {
-            return false;
-          }
-          if (c >= 127 && c <= 159) {
-            return false;
-          }
-          if (c > 1114111) {
-            return false;
-          }
-          return true;
-        }
-        function fromCodePoint2(c) {
-          if (c > 65535) {
-            c -= 65536;
-            var surrogate1 = 55296 + (c >> 10),
-              surrogate2 = 56320 + (c & 1023);
-            return String.fromCharCode(surrogate1, surrogate2);
-          }
-          return String.fromCharCode(c);
-        }
-        var UNESCAPE_MD_RE = /\\([!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~])/g;
-        var ENTITY_RE = /&([a-z#][a-z0-9]{1,31});/gi;
-        var UNESCAPE_ALL_RE = new RegExp(
-          UNESCAPE_MD_RE.source + "|" + ENTITY_RE.source,
-          "gi"
-        );
-        var DIGITAL_ENTITY_TEST_RE = /^#((?:x[a-f0-9]{1,8}|[0-9]{1,8}))/i;
-        var entities2 = entities$1;
-        function replaceEntityPattern(match2, name2) {
-          var code3 = 0;
-          if (has2(entities2, name2)) {
-            return entities2[name2];
-          }
-          if (
-            name2.charCodeAt(0) === 35 &&
-            DIGITAL_ENTITY_TEST_RE.test(name2)
-          ) {
-            code3 =
-              name2[1].toLowerCase() === "x"
-                ? parseInt(name2.slice(2), 16)
-                : parseInt(name2.slice(1), 10);
-            if (isValidEntityCode2(code3)) {
-              return fromCodePoint2(code3);
-            }
-          }
-          return match2;
-        }
-        function unescapeMd(str) {
-          if (str.indexOf("\\") < 0) {
-            return str;
-          }
-          return str.replace(UNESCAPE_MD_RE, "$1");
-        }
-        function unescapeAll2(str) {
-          if (str.indexOf("\\") < 0 && str.indexOf("&") < 0) {
-            return str;
-          }
-          return str.replace(
-            UNESCAPE_ALL_RE,
-            function (match2, escaped, entity3) {
-              if (escaped) {
-                return escaped;
-              }
-              return replaceEntityPattern(match2, entity3);
-            }
-          );
-        }
-        var HTML_ESCAPE_TEST_RE = /[&<>"]/;
-        var HTML_ESCAPE_REPLACE_RE = /[&<>"]/g;
-        var HTML_REPLACEMENTS = {
-          "&": "&amp;",
-          "<": "&lt;",
-          ">": "&gt;",
-          '"': "&quot;",
-        };
-        function replaceUnsafeChar(ch2) {
-          return HTML_REPLACEMENTS[ch2];
-        }
-        function escapeHtml2(str) {
-          if (HTML_ESCAPE_TEST_RE.test(str)) {
-            return str.replace(HTML_ESCAPE_REPLACE_RE, replaceUnsafeChar);
-          }
-          return str;
-        }
-        var REGEXP_ESCAPE_RE = /[.?*+^$[\]\\(){}|-]/g;
-        function escapeRE2(str) {
-          return str.replace(REGEXP_ESCAPE_RE, "\\$&");
-        }
-        function isSpace2(code3) {
-          switch (code3) {
-            case 9:
-            case 32:
-              return true;
-          }
-          return false;
-        }
-        function isWhiteSpace2(code3) {
-          if (code3 >= 8192 && code3 <= 8202) {
-            return true;
-          }
-          switch (code3) {
-            case 9:
-            case 10:
-            case 11:
-            case 12:
-            case 13:
-            case 32:
-            case 160:
-            case 5760:
-            case 8239:
-            case 8287:
-            case 12288:
-              return true;
-          }
-          return false;
-        }
-        var UNICODE_PUNCT_RE = regex$4;
-        function isPunctChar2(ch2) {
-          return UNICODE_PUNCT_RE.test(ch2);
-        }
-        function isMdAsciiPunct2(ch2) {
-          switch (ch2) {
-            case 33:
-            case 34:
-            case 35:
-            case 36:
-            case 37:
-            case 38:
-            case 39:
-            case 40:
-            case 41:
-            case 42:
-            case 43:
-            case 44:
-            case 45:
-            case 46:
-            case 47:
-            case 58:
-            case 59:
-            case 60:
-            case 61:
-            case 62:
-            case 63:
-            case 64:
-            case 91:
-            case 92:
-            case 93:
-            case 94:
-            case 95:
-            case 96:
-            case 123:
-            case 124:
-            case 125:
-            case 126:
-              return true;
-            default:
-              return false;
-          }
-        }
-        function normalizeReference2(str) {
-          str = str.trim().replace(/\s+/g, " ");
-          if ("\u1E9E".toLowerCase() === "\u1E7E") {
-            str = str.replace(/ẞ/g, "\xDF");
-          }
-          return str.toLowerCase().toUpperCase();
-        }
-        exports.lib = {};
-        exports.lib.mdurl = mdurl$1;
-        exports.lib.ucmicro = uc_micro;
-        exports.assign = assign2;
-        exports.isString = isString2;
-        exports.has = has2;
-        exports.unescapeMd = unescapeMd;
-        exports.unescapeAll = unescapeAll2;
-        exports.isValidEntityCode = isValidEntityCode2;
-        exports.fromCodePoint = fromCodePoint2;
-        exports.escapeHtml = escapeHtml2;
-        exports.arrayReplaceAt = arrayReplaceAt2;
-        exports.isSpace = isSpace2;
-        exports.isWhiteSpace = isWhiteSpace2;
-        exports.isMdAsciiPunct = isMdAsciiPunct2;
-        exports.isPunctChar = isPunctChar2;
-        exports.escapeRE = escapeRE2;
-        exports.normalizeReference = normalizeReference2;
-      })(utils$1);
-      var helpers$1 = {};
-      var parse_link_label = function parseLinkLabel(
-        state,
-        start2,
-        disableNested
-      ) {
-        var level,
-          found,
-          marker2,
-          prevPos,
-          labelEnd = -1,
-          max = state.posMax,
-          oldPos = state.pos;
-        state.pos = start2 + 1;
-        level = 1;
-        while (state.pos < max) {
-          marker2 = state.src.charCodeAt(state.pos);
-          if (marker2 === 93) {
-            level--;
-            if (level === 0) {
-              found = true;
-              break;
-            }
-          }
-          prevPos = state.pos;
-          state.md.inline.skipToken(state);
-          if (marker2 === 91) {
-            if (prevPos === state.pos - 1) {
-              level++;
-            } else if (disableNested) {
-              state.pos = oldPos;
-              return -1;
-            }
-          }
-        }
-        if (found) {
-          labelEnd = state.pos;
-        }
-        state.pos = oldPos;
-        return labelEnd;
-      };
-      var unescapeAll$2 = utils$1.unescapeAll;
-      var parse_link_destination = function parseLinkDestination(
-        str,
-        pos,
-        max
-      ) {
-        var code3,
-          level,
-          lines = 0,
-          start2 = pos,
-          result2 = {
-            ok: false,
-            pos: 0,
-            lines: 0,
-            str: "",
-          };
-        if (str.charCodeAt(pos) === 60) {
-          pos++;
-          while (pos < max) {
-            code3 = str.charCodeAt(pos);
-            if (code3 === 10) {
-              return result2;
-            }
-            if (code3 === 60) {
-              return result2;
-            }
-            if (code3 === 62) {
-              result2.pos = pos + 1;
-              result2.str = unescapeAll$2(str.slice(start2 + 1, pos));
-              result2.ok = true;
-              return result2;
-            }
-            if (code3 === 92 && pos + 1 < max) {
-              pos += 2;
-              continue;
-            }
-            pos++;
-          }
-          return result2;
-        }
-        level = 0;
-        while (pos < max) {
-          code3 = str.charCodeAt(pos);
-          if (code3 === 32) {
-            break;
-          }
-          if (code3 < 32 || code3 === 127) {
-            break;
-          }
-          if (code3 === 92 && pos + 1 < max) {
-            if (str.charCodeAt(pos + 1) === 32) {
-              break;
-            }
-            pos += 2;
-            continue;
-          }
-          if (code3 === 40) {
-            level++;
-            if (level > 32) {
-              return result2;
-            }
-          }
-          if (code3 === 41) {
-            if (level === 0) {
-              break;
-            }
-            level--;
-          }
-          pos++;
-        }
-        if (start2 === pos) {
-          return result2;
-        }
-        if (level !== 0) {
-          return result2;
-        }
-        result2.str = unescapeAll$2(str.slice(start2, pos));
-        result2.lines = lines;
-        result2.pos = pos;
-        result2.ok = true;
-        return result2;
-      };
-      var unescapeAll$1 = utils$1.unescapeAll;
-      var parse_link_title = function parseLinkTitle(str, pos, max) {
-        var code3,
-          marker2,
-          lines = 0,
-          start2 = pos,
-          result2 = {
-            ok: false,
-            pos: 0,
-            lines: 0,
-            str: "",
-          };
-        if (pos >= max) {
-          return result2;
-        }
-        marker2 = str.charCodeAt(pos);
-        if (marker2 !== 34 && marker2 !== 39 && marker2 !== 40) {
-          return result2;
-        }
-        pos++;
-        if (marker2 === 40) {
-          marker2 = 41;
-        }
-        while (pos < max) {
-          code3 = str.charCodeAt(pos);
-          if (code3 === marker2) {
-            result2.pos = pos + 1;
-            result2.lines = lines;
-            result2.str = unescapeAll$1(str.slice(start2 + 1, pos));
-            result2.ok = true;
-            return result2;
-          } else if (code3 === 40 && marker2 === 41) {
-            return result2;
-          } else if (code3 === 10) {
-            lines++;
-          } else if (code3 === 92 && pos + 1 < max) {
-            pos++;
-            if (str.charCodeAt(pos) === 10) {
-              lines++;
-            }
-          }
-          pos++;
-        }
-        return result2;
-      };
-      helpers$1.parseLinkLabel = parse_link_label;
-      helpers$1.parseLinkDestination = parse_link_destination;
-      helpers$1.parseLinkTitle = parse_link_title;
-      var assign$1 = utils$1.assign;
-      var unescapeAll = utils$1.unescapeAll;
-      var escapeHtml$1 = utils$1.escapeHtml;
-      var default_rules = {};
-      default_rules.code_inline = function (tokens, idx, options, env, slf) {
-        var token2 = tokens[idx];
-        return (
-          "<code" +
-          slf.renderAttrs(token2) +
-          ">" +
-          escapeHtml$1(tokens[idx].content) +
-          "</code>"
-        );
-      };
-      default_rules.code_block = function (tokens, idx, options, env, slf) {
-        var token2 = tokens[idx];
-        return (
-          "<pre" +
-          slf.renderAttrs(token2) +
-          "><code>" +
-          escapeHtml$1(tokens[idx].content) +
-          "</code></pre>\n"
-        );
-      };
-      default_rules.fence = function (tokens, idx, options, env, slf) {
-        var token2 = tokens[idx],
-          info2 = token2.info ? unescapeAll(token2.info).trim() : "",
-          langName = "",
-          langAttrs = "",
-          highlighted,
-          i,
-          arr,
-          tmpAttrs,
-          tmpToken;
-        if (info2) {
-          arr = info2.split(/(\s+)/g);
-          langName = arr[0];
-          langAttrs = arr.slice(2).join("");
-        }
-        if (options.highlight) {
-          highlighted =
-            options.highlight(token2.content, langName, langAttrs) ||
-            escapeHtml$1(token2.content);
-        } else {
-          highlighted = escapeHtml$1(token2.content);
-        }
-        if (highlighted.indexOf("<pre") === 0) {
-          return highlighted + "\n";
-        }
-        if (info2) {
-          i = token2.attrIndex("class");
-          tmpAttrs = token2.attrs ? token2.attrs.slice() : [];
-          if (i < 0) {
-            tmpAttrs.push(["class", options.langPrefix + langName]);
-          } else {
-            tmpAttrs[i] = tmpAttrs[i].slice();
-            tmpAttrs[i][1] += " " + options.langPrefix + langName;
-          }
-          tmpToken = {
-            attrs: tmpAttrs,
-          };
-          return (
-            "<pre><code" +
-            slf.renderAttrs(tmpToken) +
-            ">" +
-            highlighted +
-            "</code></pre>\n"
-          );
-        }
-        return (
-          "<pre><code" +
-          slf.renderAttrs(token2) +
-          ">" +
-          highlighted +
-          "</code></pre>\n"
-        );
-      };
-      default_rules.image = function (tokens, idx, options, env, slf) {
-        var token2 = tokens[idx];
-        token2.attrs[token2.attrIndex("alt")][1] = slf.renderInlineAsText(
-          token2.children,
-          options,
-          env
-        );
-        return slf.renderToken(tokens, idx, options);
-      };
-      default_rules.hardbreak = function (tokens, idx, options) {
-        return options.xhtmlOut ? "<br />\n" : "<br>\n";
-      };
-      default_rules.softbreak = function (tokens, idx, options) {
-        return options.breaks
-          ? options.xhtmlOut
-            ? "<br />\n"
-            : "<br>\n"
-          : "\n";
-      };
-      default_rules.text = function (tokens, idx) {
-        return escapeHtml$1(tokens[idx].content);
-      };
-      default_rules.html_block = function (tokens, idx) {
-        return tokens[idx].content;
-      };
-      default_rules.html_inline = function (tokens, idx) {
-        return tokens[idx].content;
-      };
-      function Renderer$1() {
-        this.rules = assign$1({}, default_rules);
-      }
-      Renderer$1.prototype.renderAttrs = function renderAttrs(token2) {
-        var i, l2, result2;
-        if (!token2.attrs) {
-          return "";
-        }
-        result2 = "";
-        for (i = 0, l2 = token2.attrs.length; i < l2; i++) {
-          result2 +=
-            " " +
-            escapeHtml$1(token2.attrs[i][0]) +
-            '="' +
-            escapeHtml$1(token2.attrs[i][1]) +
-            '"';
-        }
-        return result2;
-      };
-      Renderer$1.prototype.renderToken = function renderToken(
-        tokens,
-        idx,
-        options
-      ) {
-        var nextToken,
-          result2 = "",
-          needLf = false,
-          token2 = tokens[idx];
-        if (token2.hidden) {
-          return "";
-        }
-        if (
-          token2.block &&
-          token2.nesting !== -1 &&
-          idx &&
-          tokens[idx - 1].hidden
-        ) {
-          result2 += "\n";
-        }
-        result2 += (token2.nesting === -1 ? "</" : "<") + token2.tag;
-        result2 += this.renderAttrs(token2);
-        if (token2.nesting === 0 && options.xhtmlOut) {
-          result2 += " /";
-        }
-        if (token2.block) {
-          needLf = true;
-          if (token2.nesting === 1) {
-            if (idx + 1 < tokens.length) {
-              nextToken = tokens[idx + 1];
-              if (nextToken.type === "inline" || nextToken.hidden) {
-                needLf = false;
-              } else if (
-                nextToken.nesting === -1 &&
-                nextToken.tag === token2.tag
-              ) {
-                needLf = false;
-              }
-            }
-          }
-        }
-        result2 += needLf ? ">\n" : ">";
-        return result2;
-      };
-      Renderer$1.prototype.renderInline = function (tokens, options, env) {
-        var type2,
-          result2 = "",
-          rules = this.rules;
-        for (var i = 0, len = tokens.length; i < len; i++) {
-          type2 = tokens[i].type;
-          if (typeof rules[type2] !== "undefined") {
-            result2 += rules[type2](tokens, i, options, env, this);
-          } else {
-            result2 += this.renderToken(tokens, i, options);
-          }
-        }
-        return result2;
-      };
-      Renderer$1.prototype.renderInlineAsText = function (
-        tokens,
-        options,
-        env
-      ) {
-        var result2 = "";
-        for (var i = 0, len = tokens.length; i < len; i++) {
-          if (tokens[i].type === "text") {
-            result2 += tokens[i].content;
-          } else if (tokens[i].type === "image") {
-            result2 += this.renderInlineAsText(
-              tokens[i].children,
-              options,
-              env
-            );
-          } else if (tokens[i].type === "softbreak") {
-            result2 += "\n";
-          }
-        }
-        return result2;
-      };
-      Renderer$1.prototype.render = function (tokens, options, env) {
-        var i,
-          len,
-          type2,
-          result2 = "",
-          rules = this.rules;
-        for (i = 0, len = tokens.length; i < len; i++) {
-          type2 = tokens[i].type;
-          if (type2 === "inline") {
-            result2 += this.renderInline(tokens[i].children, options, env);
-          } else if (typeof rules[type2] !== "undefined") {
-            result2 += rules[tokens[i].type](tokens, i, options, env, this);
-          } else {
-            result2 += this.renderToken(tokens, i, options, env);
-          }
-        }
-        return result2;
-      };
-      var renderer = Renderer$1;
-      function Ruler$3() {
-        this.__rules__ = [];
-        this.__cache__ = null;
-      }
-      Ruler$3.prototype.__find__ = function (name2) {
-        for (var i = 0; i < this.__rules__.length; i++) {
-          if (this.__rules__[i].name === name2) {
-            return i;
-          }
-        }
-        return -1;
-      };
-      Ruler$3.prototype.__compile__ = function () {
-        var self2 = this;
-        var chains = [""];
-        self2.__rules__.forEach(function (rule) {
-          if (!rule.enabled) {
-            return;
-          }
-          rule.alt.forEach(function (altName) {
-            if (chains.indexOf(altName) < 0) {
-              chains.push(altName);
-            }
-          });
-        });
-        self2.__cache__ = {};
-        chains.forEach(function (chain) {
-          self2.__cache__[chain] = [];
-          self2.__rules__.forEach(function (rule) {
-            if (!rule.enabled) {
-              return;
-            }
-            if (chain && rule.alt.indexOf(chain) < 0) {
-              return;
-            }
-            self2.__cache__[chain].push(rule.fn);
-          });
-        });
-      };
-      Ruler$3.prototype.at = function (name2, fn, options) {
-        var index = this.__find__(name2);
-        var opt2 = options || {};
-        if (index === -1) {
-          throw new Error("Parser rule not found: " + name2);
-        }
-        this.__rules__[index].fn = fn;
-        this.__rules__[index].alt = opt2.alt || [];
-        this.__cache__ = null;
-      };
-      Ruler$3.prototype.before = function (beforeName, ruleName, fn, options) {
-        var index = this.__find__(beforeName);
-        var opt2 = options || {};
-        if (index === -1) {
-          throw new Error("Parser rule not found: " + beforeName);
-        }
-        this.__rules__.splice(index, 0, {
-          name: ruleName,
-          enabled: true,
-          fn,
-          alt: opt2.alt || [],
-        });
-        this.__cache__ = null;
-      };
-      Ruler$3.prototype.after = function (afterName, ruleName, fn, options) {
-        var index = this.__find__(afterName);
-        var opt2 = options || {};
-        if (index === -1) {
-          throw new Error("Parser rule not found: " + afterName);
-        }
-        this.__rules__.splice(index + 1, 0, {
-          name: ruleName,
-          enabled: true,
-          fn,
-          alt: opt2.alt || [],
-        });
-        this.__cache__ = null;
-      };
-      Ruler$3.prototype.push = function (ruleName, fn, options) {
-        var opt2 = options || {};
-        this.__rules__.push({
-          name: ruleName,
-          enabled: true,
-          fn,
-          alt: opt2.alt || [],
-        });
-        this.__cache__ = null;
-      };
-      Ruler$3.prototype.enable = function (list3, ignoreInvalid) {
-        if (!Array.isArray(list3)) {
-          list3 = [list3];
-        }
-        var result2 = [];
-        list3.forEach(function (name2) {
-          var idx = this.__find__(name2);
-          if (idx < 0) {
-            if (ignoreInvalid) {
-              return;
-            }
-            throw new Error("Rules manager: invalid rule name " + name2);
-          }
-          this.__rules__[idx].enabled = true;
-          result2.push(name2);
-        }, this);
-        this.__cache__ = null;
-        return result2;
-      };
-      Ruler$3.prototype.enableOnly = function (list3, ignoreInvalid) {
-        if (!Array.isArray(list3)) {
-          list3 = [list3];
-        }
-        this.__rules__.forEach(function (rule) {
-          rule.enabled = false;
-        });
-        this.enable(list3, ignoreInvalid);
-      };
-      Ruler$3.prototype.disable = function (list3, ignoreInvalid) {
-        if (!Array.isArray(list3)) {
-          list3 = [list3];
-        }
-        var result2 = [];
-        list3.forEach(function (name2) {
-          var idx = this.__find__(name2);
-          if (idx < 0) {
-            if (ignoreInvalid) {
-              return;
-            }
-            throw new Error("Rules manager: invalid rule name " + name2);
-          }
-          this.__rules__[idx].enabled = false;
-          result2.push(name2);
-        }, this);
-        this.__cache__ = null;
-        return result2;
-      };
-      Ruler$3.prototype.getRules = function (chainName) {
-        if (this.__cache__ === null) {
-          this.__compile__();
-        }
-        return this.__cache__[chainName] || [];
-      };
-      var ruler = Ruler$3;
-      var NEWLINES_RE = /\r\n?|\n/g;
-      var NULL_RE = /\0/g;
-      var normalize = function normalize2(state) {
-        var str;
-        str = state.src.replace(NEWLINES_RE, "\n");
-        str = str.replace(NULL_RE, "\uFFFD");
-        state.src = str;
-      };
-      var block$1 = function block(state) {
-        var token2;
-        if (state.inlineMode) {
-          token2 = new state.Token("inline", "", 0);
-          token2.content = state.src;
-          token2.map = [0, 1];
-          token2.children = [];
-          state.tokens.push(token2);
-        } else {
-          state.md.block.parse(state.src, state.md, state.env, state.tokens);
-        }
-      };
-      var inline = function inline2(state) {
-        var tokens = state.tokens,
-          tok,
-          i,
-          l2;
-        for (i = 0, l2 = tokens.length; i < l2; i++) {
-          tok = tokens[i];
-          if (tok.type === "inline") {
-            state.md.inline.parse(
-              tok.content,
-              state.md,
-              state.env,
-              tok.children
-            );
-          }
-        }
-      };
-      var arrayReplaceAt = utils$1.arrayReplaceAt;
-      function isLinkOpen(str) {
-        return /^<a[>\s]/i.test(str);
-      }
-      function isLinkClose(str) {
-        return /^<\/a\s*>/i.test(str);
-      }
-      var linkify = function linkify2(state) {
-        var i,
-          j,
-          l2,
-          tokens,
-          token2,
-          currentToken,
-          nodes,
-          ln,
-          text3,
-          pos,
-          lastPos,
-          level,
-          htmlLinkLevel,
-          url,
-          fullUrl,
-          urlText,
-          blockTokens = state.tokens,
-          links;
-        if (!state.md.options.linkify) {
-          return;
-        }
-        for (j = 0, l2 = blockTokens.length; j < l2; j++) {
-          if (
-            blockTokens[j].type !== "inline" ||
-            !state.md.linkify.pretest(blockTokens[j].content)
-          ) {
-            continue;
-          }
-          tokens = blockTokens[j].children;
-          htmlLinkLevel = 0;
-          for (i = tokens.length - 1; i >= 0; i--) {
-            currentToken = tokens[i];
-            if (currentToken.type === "link_close") {
-              i--;
-              while (
-                tokens[i].level !== currentToken.level &&
-                tokens[i].type !== "link_open"
-              ) {
-                i--;
-              }
-              continue;
-            }
-            if (currentToken.type === "html_inline") {
-              if (isLinkOpen(currentToken.content) && htmlLinkLevel > 0) {
-                htmlLinkLevel--;
-              }
-              if (isLinkClose(currentToken.content)) {
-                htmlLinkLevel++;
-              }
-            }
-            if (htmlLinkLevel > 0) {
-              continue;
-            }
-            if (
-              currentToken.type === "text" &&
-              state.md.linkify.test(currentToken.content)
-            ) {
-              text3 = currentToken.content;
-              links = state.md.linkify.match(text3);
-              nodes = [];
-              level = currentToken.level;
-              lastPos = 0;
-              for (ln = 0; ln < links.length; ln++) {
-                url = links[ln].url;
-                fullUrl = state.md.normalizeLink(url);
-                if (!state.md.validateLink(fullUrl)) {
-                  continue;
-                }
-                urlText = links[ln].text;
-                if (!links[ln].schema) {
-                  urlText = state.md
-                    .normalizeLinkText("http://" + urlText)
-                    .replace(/^http:\/\//, "");
-                } else if (
-                  links[ln].schema === "mailto:" &&
-                  !/^mailto:/i.test(urlText)
-                ) {
-                  urlText = state.md
-                    .normalizeLinkText("mailto:" + urlText)
-                    .replace(/^mailto:/, "");
-                } else {
-                  urlText = state.md.normalizeLinkText(urlText);
-                }
-                pos = links[ln].index;
-                if (pos > lastPos) {
-                  token2 = new state.Token("text", "", 0);
-                  token2.content = text3.slice(lastPos, pos);
-                  token2.level = level;
-                  nodes.push(token2);
-                }
-                token2 = new state.Token("link_open", "a", 1);
-                token2.attrs = [["href", fullUrl]];
-                token2.level = level++;
-                token2.markup = "linkify";
-                token2.info = "auto";
-                nodes.push(token2);
-                token2 = new state.Token("text", "", 0);
-                token2.content = urlText;
-                token2.level = level;
-                nodes.push(token2);
-                token2 = new state.Token("link_close", "a", -1);
-                token2.level = --level;
-                token2.markup = "linkify";
-                token2.info = "auto";
-                nodes.push(token2);
-                lastPos = links[ln].lastIndex;
-              }
-              if (lastPos < text3.length) {
-                token2 = new state.Token("text", "", 0);
-                token2.content = text3.slice(lastPos);
-                token2.level = level;
-                nodes.push(token2);
-              }
-              blockTokens[j].children = tokens = arrayReplaceAt(
-                tokens,
-                i,
-                nodes
-              );
-            }
-          }
-        }
-      };
-      var RARE_RE = /\+-|\.\.|\?\?\?\?|!!!!|,,|--/;
-      var SCOPED_ABBR_TEST_RE = /\((c|tm|r|p)\)/i;
-      var SCOPED_ABBR_RE = /\((c|tm|r|p)\)/gi;
-      var SCOPED_ABBR = {
-        c: "\xA9",
-        r: "\xAE",
-        p: "\xA7",
-        tm: "\u2122",
-      };
-      function replaceFn(match2, name2) {
-        return SCOPED_ABBR[name2.toLowerCase()];
-      }
-      function replace_scoped(inlineTokens) {
-        var i,
-          token2,
-          inside_autolink = 0;
-        for (i = inlineTokens.length - 1; i >= 0; i--) {
-          token2 = inlineTokens[i];
-          if (token2.type === "text" && !inside_autolink) {
-            token2.content = token2.content.replace(SCOPED_ABBR_RE, replaceFn);
-          }
-          if (token2.type === "link_open" && token2.info === "auto") {
-            inside_autolink--;
-          }
-          if (token2.type === "link_close" && token2.info === "auto") {
-            inside_autolink++;
-          }
-        }
-      }
-      function replace_rare(inlineTokens) {
-        var i,
-          token2,
-          inside_autolink = 0;
-        for (i = inlineTokens.length - 1; i >= 0; i--) {
-          token2 = inlineTokens[i];
-          if (token2.type === "text" && !inside_autolink) {
-            if (RARE_RE.test(token2.content)) {
-              token2.content = token2.content
-                .replace(/\+-/g, "\xB1")
-                .replace(/\.{2,}/g, "\u2026")
-                .replace(/([?!])…/g, "$1..")
-                .replace(/([?!]){4,}/g, "$1$1$1")
-                .replace(/,{2,}/g, ",")
-                .replace(/(^|[^-])---(?=[^-]|$)/gm, "$1\u2014")
-                .replace(/(^|\s)--(?=\s|$)/gm, "$1\u2013")
-                .replace(/(^|[^-\s])--(?=[^-\s]|$)/gm, "$1\u2013");
-            }
-          }
-          if (token2.type === "link_open" && token2.info === "auto") {
-            inside_autolink--;
-          }
-          if (token2.type === "link_close" && token2.info === "auto") {
-            inside_autolink++;
-          }
-        }
-      }
-      var replacements = function replace(state) {
-        var blkIdx;
-        if (!state.md.options.typographer) {
-          return;
-        }
-        for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
-          if (state.tokens[blkIdx].type !== "inline") {
-            continue;
-          }
-          if (SCOPED_ABBR_TEST_RE.test(state.tokens[blkIdx].content)) {
-            replace_scoped(state.tokens[blkIdx].children);
-          }
-          if (RARE_RE.test(state.tokens[blkIdx].content)) {
-            replace_rare(state.tokens[blkIdx].children);
-          }
-        }
-      };
-      var isWhiteSpace$1 = utils$1.isWhiteSpace;
-      var isPunctChar$1 = utils$1.isPunctChar;
-      var isMdAsciiPunct$1 = utils$1.isMdAsciiPunct;
-      var QUOTE_TEST_RE = /['"]/;
-      var QUOTE_RE = /['"]/g;
-      var APOSTROPHE = "\u2019";
-      function replaceAt(str, index, ch2) {
-        return str.substr(0, index) + ch2 + str.substr(index + 1);
-      }
-      function process_inlines(tokens, state) {
-        var i,
-          token2,
-          text3,
-          t2,
-          pos,
-          max,
-          thisLevel,
-          item,
-          lastChar,
-          nextChar,
-          isLastPunctChar,
-          isNextPunctChar,
-          isLastWhiteSpace,
-          isNextWhiteSpace,
-          canOpen,
-          canClose,
-          j,
-          isSingle,
-          stack,
-          openQuote,
-          closeQuote;
-        stack = [];
-        for (i = 0; i < tokens.length; i++) {
-          token2 = tokens[i];
-          thisLevel = tokens[i].level;
-          for (j = stack.length - 1; j >= 0; j--) {
-            if (stack[j].level <= thisLevel) {
-              break;
-            }
-          }
-          stack.length = j + 1;
-          if (token2.type !== "text") {
-            continue;
-          }
-          text3 = token2.content;
-          pos = 0;
-          max = text3.length;
-          OUTER: while (pos < max) {
-            QUOTE_RE.lastIndex = pos;
-            t2 = QUOTE_RE.exec(text3);
-            if (!t2) {
-              break;
-            }
-            canOpen = canClose = true;
-            pos = t2.index + 1;
-            isSingle = t2[0] === "'";
-            lastChar = 32;
-            if (t2.index - 1 >= 0) {
-              lastChar = text3.charCodeAt(t2.index - 1);
-            } else {
-              for (j = i - 1; j >= 0; j--) {
-                if (
-                  tokens[j].type === "softbreak" ||
-                  tokens[j].type === "hardbreak"
-                )
-                  break;
-                if (!tokens[j].content) continue;
-                lastChar = tokens[j].content.charCodeAt(
-                  tokens[j].content.length - 1
-                );
-                break;
-              }
-            }
-            nextChar = 32;
-            if (pos < max) {
-              nextChar = text3.charCodeAt(pos);
-            } else {
-              for (j = i + 1; j < tokens.length; j++) {
-                if (
-                  tokens[j].type === "softbreak" ||
-                  tokens[j].type === "hardbreak"
-                )
-                  break;
-                if (!tokens[j].content) continue;
-                nextChar = tokens[j].content.charCodeAt(0);
-                break;
-              }
-            }
-            isLastPunctChar =
-              isMdAsciiPunct$1(lastChar) ||
-              isPunctChar$1(String.fromCharCode(lastChar));
-            isNextPunctChar =
-              isMdAsciiPunct$1(nextChar) ||
-              isPunctChar$1(String.fromCharCode(nextChar));
-            isLastWhiteSpace = isWhiteSpace$1(lastChar);
-            isNextWhiteSpace = isWhiteSpace$1(nextChar);
-            if (isNextWhiteSpace) {
-              canOpen = false;
-            } else if (isNextPunctChar) {
-              if (!(isLastWhiteSpace || isLastPunctChar)) {
-                canOpen = false;
-              }
-            }
-            if (isLastWhiteSpace) {
-              canClose = false;
-            } else if (isLastPunctChar) {
-              if (!(isNextWhiteSpace || isNextPunctChar)) {
-                canClose = false;
-              }
-            }
-            if (nextChar === 34 && t2[0] === '"') {
-              if (lastChar >= 48 && lastChar <= 57) {
-                canClose = canOpen = false;
-              }
-            }
-            if (canOpen && canClose) {
-              canOpen = isLastPunctChar;
-              canClose = isNextPunctChar;
-            }
-            if (!canOpen && !canClose) {
-              if (isSingle) {
-                token2.content = replaceAt(
-                  token2.content,
-                  t2.index,
-                  APOSTROPHE
-                );
-              }
-              continue;
-            }
-            if (canClose) {
-              for (j = stack.length - 1; j >= 0; j--) {
-                item = stack[j];
-                if (stack[j].level < thisLevel) {
-                  break;
-                }
-                if (item.single === isSingle && stack[j].level === thisLevel) {
-                  item = stack[j];
-                  if (isSingle) {
-                    openQuote = state.md.options.quotes[2];
-                    closeQuote = state.md.options.quotes[3];
-                  } else {
-                    openQuote = state.md.options.quotes[0];
-                    closeQuote = state.md.options.quotes[1];
-                  }
-                  token2.content = replaceAt(
-                    token2.content,
-                    t2.index,
-                    closeQuote
-                  );
-                  tokens[item.token].content = replaceAt(
-                    tokens[item.token].content,
-                    item.pos,
-                    openQuote
-                  );
-                  pos += closeQuote.length - 1;
-                  if (item.token === i) {
-                    pos += openQuote.length - 1;
-                  }
-                  text3 = token2.content;
-                  max = text3.length;
-                  stack.length = j;
-                  continue OUTER;
-                }
-              }
-            }
-            if (canOpen) {
-              stack.push({
-                token: i,
-                pos: t2.index,
-                single: isSingle,
-                level: thisLevel,
-              });
-            } else if (canClose && isSingle) {
-              token2.content = replaceAt(token2.content, t2.index, APOSTROPHE);
-            }
-          }
-        }
-      }
-      var smartquotes = function smartquotes2(state) {
-        var blkIdx;
-        if (!state.md.options.typographer) {
-          return;
-        }
-        for (blkIdx = state.tokens.length - 1; blkIdx >= 0; blkIdx--) {
-          if (
-            state.tokens[blkIdx].type !== "inline" ||
-            !QUOTE_TEST_RE.test(state.tokens[blkIdx].content)
-          ) {
-            continue;
-          }
-          process_inlines(state.tokens[blkIdx].children, state);
-        }
-      };
-      function Token$3(type2, tag, nesting) {
-        this.type = type2;
-        this.tag = tag;
-        this.attrs = null;
-        this.map = null;
-        this.nesting = nesting;
-        this.level = 0;
-        this.children = null;
-        this.content = "";
-        this.markup = "";
-        this.info = "";
-        this.meta = null;
-        this.block = false;
-        this.hidden = false;
-      }
-      Token$3.prototype.attrIndex = function attrIndex(name2) {
-        var attrs, i, len;
-        if (!this.attrs) {
-          return -1;
-        }
-        attrs = this.attrs;
-        for (i = 0, len = attrs.length; i < len; i++) {
-          if (attrs[i][0] === name2) {
-            return i;
-          }
-        }
-        return -1;
-      };
-      Token$3.prototype.attrPush = function attrPush(attrData) {
-        if (this.attrs) {
-          this.attrs.push(attrData);
-        } else {
-          this.attrs = [attrData];
-        }
-      };
-      Token$3.prototype.attrSet = function attrSet(name2, value) {
-        var idx = this.attrIndex(name2),
-          attrData = [name2, value];
-        if (idx < 0) {
-          this.attrPush(attrData);
-        } else {
-          this.attrs[idx] = attrData;
-        }
-      };
-      Token$3.prototype.attrGet = function attrGet(name2) {
-        var idx = this.attrIndex(name2),
-          value = null;
-        if (idx >= 0) {
-          value = this.attrs[idx][1];
-        }
-        return value;
-      };
-      Token$3.prototype.attrJoin = function attrJoin(name2, value) {
-        var idx = this.attrIndex(name2);
-        if (idx < 0) {
-          this.attrPush([name2, value]);
-        } else {
-          this.attrs[idx][1] = this.attrs[idx][1] + " " + value;
-        }
-      };
-      var token = Token$3;
-      var Token$2 = token;
-      function StateCore(src, md2, env) {
-        this.src = src;
-        this.env = env;
-        this.tokens = [];
-        this.inlineMode = false;
-        this.md = md2;
-      }
-      StateCore.prototype.Token = Token$2;
-      var state_core = StateCore;
-      var Ruler$2 = ruler;
-      var _rules$2 = [
-        ["normalize", normalize],
-        ["block", block$1],
-        ["inline", inline],
-        ["linkify", linkify],
-        ["replacements", replacements],
-        ["smartquotes", smartquotes],
-      ];
-      function Core() {
-        this.ruler = new Ruler$2();
-        for (var i = 0; i < _rules$2.length; i++) {
-          this.ruler.push(_rules$2[i][0], _rules$2[i][1]);
-        }
-      }
-      Core.prototype.process = function (state) {
-        var i, l2, rules;
-        rules = this.ruler.getRules("");
-        for (i = 0, l2 = rules.length; i < l2; i++) {
-          rules[i](state);
-        }
-      };
-      Core.prototype.State = state_core;
-      var parser_core = Core;
-      var isSpace$a = utils$1.isSpace;
-      function getLine(state, line) {
-        var pos = state.bMarks[line] + state.tShift[line],
-          max = state.eMarks[line];
-        return state.src.substr(pos, max - pos);
-      }
-      function escapedSplit(str) {
-        var result2 = [],
-          pos = 0,
-          max = str.length,
-          ch2,
-          isEscaped = false,
-          lastPos = 0,
-          current = "";
-        ch2 = str.charCodeAt(pos);
-        while (pos < max) {
-          if (ch2 === 124) {
-            if (!isEscaped) {
-              result2.push(current + str.substring(lastPos, pos));
-              current = "";
-              lastPos = pos + 1;
-            } else {
-              current += str.substring(lastPos, pos - 1);
-              lastPos = pos;
-            }
-          }
-          isEscaped = ch2 === 92;
-          pos++;
-          ch2 = str.charCodeAt(pos);
-        }
-        result2.push(current + str.substring(lastPos));
-        return result2;
-      }
-      var table = function table2(state, startLine, endLine, silent) {
-        var ch2,
-          lineText,
-          pos,
-          i,
-          l2,
-          nextLine,
-          columns,
-          columnCount,
-          token2,
-          aligns,
-          t2,
-          tableLines,
-          tbodyLines,
-          oldParentType,
-          terminate,
-          terminatorRules,
-          firstCh,
-          secondCh;
-        if (startLine + 2 > endLine) {
-          return false;
-        }
-        nextLine = startLine + 1;
-        if (state.sCount[nextLine] < state.blkIndent) {
-          return false;
-        }
-        if (state.sCount[nextLine] - state.blkIndent >= 4) {
-          return false;
-        }
-        pos = state.bMarks[nextLine] + state.tShift[nextLine];
-        if (pos >= state.eMarks[nextLine]) {
-          return false;
-        }
-        firstCh = state.src.charCodeAt(pos++);
-        if (firstCh !== 124 && firstCh !== 45 && firstCh !== 58) {
-          return false;
-        }
-        if (pos >= state.eMarks[nextLine]) {
-          return false;
-        }
-        secondCh = state.src.charCodeAt(pos++);
-        if (
-          secondCh !== 124 &&
-          secondCh !== 45 &&
-          secondCh !== 58 &&
-          !isSpace$a(secondCh)
-        ) {
-          return false;
-        }
-        if (firstCh === 45 && isSpace$a(secondCh)) {
-          return false;
-        }
-        while (pos < state.eMarks[nextLine]) {
-          ch2 = state.src.charCodeAt(pos);
-          if (ch2 !== 124 && ch2 !== 45 && ch2 !== 58 && !isSpace$a(ch2)) {
-            return false;
-          }
-          pos++;
-        }
-        lineText = getLine(state, startLine + 1);
-        columns = lineText.split("|");
-        aligns = [];
-        for (i = 0; i < columns.length; i++) {
-          t2 = columns[i].trim();
-          if (!t2) {
-            if (i === 0 || i === columns.length - 1) {
-              continue;
-            } else {
-              return false;
-            }
-          }
-          if (!/^:?-+:?$/.test(t2)) {
-            return false;
-          }
-          if (t2.charCodeAt(t2.length - 1) === 58) {
-            aligns.push(t2.charCodeAt(0) === 58 ? "center" : "right");
-          } else if (t2.charCodeAt(0) === 58) {
-            aligns.push("left");
-          } else {
-            aligns.push("");
-          }
-        }
-        lineText = getLine(state, startLine).trim();
-        if (lineText.indexOf("|") === -1) {
-          return false;
-        }
-        if (state.sCount[startLine] - state.blkIndent >= 4) {
-          return false;
-        }
-        columns = escapedSplit(lineText);
-        if (columns.length && columns[0] === "") columns.shift();
-        if (columns.length && columns[columns.length - 1] === "") columns.pop();
-        columnCount = columns.length;
-        if (columnCount === 0 || columnCount !== aligns.length) {
-          return false;
-        }
-        if (silent) {
-          return true;
-        }
-        oldParentType = state.parentType;
-        state.parentType = "table";
-        terminatorRules = state.md.block.ruler.getRules("blockquote");
-        token2 = state.push("table_open", "table", 1);
-        token2.map = tableLines = [startLine, 0];
-        token2 = state.push("thead_open", "thead", 1);
-        token2.map = [startLine, startLine + 1];
-        token2 = state.push("tr_open", "tr", 1);
-        token2.map = [startLine, startLine + 1];
-        for (i = 0; i < columns.length; i++) {
-          token2 = state.push("th_open", "th", 1);
-          if (aligns[i]) {
-            token2.attrs = [["style", "text-align:" + aligns[i]]];
-          }
-          token2 = state.push("inline", "", 0);
-          token2.content = columns[i].trim();
-          token2.children = [];
-          token2 = state.push("th_close", "th", -1);
-        }
-        token2 = state.push("tr_close", "tr", -1);
-        token2 = state.push("thead_close", "thead", -1);
-        for (nextLine = startLine + 2; nextLine < endLine; nextLine++) {
-          if (state.sCount[nextLine] < state.blkIndent) {
-            break;
-          }
-          terminate = false;
-          for (i = 0, l2 = terminatorRules.length; i < l2; i++) {
-            if (terminatorRules[i](state, nextLine, endLine, true)) {
-              terminate = true;
-              break;
-            }
-          }
-          if (terminate) {
-            break;
-          }
-          lineText = getLine(state, nextLine).trim();
-          if (!lineText) {
-            break;
-          }
-          if (state.sCount[nextLine] - state.blkIndent >= 4) {
-            break;
-          }
-          columns = escapedSplit(lineText);
-          if (columns.length && columns[0] === "") columns.shift();
-          if (columns.length && columns[columns.length - 1] === "")
-            columns.pop();
-          if (nextLine === startLine + 2) {
-            token2 = state.push("tbody_open", "tbody", 1);
-            token2.map = tbodyLines = [startLine + 2, 0];
-          }
-          token2 = state.push("tr_open", "tr", 1);
-          token2.map = [nextLine, nextLine + 1];
-          for (i = 0; i < columnCount; i++) {
-            token2 = state.push("td_open", "td", 1);
-            if (aligns[i]) {
-              token2.attrs = [["style", "text-align:" + aligns[i]]];
-            }
-            token2 = state.push("inline", "", 0);
-            token2.content = columns[i] ? columns[i].trim() : "";
-            token2.children = [];
-            token2 = state.push("td_close", "td", -1);
-          }
-          token2 = state.push("tr_close", "tr", -1);
-        }
-        if (tbodyLines) {
-          token2 = state.push("tbody_close", "tbody", -1);
-          tbodyLines[1] = nextLine;
-        }
-        token2 = state.push("table_close", "table", -1);
-        tableLines[1] = nextLine;
-        state.parentType = oldParentType;
-        state.line = nextLine;
-        return true;
-      };
-      var code$2 = function code(state, startLine, endLine) {
-        var nextLine, last, token2;
-        if (state.sCount[startLine] - state.blkIndent < 4) {
-          return false;
-        }
-        last = nextLine = startLine + 1;
-        while (nextLine < endLine) {
-          if (state.isEmpty(nextLine)) {
-            nextLine++;
-            continue;
-          }
-          if (state.sCount[nextLine] - state.blkIndent >= 4) {
-            nextLine++;
-            last = nextLine;
-            continue;
-          }
-          break;
-        }
-        state.line = last;
-        token2 = state.push("code_block", "code", 0);
-        token2.content =
-          state.getLines(startLine, last, 4 + state.blkIndent, false) + "\n";
-        token2.map = [startLine, state.line];
-        return true;
-      };
-      var fence = function fence2(state, startLine, endLine, silent) {
-        var marker2,
-          len,
-          params,
-          nextLine,
-          mem,
-          token2,
-          markup,
-          haveEndMarker = false,
-          pos = state.bMarks[startLine] + state.tShift[startLine],
-          max = state.eMarks[startLine];
-        if (state.sCount[startLine] - state.blkIndent >= 4) {
-          return false;
-        }
-        if (pos + 3 > max) {
-          return false;
-        }
-        marker2 = state.src.charCodeAt(pos);
-        if (marker2 !== 126 && marker2 !== 96) {
-          return false;
-        }
-        mem = pos;
-        pos = state.skipChars(pos, marker2);
-        len = pos - mem;
-        if (len < 3) {
-          return false;
-        }
-        markup = state.src.slice(mem, pos);
-        params = state.src.slice(pos, max);
-        if (marker2 === 96) {
-          if (params.indexOf(String.fromCharCode(marker2)) >= 0) {
-            return false;
-          }
-        }
-        if (silent) {
-          return true;
-        }
-        nextLine = startLine;
-        for (;;) {
-          nextLine++;
-          if (nextLine >= endLine) {
-            break;
-          }
-          pos = mem = state.bMarks[nextLine] + state.tShift[nextLine];
-          max = state.eMarks[nextLine];
-          if (pos < max && state.sCount[nextLine] < state.blkIndent) {
-            break;
-          }
-          if (state.src.charCodeAt(pos) !== marker2) {
-            continue;
-          }
-          if (state.sCount[nextLine] - state.blkIndent >= 4) {
-            continue;
-          }
-          pos = state.skipChars(pos, marker2);
-          if (pos - mem < len) {
-            continue;
-          }
-          pos = state.skipSpaces(pos);
-          if (pos < max) {
-            continue;
-          }
-          haveEndMarker = true;
-          break;
-        }
-        len = state.sCount[startLine];
-        state.line = nextLine + (haveEndMarker ? 1 : 0);
-        token2 = state.push("fence", "code", 0);
-        token2.info = params;
-        token2.content = state.getLines(startLine + 1, nextLine, len, true);
-        token2.markup = markup;
-        token2.map = [startLine, state.line];
-        return true;
-      };
-      var isSpace$9 = utils$1.isSpace;
-      var blockquote = function blockquote2(state, startLine, endLine, silent) {
-        var adjustTab,
-          ch2,
-          i,
-          initial,
-          l2,
-          lastLineEmpty,
-          lines,
-          nextLine,
-          offset,
-          oldBMarks,
-          oldBSCount,
-          oldIndent,
-          oldParentType,
-          oldSCount,
-          oldTShift,
-          spaceAfterMarker,
-          terminate,
-          terminatorRules,
-          token2,
-          isOutdented,
-          oldLineMax = state.lineMax,
-          pos = state.bMarks[startLine] + state.tShift[startLine],
-          max = state.eMarks[startLine];
-        if (state.sCount[startLine] - state.blkIndent >= 4) {
-          return false;
-        }
-        if (state.src.charCodeAt(pos++) !== 62) {
-          return false;
-        }
-        if (silent) {
-          return true;
-        }
-        initial = offset = state.sCount[startLine] + 1;
-        if (state.src.charCodeAt(pos) === 32) {
-          pos++;
-          initial++;
-          offset++;
-          adjustTab = false;
-          spaceAfterMarker = true;
-        } else if (state.src.charCodeAt(pos) === 9) {
-          spaceAfterMarker = true;
-          if ((state.bsCount[startLine] + offset) % 4 === 3) {
-            pos++;
-            initial++;
-            offset++;
-            adjustTab = false;
-          } else {
-            adjustTab = true;
-          }
-        } else {
-          spaceAfterMarker = false;
-        }
-        oldBMarks = [state.bMarks[startLine]];
-        state.bMarks[startLine] = pos;
-        while (pos < max) {
-          ch2 = state.src.charCodeAt(pos);
-          if (isSpace$9(ch2)) {
-            if (ch2 === 9) {
-              offset +=
-                4 -
-                ((offset + state.bsCount[startLine] + (adjustTab ? 1 : 0)) % 4);
-            } else {
-              offset++;
-            }
-          } else {
-            break;
-          }
-          pos++;
-        }
-        oldBSCount = [state.bsCount[startLine]];
-        state.bsCount[startLine] =
-          state.sCount[startLine] + 1 + (spaceAfterMarker ? 1 : 0);
-        lastLineEmpty = pos >= max;
-        oldSCount = [state.sCount[startLine]];
-        state.sCount[startLine] = offset - initial;
-        oldTShift = [state.tShift[startLine]];
-        state.tShift[startLine] = pos - state.bMarks[startLine];
-        terminatorRules = state.md.block.ruler.getRules("blockquote");
-        oldParentType = state.parentType;
-        state.parentType = "blockquote";
-        for (nextLine = startLine + 1; nextLine < endLine; nextLine++) {
-          isOutdented = state.sCount[nextLine] < state.blkIndent;
-          pos = state.bMarks[nextLine] + state.tShift[nextLine];
-          max = state.eMarks[nextLine];
-          if (pos >= max) {
-            break;
-          }
-          if (state.src.charCodeAt(pos++) === 62 && !isOutdented) {
-            initial = offset = state.sCount[nextLine] + 1;
-            if (state.src.charCodeAt(pos) === 32) {
-              pos++;
-              initial++;
-              offset++;
-              adjustTab = false;
-              spaceAfterMarker = true;
-            } else if (state.src.charCodeAt(pos) === 9) {
-              spaceAfterMarker = true;
-              if ((state.bsCount[nextLine] + offset) % 4 === 3) {
-                pos++;
-                initial++;
-                offset++;
-                adjustTab = false;
-              } else {
-                adjustTab = true;
-              }
-            } else {
-              spaceAfterMarker = false;
-            }
-            oldBMarks.push(state.bMarks[nextLine]);
-            state.bMarks[nextLine] = pos;
-            while (pos < max) {
-              ch2 = state.src.charCodeAt(pos);
-              if (isSpace$9(ch2)) {
-                if (ch2 === 9) {
-                  offset +=
-                    4 -
-                    ((offset + state.bsCount[nextLine] + (adjustTab ? 1 : 0)) %
-                      4);
-                } else {
-                  offset++;
-                }
-              } else {
-                break;
-              }
-              pos++;
-            }
-            lastLineEmpty = pos >= max;
-            oldBSCount.push(state.bsCount[nextLine]);
-            state.bsCount[nextLine] =
-              state.sCount[nextLine] + 1 + (spaceAfterMarker ? 1 : 0);
-            oldSCount.push(state.sCount[nextLine]);
-            state.sCount[nextLine] = offset - initial;
-            oldTShift.push(state.tShift[nextLine]);
-            state.tShift[nextLine] = pos - state.bMarks[nextLine];
-            continue;
-          }
-          if (lastLineEmpty) {
-            break;
-          }
-          terminate = false;
-          for (i = 0, l2 = terminatorRules.length; i < l2; i++) {
-            if (terminatorRules[i](state, nextLine, endLine, true)) {
-              terminate = true;
-              break;
-            }
-          }
-          if (terminate) {
-            state.lineMax = nextLine;
-            if (state.blkIndent !== 0) {
-              oldBMarks.push(state.bMarks[nextLine]);
-              oldBSCount.push(state.bsCount[nextLine]);
-              oldTShift.push(state.tShift[nextLine]);
-              oldSCount.push(state.sCount[nextLine]);
-              state.sCount[nextLine] -= state.blkIndent;
-            }
-            break;
-          }
-          oldBMarks.push(state.bMarks[nextLine]);
-          oldBSCount.push(state.bsCount[nextLine]);
-          oldTShift.push(state.tShift[nextLine]);
-          oldSCount.push(state.sCount[nextLine]);
-          state.sCount[nextLine] = -1;
-        }
-        oldIndent = state.blkIndent;
-        state.blkIndent = 0;
-        token2 = state.push("blockquote_open", "blockquote", 1);
-        token2.markup = ">";
-        token2.map = lines = [startLine, 0];
-        state.md.block.tokenize(state, startLine, nextLine);
-        token2 = state.push("blockquote_close", "blockquote", -1);
-        token2.markup = ">";
-        state.lineMax = oldLineMax;
-        state.parentType = oldParentType;
-        lines[1] = state.line;
-        for (i = 0; i < oldTShift.length; i++) {
-          state.bMarks[i + startLine] = oldBMarks[i];
-          state.tShift[i + startLine] = oldTShift[i];
-          state.sCount[i + startLine] = oldSCount[i];
-          state.bsCount[i + startLine] = oldBSCount[i];
-        }
-        state.blkIndent = oldIndent;
-        return true;
-      };
-      var isSpace$8 = utils$1.isSpace;
-      var hr = function hr2(state, startLine, endLine, silent) {
-        var marker2,
-          cnt,
-          ch2,
-          token2,
-          pos = state.bMarks[startLine] + state.tShift[startLine],
-          max = state.eMarks[startLine];
-        if (state.sCount[startLine] - state.blkIndent >= 4) {
-          return false;
-        }
-        marker2 = state.src.charCodeAt(pos++);
-        if (marker2 !== 42 && marker2 !== 45 && marker2 !== 95) {
-          return false;
-        }
-        cnt = 1;
-        while (pos < max) {
-          ch2 = state.src.charCodeAt(pos++);
-          if (ch2 !== marker2 && !isSpace$8(ch2)) {
-            return false;
-          }
-          if (ch2 === marker2) {
-            cnt++;
-          }
-        }
-        if (cnt < 3) {
-          return false;
-        }
-        if (silent) {
-          return true;
-        }
-        state.line = startLine + 1;
-        token2 = state.push("hr", "hr", 0);
-        token2.map = [startLine, state.line];
-        token2.markup = Array(cnt + 1).join(String.fromCharCode(marker2));
-        return true;
-      };
-      var isSpace$7 = utils$1.isSpace;
-      function skipBulletListMarker(state, startLine) {
-        var marker2, pos, max, ch2;
-        pos = state.bMarks[startLine] + state.tShift[startLine];
-        max = state.eMarks[startLine];
-        marker2 = state.src.charCodeAt(pos++);
-        if (marker2 !== 42 && marker2 !== 45 && marker2 !== 43) {
-          return -1;
-        }
-        if (pos < max) {
-          ch2 = state.src.charCodeAt(pos);
-          if (!isSpace$7(ch2)) {
-            return -1;
-          }
-        }
-        return pos;
-      }
-      function skipOrderedListMarker(state, startLine) {
-        var ch2,
-          start2 = state.bMarks[startLine] + state.tShift[startLine],
-          pos = start2,
-          max = state.eMarks[startLine];
-        if (pos + 1 >= max) {
-          return -1;
-        }
-        ch2 = state.src.charCodeAt(pos++);
-        if (ch2 < 48 || ch2 > 57) {
-          return -1;
-        }
-        for (;;) {
-          if (pos >= max) {
-            return -1;
-          }
-          ch2 = state.src.charCodeAt(pos++);
-          if (ch2 >= 48 && ch2 <= 57) {
-            if (pos - start2 >= 10) {
-              return -1;
-            }
-            continue;
-          }
-          if (ch2 === 41 || ch2 === 46) {
-            break;
-          }
-          return -1;
-        }
-        if (pos < max) {
-          ch2 = state.src.charCodeAt(pos);
-          if (!isSpace$7(ch2)) {
-            return -1;
-          }
-        }
-        return pos;
-      }
-      function markTightParagraphs(state, idx) {
-        var i,
-          l2,
-          level = state.level + 2;
-        for (i = idx + 2, l2 = state.tokens.length - 2; i < l2; i++) {
-          if (
-            state.tokens[i].level === level &&
-            state.tokens[i].type === "paragraph_open"
-          ) {
-            state.tokens[i + 2].hidden = true;
-            state.tokens[i].hidden = true;
-            i += 2;
-          }
-        }
-      }
-      var list = function list2(state, startLine, endLine, silent) {
-        var ch2,
-          contentStart,
-          i,
-          indent2,
-          indentAfterMarker,
-          initial,
-          isOrdered,
-          itemLines,
-          l2,
-          listLines,
-          listTokIdx,
-          markerCharCode,
-          markerValue,
-          max,
-          nextLine,
-          offset,
-          oldListIndent,
-          oldParentType,
-          oldSCount,
-          oldTShift,
-          oldTight,
-          pos,
-          posAfterMarker,
-          prevEmptyEnd,
-          start2,
-          terminate,
-          terminatorRules,
-          token2,
-          isTerminatingParagraph = false,
-          tight = true;
-        if (state.sCount[startLine] - state.blkIndent >= 4) {
-          return false;
-        }
-        if (
-          state.listIndent >= 0 &&
-          state.sCount[startLine] - state.listIndent >= 4 &&
-          state.sCount[startLine] < state.blkIndent
-        ) {
-          return false;
-        }
-        if (silent && state.parentType === "paragraph") {
-          if (state.sCount[startLine] >= state.blkIndent) {
-            isTerminatingParagraph = true;
-          }
-        }
-        if ((posAfterMarker = skipOrderedListMarker(state, startLine)) >= 0) {
-          isOrdered = true;
-          start2 = state.bMarks[startLine] + state.tShift[startLine];
-          markerValue = Number(state.src.slice(start2, posAfterMarker - 1));
-          if (isTerminatingParagraph && markerValue !== 1) return false;
-        } else if (
-          (posAfterMarker = skipBulletListMarker(state, startLine)) >= 0
-        ) {
-          isOrdered = false;
-        } else {
-          return false;
-        }
-        if (isTerminatingParagraph) {
-          if (state.skipSpaces(posAfterMarker) >= state.eMarks[startLine])
-            return false;
-        }
-        markerCharCode = state.src.charCodeAt(posAfterMarker - 1);
-        if (silent) {
-          return true;
-        }
-        listTokIdx = state.tokens.length;
-        if (isOrdered) {
-          token2 = state.push("ordered_list_open", "ol", 1);
-          if (markerValue !== 1) {
-            token2.attrs = [["start", markerValue]];
-          }
-        } else {
-          token2 = state.push("bullet_list_open", "ul", 1);
-        }
-        token2.map = listLines = [startLine, 0];
-        token2.markup = String.fromCharCode(markerCharCode);
-        nextLine = startLine;
-        prevEmptyEnd = false;
-        terminatorRules = state.md.block.ruler.getRules("list");
-        oldParentType = state.parentType;
-        state.parentType = "list";
-        while (nextLine < endLine) {
-          pos = posAfterMarker;
-          max = state.eMarks[nextLine];
-          initial = offset =
-            state.sCount[nextLine] +
-            posAfterMarker -
-            (state.bMarks[startLine] + state.tShift[startLine]);
-          while (pos < max) {
-            ch2 = state.src.charCodeAt(pos);
-            if (ch2 === 9) {
-              offset += 4 - ((offset + state.bsCount[nextLine]) % 4);
-            } else if (ch2 === 32) {
-              offset++;
-            } else {
-              break;
-            }
-            pos++;
-          }
-          contentStart = pos;
-          if (contentStart >= max) {
-            indentAfterMarker = 1;
-          } else {
-            indentAfterMarker = offset - initial;
-          }
-          if (indentAfterMarker > 4) {
-            indentAfterMarker = 1;
-          }
-          indent2 = initial + indentAfterMarker;
-          token2 = state.push("list_item_open", "li", 1);
-          token2.markup = String.fromCharCode(markerCharCode);
-          token2.map = itemLines = [startLine, 0];
-          if (isOrdered) {
-            token2.info = state.src.slice(start2, posAfterMarker - 1);
-          }
-          oldTight = state.tight;
-          oldTShift = state.tShift[startLine];
-          oldSCount = state.sCount[startLine];
-          oldListIndent = state.listIndent;
-          state.listIndent = state.blkIndent;
-          state.blkIndent = indent2;
-          state.tight = true;
-          state.tShift[startLine] = contentStart - state.bMarks[startLine];
-          state.sCount[startLine] = offset;
-          if (contentStart >= max && state.isEmpty(startLine + 1)) {
-            state.line = Math.min(state.line + 2, endLine);
-          } else {
-            state.md.block.tokenize(state, startLine, endLine, true);
-          }
-          if (!state.tight || prevEmptyEnd) {
-            tight = false;
-          }
-          prevEmptyEnd =
-            state.line - startLine > 1 && state.isEmpty(state.line - 1);
-          state.blkIndent = state.listIndent;
-          state.listIndent = oldListIndent;
-          state.tShift[startLine] = oldTShift;
-          state.sCount[startLine] = oldSCount;
-          state.tight = oldTight;
-          token2 = state.push("list_item_close", "li", -1);
-          token2.markup = String.fromCharCode(markerCharCode);
-          nextLine = startLine = state.line;
-          itemLines[1] = nextLine;
-          contentStart = state.bMarks[startLine];
-          if (nextLine >= endLine) {
-            break;
-          }
-          if (state.sCount[nextLine] < state.blkIndent) {
-            break;
-          }
-          if (state.sCount[startLine] - state.blkIndent >= 4) {
-            break;
-          }
-          terminate = false;
-          for (i = 0, l2 = terminatorRules.length; i < l2; i++) {
-            if (terminatorRules[i](state, nextLine, endLine, true)) {
-              terminate = true;
-              break;
-            }
-          }
-          if (terminate) {
-            break;
-          }
-          if (isOrdered) {
-            posAfterMarker = skipOrderedListMarker(state, nextLine);
-            if (posAfterMarker < 0) {
-              break;
-            }
-            start2 = state.bMarks[nextLine] + state.tShift[nextLine];
-          } else {
-            posAfterMarker = skipBulletListMarker(state, nextLine);
-            if (posAfterMarker < 0) {
-              break;
-            }
-          }
-          if (markerCharCode !== state.src.charCodeAt(posAfterMarker - 1)) {
-            break;
-          }
-        }
-        if (isOrdered) {
-          token2 = state.push("ordered_list_close", "ol", -1);
-        } else {
-          token2 = state.push("bullet_list_close", "ul", -1);
-        }
-        token2.markup = String.fromCharCode(markerCharCode);
-        listLines[1] = nextLine;
-        state.line = nextLine;
-        state.parentType = oldParentType;
-        if (tight) {
-          markTightParagraphs(state, listTokIdx);
-        }
-        return true;
-      };
-      var normalizeReference$2 = utils$1.normalizeReference;
-      var isSpace$6 = utils$1.isSpace;
-      var reference = function reference2(state, startLine, _endLine, silent) {
-        var ch2,
-          destEndPos,
-          destEndLineNo,
-          endLine,
-          href,
-          i,
-          l2,
-          label,
-          labelEnd,
-          oldParentType,
-          res,
-          start2,
-          str,
-          terminate,
-          terminatorRules,
-          title,
-          lines = 0,
-          pos = state.bMarks[startLine] + state.tShift[startLine],
-          max = state.eMarks[startLine],
-          nextLine = startLine + 1;
-        if (state.sCount[startLine] - state.blkIndent >= 4) {
-          return false;
-        }
-        if (state.src.charCodeAt(pos) !== 91) {
-          return false;
-        }
-        while (++pos < max) {
-          if (
-            state.src.charCodeAt(pos) === 93 &&
-            state.src.charCodeAt(pos - 1) !== 92
-          ) {
-            if (pos + 1 === max) {
-              return false;
-            }
-            if (state.src.charCodeAt(pos + 1) !== 58) {
-              return false;
-            }
-            break;
-          }
-        }
-        endLine = state.lineMax;
-        terminatorRules = state.md.block.ruler.getRules("reference");
-        oldParentType = state.parentType;
-        state.parentType = "reference";
-        for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
-          if (state.sCount[nextLine] - state.blkIndent > 3) {
-            continue;
-          }
-          if (state.sCount[nextLine] < 0) {
-            continue;
-          }
-          terminate = false;
-          for (i = 0, l2 = terminatorRules.length; i < l2; i++) {
-            if (terminatorRules[i](state, nextLine, endLine, true)) {
-              terminate = true;
-              break;
-            }
-          }
-          if (terminate) {
-            break;
-          }
-        }
-        str = state
-          .getLines(startLine, nextLine, state.blkIndent, false)
-          .trim();
-        max = str.length;
-        for (pos = 1; pos < max; pos++) {
-          ch2 = str.charCodeAt(pos);
-          if (ch2 === 91) {
-            return false;
-          } else if (ch2 === 93) {
-            labelEnd = pos;
-            break;
-          } else if (ch2 === 10) {
-            lines++;
-          } else if (ch2 === 92) {
-            pos++;
-            if (pos < max && str.charCodeAt(pos) === 10) {
-              lines++;
-            }
-          }
-        }
-        if (labelEnd < 0 || str.charCodeAt(labelEnd + 1) !== 58) {
-          return false;
-        }
-        for (pos = labelEnd + 2; pos < max; pos++) {
-          ch2 = str.charCodeAt(pos);
-          if (ch2 === 10) {
-            lines++;
-          } else if (isSpace$6(ch2));
-          else {
-            break;
-          }
-        }
-        res = state.md.helpers.parseLinkDestination(str, pos, max);
-        if (!res.ok) {
-          return false;
-        }
-        href = state.md.normalizeLink(res.str);
-        if (!state.md.validateLink(href)) {
-          return false;
-        }
-        pos = res.pos;
-        lines += res.lines;
-        destEndPos = pos;
-        destEndLineNo = lines;
-        start2 = pos;
-        for (; pos < max; pos++) {
-          ch2 = str.charCodeAt(pos);
-          if (ch2 === 10) {
-            lines++;
-          } else if (isSpace$6(ch2));
-          else {
-            break;
-          }
-        }
-        res = state.md.helpers.parseLinkTitle(str, pos, max);
-        if (pos < max && start2 !== pos && res.ok) {
-          title = res.str;
-          pos = res.pos;
-          lines += res.lines;
-        } else {
-          title = "";
-          pos = destEndPos;
-          lines = destEndLineNo;
-        }
-        while (pos < max) {
-          ch2 = str.charCodeAt(pos);
-          if (!isSpace$6(ch2)) {
-            break;
-          }
-          pos++;
-        }
-        if (pos < max && str.charCodeAt(pos) !== 10) {
-          if (title) {
-            title = "";
-            pos = destEndPos;
-            lines = destEndLineNo;
-            while (pos < max) {
-              ch2 = str.charCodeAt(pos);
-              if (!isSpace$6(ch2)) {
-                break;
-              }
-              pos++;
-            }
-          }
-        }
-        if (pos < max && str.charCodeAt(pos) !== 10) {
-          return false;
-        }
-        label = normalizeReference$2(str.slice(1, labelEnd));
-        if (!label) {
-          return false;
-        }
-        if (silent) {
-          return true;
-        }
-        if (typeof state.env.references === "undefined") {
-          state.env.references = {};
-        }
-        if (typeof state.env.references[label] === "undefined") {
-          state.env.references[label] = { title, href };
-        }
-        state.parentType = oldParentType;
-        state.line = startLine + lines + 1;
-        return true;
-      };
-      var html_blocks = [
-        "address",
-        "article",
-        "aside",
-        "base",
-        "basefont",
-        "blockquote",
-        "body",
-        "caption",
-        "center",
-        "col",
-        "colgroup",
-        "dd",
-        "details",
-        "dialog",
-        "dir",
-        "div",
-        "dl",
-        "dt",
-        "fieldset",
-        "figcaption",
-        "figure",
-        "footer",
-        "form",
-        "frame",
-        "frameset",
-        "h1",
-        "h2",
-        "h3",
-        "h4",
-        "h5",
-        "h6",
-        "head",
-        "header",
-        "hr",
-        "html",
-        "iframe",
-        "legend",
-        "li",
-        "link",
-        "main",
-        "menu",
-        "menuitem",
-        "nav",
-        "noframes",
-        "ol",
-        "optgroup",
-        "option",
-        "p",
-        "param",
-        "section",
-        "source",
-        "summary",
-        "table",
-        "tbody",
-        "td",
-        "tfoot",
-        "th",
-        "thead",
-        "title",
-        "tr",
-        "track",
-        "ul",
-      ];
-      var html_re = {};
-      var attr_name = "[a-zA-Z_:][a-zA-Z0-9:._-]*";
-      var unquoted = "[^\"'=<>`\\x00-\\x20]+";
-      var single_quoted = "'[^']*'";
-      var double_quoted = '"[^"]*"';
-      var attr_value =
-        "(?:" + unquoted + "|" + single_quoted + "|" + double_quoted + ")";
-      var attribute =
-        "(?:\\s+" + attr_name + "(?:\\s*=\\s*" + attr_value + ")?)";
-      var open_tag = "<[A-Za-z][A-Za-z0-9\\-]*" + attribute + "*\\s*\\/?>";
-      var close_tag = "<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>";
-      var comment$3 = "<!---->|<!--(?:-?[^>-])(?:-?[^-])*-->";
-      var processing = "<[?][\\s\\S]*?[?]>";
-      var declaration = "<![A-Z]+\\s+[^>]*>";
-      var cdata = "<!\\[CDATA\\[[\\s\\S]*?\\]\\]>";
-      var HTML_TAG_RE$1 = new RegExp(
-        "^(?:" +
-          open_tag +
-          "|" +
-          close_tag +
-          "|" +
-          comment$3 +
-          "|" +
-          processing +
-          "|" +
-          declaration +
-          "|" +
-          cdata +
-          ")"
-      );
-      var HTML_OPEN_CLOSE_TAG_RE$1 = new RegExp(
-        "^(?:" + open_tag + "|" + close_tag + ")"
-      );
-      html_re.HTML_TAG_RE = HTML_TAG_RE$1;
-      html_re.HTML_OPEN_CLOSE_TAG_RE = HTML_OPEN_CLOSE_TAG_RE$1;
-      var block_names = html_blocks;
-      var HTML_OPEN_CLOSE_TAG_RE = html_re.HTML_OPEN_CLOSE_TAG_RE;
-      var HTML_SEQUENCES = [
-        [
-          /^<(script|pre|style|textarea)(?=(\s|>|$))/i,
-          /<\/(script|pre|style|textarea)>/i,
-          true,
-        ],
-        [/^<!--/, /-->/, true],
-        [/^<\?/, /\?>/, true],
-        [/^<![A-Z]/, />/, true],
-        [/^<!\[CDATA\[/, /\]\]>/, true],
-        [
-          new RegExp("^</?(" + block_names.join("|") + ")(?=(\\s|/?>|$))", "i"),
-          /^$/,
-          true,
-        ],
-        [new RegExp(HTML_OPEN_CLOSE_TAG_RE.source + "\\s*$"), /^$/, false],
-      ];
-      var html_block = function html_block2(state, startLine, endLine, silent) {
-        var i,
-          nextLine,
-          token2,
-          lineText,
-          pos = state.bMarks[startLine] + state.tShift[startLine],
-          max = state.eMarks[startLine];
-        if (state.sCount[startLine] - state.blkIndent >= 4) {
-          return false;
-        }
-        if (!state.md.options.html) {
-          return false;
-        }
-        if (state.src.charCodeAt(pos) !== 60) {
-          return false;
-        }
-        lineText = state.src.slice(pos, max);
-        for (i = 0; i < HTML_SEQUENCES.length; i++) {
-          if (HTML_SEQUENCES[i][0].test(lineText)) {
-            break;
-          }
-        }
-        if (i === HTML_SEQUENCES.length) {
-          return false;
-        }
-        if (silent) {
-          return HTML_SEQUENCES[i][2];
-        }
-        nextLine = startLine + 1;
-        if (!HTML_SEQUENCES[i][1].test(lineText)) {
-          for (; nextLine < endLine; nextLine++) {
-            if (state.sCount[nextLine] < state.blkIndent) {
-              break;
-            }
-            pos = state.bMarks[nextLine] + state.tShift[nextLine];
-            max = state.eMarks[nextLine];
-            lineText = state.src.slice(pos, max);
-            if (HTML_SEQUENCES[i][1].test(lineText)) {
-              if (lineText.length !== 0) {
-                nextLine++;
-              }
-              break;
-            }
-          }
-        }
-        state.line = nextLine;
-        token2 = state.push("html_block", "", 0);
-        token2.map = [startLine, nextLine];
-        token2.content = state.getLines(
-          startLine,
-          nextLine,
-          state.blkIndent,
-          true
-        );
-        return true;
-      };
-      var isSpace$5 = utils$1.isSpace;
-      var heading = function heading2(state, startLine, endLine, silent) {
-        var ch2,
-          level,
-          tmp,
-          token2,
-          pos = state.bMarks[startLine] + state.tShift[startLine],
-          max = state.eMarks[startLine];
-        if (state.sCount[startLine] - state.blkIndent >= 4) {
-          return false;
-        }
-        ch2 = state.src.charCodeAt(pos);
-        if (ch2 !== 35 || pos >= max) {
-          return false;
-        }
-        level = 1;
-        ch2 = state.src.charCodeAt(++pos);
-        while (ch2 === 35 && pos < max && level <= 6) {
-          level++;
-          ch2 = state.src.charCodeAt(++pos);
-        }
-        if (level > 6 || (pos < max && !isSpace$5(ch2))) {
-          return false;
-        }
-        if (silent) {
-          return true;
-        }
-        max = state.skipSpacesBack(max, pos);
-        tmp = state.skipCharsBack(max, 35, pos);
-        if (tmp > pos && isSpace$5(state.src.charCodeAt(tmp - 1))) {
-          max = tmp;
-        }
-        state.line = startLine + 1;
-        token2 = state.push("heading_open", "h" + String(level), 1);
-        token2.markup = "########".slice(0, level);
-        token2.map = [startLine, state.line];
-        token2 = state.push("inline", "", 0);
-        token2.content = state.src.slice(pos, max).trim();
-        token2.map = [startLine, state.line];
-        token2.children = [];
-        token2 = state.push("heading_close", "h" + String(level), -1);
-        token2.markup = "########".slice(0, level);
-        return true;
-      };
-      var lheading = function lheading2(state, startLine, endLine) {
-        var content,
-          terminate,
-          i,
-          l2,
-          token2,
-          pos,
-          max,
-          level,
-          marker2,
-          nextLine = startLine + 1,
-          oldParentType,
-          terminatorRules = state.md.block.ruler.getRules("paragraph");
-        if (state.sCount[startLine] - state.blkIndent >= 4) {
-          return false;
-        }
-        oldParentType = state.parentType;
-        state.parentType = "paragraph";
-        for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
-          if (state.sCount[nextLine] - state.blkIndent > 3) {
-            continue;
-          }
-          if (state.sCount[nextLine] >= state.blkIndent) {
-            pos = state.bMarks[nextLine] + state.tShift[nextLine];
-            max = state.eMarks[nextLine];
-            if (pos < max) {
-              marker2 = state.src.charCodeAt(pos);
-              if (marker2 === 45 || marker2 === 61) {
-                pos = state.skipChars(pos, marker2);
-                pos = state.skipSpaces(pos);
-                if (pos >= max) {
-                  level = marker2 === 61 ? 1 : 2;
-                  break;
-                }
-              }
-            }
-          }
-          if (state.sCount[nextLine] < 0) {
-            continue;
-          }
-          terminate = false;
-          for (i = 0, l2 = terminatorRules.length; i < l2; i++) {
-            if (terminatorRules[i](state, nextLine, endLine, true)) {
-              terminate = true;
-              break;
-            }
-          }
-          if (terminate) {
-            break;
-          }
-        }
-        if (!level) {
-          return false;
-        }
-        content = state
-          .getLines(startLine, nextLine, state.blkIndent, false)
-          .trim();
-        state.line = nextLine + 1;
-        token2 = state.push("heading_open", "h" + String(level), 1);
-        token2.markup = String.fromCharCode(marker2);
-        token2.map = [startLine, state.line];
-        token2 = state.push("inline", "", 0);
-        token2.content = content;
-        token2.map = [startLine, state.line - 1];
-        token2.children = [];
-        token2 = state.push("heading_close", "h" + String(level), -1);
-        token2.markup = String.fromCharCode(marker2);
-        state.parentType = oldParentType;
-        return true;
-      };
-      var paragraph = function paragraph2(state, startLine) {
-        var content,
-          terminate,
-          i,
-          l2,
-          token2,
-          oldParentType,
-          nextLine = startLine + 1,
-          terminatorRules = state.md.block.ruler.getRules("paragraph"),
-          endLine = state.lineMax;
-        oldParentType = state.parentType;
-        state.parentType = "paragraph";
-        for (; nextLine < endLine && !state.isEmpty(nextLine); nextLine++) {
-          if (state.sCount[nextLine] - state.blkIndent > 3) {
-            continue;
-          }
-          if (state.sCount[nextLine] < 0) {
-            continue;
-          }
-          terminate = false;
-          for (i = 0, l2 = terminatorRules.length; i < l2; i++) {
-            if (terminatorRules[i](state, nextLine, endLine, true)) {
-              terminate = true;
-              break;
-            }
-          }
-          if (terminate) {
-            break;
-          }
-        }
-        content = state
-          .getLines(startLine, nextLine, state.blkIndent, false)
-          .trim();
-        state.line = nextLine;
-        token2 = state.push("paragraph_open", "p", 1);
-        token2.map = [startLine, state.line];
-        token2 = state.push("inline", "", 0);
-        token2.content = content;
-        token2.map = [startLine, state.line];
-        token2.children = [];
-        token2 = state.push("paragraph_close", "p", -1);
-        state.parentType = oldParentType;
-        return true;
-      };
-      var Token$1 = token;
-      var isSpace$4 = utils$1.isSpace;
-      function StateBlock(src, md2, env, tokens) {
-        var ch2, s, start2, pos, len, indent2, offset, indent_found;
-        this.src = src;
-        this.md = md2;
-        this.env = env;
-        this.tokens = tokens;
-        this.bMarks = [];
-        this.eMarks = [];
-        this.tShift = [];
-        this.sCount = [];
-        this.bsCount = [];
-        this.blkIndent = 0;
-        this.line = 0;
-        this.lineMax = 0;
-        this.tight = false;
-        this.ddIndent = -1;
-        this.listIndent = -1;
-        this.parentType = "root";
-        this.level = 0;
-        this.result = "";
-        s = this.src;
-        indent_found = false;
-        for (
-          start2 = pos = indent2 = offset = 0, len = s.length;
-          pos < len;
-          pos++
-        ) {
-          ch2 = s.charCodeAt(pos);
-          if (!indent_found) {
-            if (isSpace$4(ch2)) {
-              indent2++;
-              if (ch2 === 9) {
-                offset += 4 - (offset % 4);
-              } else {
-                offset++;
-              }
-              continue;
-            } else {
-              indent_found = true;
-            }
-          }
-          if (ch2 === 10 || pos === len - 1) {
-            if (ch2 !== 10) {
-              pos++;
-            }
-            this.bMarks.push(start2);
-            this.eMarks.push(pos);
-            this.tShift.push(indent2);
-            this.sCount.push(offset);
-            this.bsCount.push(0);
-            indent_found = false;
-            indent2 = 0;
-            offset = 0;
-            start2 = pos + 1;
-          }
-        }
-        this.bMarks.push(s.length);
-        this.eMarks.push(s.length);
-        this.tShift.push(0);
-        this.sCount.push(0);
-        this.bsCount.push(0);
-        this.lineMax = this.bMarks.length - 1;
-      }
-      StateBlock.prototype.push = function (type2, tag, nesting) {
-        var token2 = new Token$1(type2, tag, nesting);
-        token2.block = true;
-        if (nesting < 0) this.level--;
-        token2.level = this.level;
-        if (nesting > 0) this.level++;
-        this.tokens.push(token2);
-        return token2;
-      };
-      StateBlock.prototype.isEmpty = function isEmpty(line) {
-        return this.bMarks[line] + this.tShift[line] >= this.eMarks[line];
-      };
-      StateBlock.prototype.skipEmptyLines = function skipEmptyLines(from) {
-        for (var max = this.lineMax; from < max; from++) {
-          if (this.bMarks[from] + this.tShift[from] < this.eMarks[from]) {
-            break;
-          }
-        }
-        return from;
-      };
-      StateBlock.prototype.skipSpaces = function skipSpaces(pos) {
-        var ch2;
-        for (var max = this.src.length; pos < max; pos++) {
-          ch2 = this.src.charCodeAt(pos);
-          if (!isSpace$4(ch2)) {
-            break;
-          }
-        }
-        return pos;
-      };
-      StateBlock.prototype.skipSpacesBack = function skipSpacesBack(pos, min) {
-        if (pos <= min) {
-          return pos;
-        }
-        while (pos > min) {
-          if (!isSpace$4(this.src.charCodeAt(--pos))) {
-            return pos + 1;
-          }
-        }
-        return pos;
-      };
-      StateBlock.prototype.skipChars = function skipChars(pos, code3) {
-        for (var max = this.src.length; pos < max; pos++) {
-          if (this.src.charCodeAt(pos) !== code3) {
-            break;
-          }
-        }
-        return pos;
-      };
-      StateBlock.prototype.skipCharsBack = function skipCharsBack(
-        pos,
-        code3,
-        min
-      ) {
-        if (pos <= min) {
-          return pos;
-        }
-        while (pos > min) {
-          if (code3 !== this.src.charCodeAt(--pos)) {
-            return pos + 1;
-          }
-        }
-        return pos;
-      };
-      StateBlock.prototype.getLines = function getLines(
-        begin,
-        end2,
-        indent2,
-        keepLastLF
-      ) {
-        var i,
-          lineIndent,
-          ch2,
-          first,
-          last,
-          queue,
-          lineStart,
-          line = begin;
-        if (begin >= end2) {
-          return "";
-        }
-        queue = new Array(end2 - begin);
-        for (i = 0; line < end2; line++, i++) {
-          lineIndent = 0;
-          lineStart = first = this.bMarks[line];
-          if (line + 1 < end2 || keepLastLF) {
-            last = this.eMarks[line] + 1;
-          } else {
-            last = this.eMarks[line];
-          }
-          while (first < last && lineIndent < indent2) {
-            ch2 = this.src.charCodeAt(first);
-            if (isSpace$4(ch2)) {
-              if (ch2 === 9) {
-                lineIndent += 4 - ((lineIndent + this.bsCount[line]) % 4);
-              } else {
-                lineIndent++;
-              }
-            } else if (first - lineStart < this.tShift[line]) {
-              lineIndent++;
-            } else {
-              break;
-            }
-            first++;
-          }
-          if (lineIndent > indent2) {
-            queue[i] =
-              new Array(lineIndent - indent2 + 1).join(" ") +
-              this.src.slice(first, last);
-          } else {
-            queue[i] = this.src.slice(first, last);
-          }
-        }
-        return queue.join("");
-      };
-      StateBlock.prototype.Token = Token$1;
-      var state_block = StateBlock;
-      var Ruler$1 = ruler;
-      var _rules$1 = [
-        ["table", table, ["paragraph", "reference"]],
-        ["code", code$2],
-        ["fence", fence, ["paragraph", "reference", "blockquote", "list"]],
-        [
-          "blockquote",
-          blockquote,
-          ["paragraph", "reference", "blockquote", "list"],
-        ],
-        ["hr", hr, ["paragraph", "reference", "blockquote", "list"]],
-        ["list", list, ["paragraph", "reference", "blockquote"]],
-        ["reference", reference],
-        ["html_block", html_block, ["paragraph", "reference", "blockquote"]],
-        ["heading", heading, ["paragraph", "reference", "blockquote"]],
-        ["lheading", lheading],
-        ["paragraph", paragraph],
-      ];
-      function ParserBlock$1() {
-        this.ruler = new Ruler$1();
-        for (var i = 0; i < _rules$1.length; i++) {
-          this.ruler.push(_rules$1[i][0], _rules$1[i][1], {
-            alt: (_rules$1[i][2] || []).slice(),
-          });
-        }
-      }
-      ParserBlock$1.prototype.tokenize = function (state, startLine, endLine) {
-        var ok2,
-          i,
-          rules = this.ruler.getRules(""),
-          len = rules.length,
-          line = startLine,
-          hasEmptyLines = false,
-          maxNesting = state.md.options.maxNesting;
-        while (line < endLine) {
-          state.line = line = state.skipEmptyLines(line);
-          if (line >= endLine) {
-            break;
-          }
-          if (state.sCount[line] < state.blkIndent) {
-            break;
-          }
-          if (state.level >= maxNesting) {
-            state.line = endLine;
-            break;
-          }
-          for (i = 0; i < len; i++) {
-            ok2 = rules[i](state, line, endLine, false);
-            if (ok2) {
-              break;
-            }
-          }
-          state.tight = !hasEmptyLines;
-          if (state.isEmpty(state.line - 1)) {
-            hasEmptyLines = true;
-          }
-          line = state.line;
-          if (line < endLine && state.isEmpty(line)) {
-            hasEmptyLines = true;
-            line++;
-            state.line = line;
-          }
-        }
-      };
-      ParserBlock$1.prototype.parse = function (src, md2, env, outTokens) {
-        var state;
-        if (!src) {
-          return;
-        }
-        state = new this.State(src, md2, env, outTokens);
-        this.tokenize(state, state.line, state.lineMax);
-      };
-      ParserBlock$1.prototype.State = state_block;
-      var parser_block = ParserBlock$1;
-      function isTerminatorChar(ch2) {
-        switch (ch2) {
-          case 10:
-          case 33:
-          case 35:
-          case 36:
-          case 37:
-          case 38:
-          case 42:
-          case 43:
-          case 45:
-          case 58:
-          case 60:
-          case 61:
-          case 62:
-          case 64:
-          case 91:
-          case 92:
-          case 93:
-          case 94:
-          case 95:
-          case 96:
-          case 123:
-          case 125:
-          case 126:
-            return true;
-          default:
-            return false;
-        }
-      }
-      var text$1 = function text(state, silent) {
-        var pos = state.pos;
-        while (
-          pos < state.posMax &&
-          !isTerminatorChar(state.src.charCodeAt(pos))
-        ) {
-          pos++;
-        }
-        if (pos === state.pos) {
-          return false;
-        }
-        if (!silent) {
-          state.pending += state.src.slice(state.pos, pos);
-        }
-        state.pos = pos;
-        return true;
-      };
-      var isSpace$3 = utils$1.isSpace;
-      var newline = function newline2(state, silent) {
-        var pmax,
-          max,
-          ws2,
-          pos = state.pos;
-        if (state.src.charCodeAt(pos) !== 10) {
-          return false;
-        }
-        pmax = state.pending.length - 1;
-        max = state.posMax;
-        if (!silent) {
-          if (pmax >= 0 && state.pending.charCodeAt(pmax) === 32) {
-            if (pmax >= 1 && state.pending.charCodeAt(pmax - 1) === 32) {
-              ws2 = pmax - 1;
-              while (ws2 >= 1 && state.pending.charCodeAt(ws2 - 1) === 32)
-                ws2--;
-              state.pending = state.pending.slice(0, ws2);
-              state.push("hardbreak", "br", 0);
-            } else {
-              state.pending = state.pending.slice(0, -1);
-              state.push("softbreak", "br", 0);
-            }
-          } else {
-            state.push("softbreak", "br", 0);
-          }
-        }
-        pos++;
-        while (pos < max && isSpace$3(state.src.charCodeAt(pos))) {
-          pos++;
-        }
-        state.pos = pos;
-        return true;
-      };
-      var isSpace$2 = utils$1.isSpace;
-      var ESCAPED = [];
-      for (var i$1 = 0; i$1 < 256; i$1++) {
-        ESCAPED.push(0);
-      }
-      "\\!\"#$%&'()*+,./:;<=>?@[]^_`{|}~-".split("").forEach(function (ch2) {
-        ESCAPED[ch2.charCodeAt(0)] = 1;
-      });
-      var _escape = function escape2(state, silent) {
-        var ch2,
-          pos = state.pos,
-          max = state.posMax;
-        if (state.src.charCodeAt(pos) !== 92) {
-          return false;
-        }
-        pos++;
-        if (pos < max) {
-          ch2 = state.src.charCodeAt(pos);
-          if (ch2 < 256 && ESCAPED[ch2] !== 0) {
-            if (!silent) {
-              state.pending += state.src[pos];
-            }
-            state.pos += 2;
-            return true;
-          }
-          if (ch2 === 10) {
-            if (!silent) {
-              state.push("hardbreak", "br", 0);
-            }
-            pos++;
-            while (pos < max) {
-              ch2 = state.src.charCodeAt(pos);
-              if (!isSpace$2(ch2)) {
-                break;
-              }
-              pos++;
-            }
-            state.pos = pos;
-            return true;
-          }
-        }
-        if (!silent) {
-          state.pending += "\\";
-        }
-        state.pos++;
-        return true;
-      };
-      var backticks = function backtick(state, silent) {
-        var start2,
-          max,
-          marker2,
-          token2,
-          matchStart,
-          matchEnd,
-          openerLength,
-          closerLength,
-          pos = state.pos,
-          ch2 = state.src.charCodeAt(pos);
-        if (ch2 !== 96) {
-          return false;
-        }
-        start2 = pos;
-        pos++;
-        max = state.posMax;
-        while (pos < max && state.src.charCodeAt(pos) === 96) {
-          pos++;
-        }
-        marker2 = state.src.slice(start2, pos);
-        openerLength = marker2.length;
-        if (
-          state.backticksScanned &&
-          (state.backticks[openerLength] || 0) <= start2
-        ) {
-          if (!silent) state.pending += marker2;
-          state.pos += openerLength;
-          return true;
-        }
-        matchStart = matchEnd = pos;
-        while ((matchStart = state.src.indexOf("`", matchEnd)) !== -1) {
-          matchEnd = matchStart + 1;
-          while (matchEnd < max && state.src.charCodeAt(matchEnd) === 96) {
-            matchEnd++;
-          }
-          closerLength = matchEnd - matchStart;
-          if (closerLength === openerLength) {
-            if (!silent) {
-              token2 = state.push("code_inline", "code", 0);
-              token2.markup = marker2;
-              token2.content = state.src
-                .slice(pos, matchStart)
-                .replace(/\n/g, " ")
-                .replace(/^ (.+) $/, "$1");
-            }
-            state.pos = matchEnd;
-            return true;
-          }
-          state.backticks[closerLength] = matchStart;
-        }
-        state.backticksScanned = true;
-        if (!silent) state.pending += marker2;
-        state.pos += openerLength;
-        return true;
-      };
-      var strikethrough = {};
-      strikethrough.tokenize = function strikethrough2(state, silent) {
-        var i,
-          scanned,
-          token2,
-          len,
-          ch2,
-          start2 = state.pos,
-          marker2 = state.src.charCodeAt(start2);
-        if (silent) {
-          return false;
-        }
-        if (marker2 !== 126) {
-          return false;
-        }
-        scanned = state.scanDelims(state.pos, true);
-        len = scanned.length;
-        ch2 = String.fromCharCode(marker2);
-        if (len < 2) {
-          return false;
-        }
-        if (len % 2) {
-          token2 = state.push("text", "", 0);
-          token2.content = ch2;
-          len--;
-        }
-        for (i = 0; i < len; i += 2) {
-          token2 = state.push("text", "", 0);
-          token2.content = ch2 + ch2;
-          state.delimiters.push({
-            marker: marker2,
-            length: 0,
-            token: state.tokens.length - 1,
-            end: -1,
-            open: scanned.can_open,
-            close: scanned.can_close,
-          });
-        }
-        state.pos += scanned.length;
-        return true;
-      };
-      function postProcess$1(state, delimiters) {
-        var i,
-          j,
-          startDelim,
-          endDelim,
-          token2,
-          loneMarkers = [],
-          max = delimiters.length;
-        for (i = 0; i < max; i++) {
-          startDelim = delimiters[i];
-          if (startDelim.marker !== 126) {
-            continue;
-          }
-          if (startDelim.end === -1) {
-            continue;
-          }
-          endDelim = delimiters[startDelim.end];
-          token2 = state.tokens[startDelim.token];
-          token2.type = "s_open";
-          token2.tag = "s";
-          token2.nesting = 1;
-          token2.markup = "~~";
-          token2.content = "";
-          token2 = state.tokens[endDelim.token];
-          token2.type = "s_close";
-          token2.tag = "s";
-          token2.nesting = -1;
-          token2.markup = "~~";
-          token2.content = "";
-          if (
-            state.tokens[endDelim.token - 1].type === "text" &&
-            state.tokens[endDelim.token - 1].content === "~"
-          ) {
-            loneMarkers.push(endDelim.token - 1);
-          }
-        }
-        while (loneMarkers.length) {
-          i = loneMarkers.pop();
-          j = i + 1;
-          while (
-            j < state.tokens.length &&
-            state.tokens[j].type === "s_close"
-          ) {
-            j++;
-          }
-          j--;
-          if (i !== j) {
-            token2 = state.tokens[j];
-            state.tokens[j] = state.tokens[i];
-            state.tokens[i] = token2;
-          }
-        }
-      }
-      strikethrough.postProcess = function strikethrough3(state) {
-        var curr,
-          tokens_meta = state.tokens_meta,
-          max = state.tokens_meta.length;
-        postProcess$1(state, state.delimiters);
-        for (curr = 0; curr < max; curr++) {
-          if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
-            postProcess$1(state, tokens_meta[curr].delimiters);
-          }
-        }
-      };
-      var emphasis = {};
-      emphasis.tokenize = function emphasis2(state, silent) {
-        var i,
-          scanned,
-          token2,
-          start2 = state.pos,
-          marker2 = state.src.charCodeAt(start2);
-        if (silent) {
-          return false;
-        }
-        if (marker2 !== 95 && marker2 !== 42) {
-          return false;
-        }
-        scanned = state.scanDelims(state.pos, marker2 === 42);
-        for (i = 0; i < scanned.length; i++) {
-          token2 = state.push("text", "", 0);
-          token2.content = String.fromCharCode(marker2);
-          state.delimiters.push({
-            marker: marker2,
-            length: scanned.length,
-            token: state.tokens.length - 1,
-            end: -1,
-            open: scanned.can_open,
-            close: scanned.can_close,
-          });
-        }
-        state.pos += scanned.length;
-        return true;
-      };
-      function postProcess(state, delimiters) {
-        var i,
-          startDelim,
-          endDelim,
-          token2,
-          ch2,
-          isStrong,
-          max = delimiters.length;
-        for (i = max - 1; i >= 0; i--) {
-          startDelim = delimiters[i];
-          if (startDelim.marker !== 95 && startDelim.marker !== 42) {
-            continue;
-          }
-          if (startDelim.end === -1) {
-            continue;
-          }
-          endDelim = delimiters[startDelim.end];
-          isStrong =
-            i > 0 &&
-            delimiters[i - 1].end === startDelim.end + 1 &&
-            delimiters[i - 1].marker === startDelim.marker &&
-            delimiters[i - 1].token === startDelim.token - 1 &&
-            delimiters[startDelim.end + 1].token === endDelim.token + 1;
-          ch2 = String.fromCharCode(startDelim.marker);
-          token2 = state.tokens[startDelim.token];
-          token2.type = isStrong ? "strong_open" : "em_open";
-          token2.tag = isStrong ? "strong" : "em";
-          token2.nesting = 1;
-          token2.markup = isStrong ? ch2 + ch2 : ch2;
-          token2.content = "";
-          token2 = state.tokens[endDelim.token];
-          token2.type = isStrong ? "strong_close" : "em_close";
-          token2.tag = isStrong ? "strong" : "em";
-          token2.nesting = -1;
-          token2.markup = isStrong ? ch2 + ch2 : ch2;
-          token2.content = "";
-          if (isStrong) {
-            state.tokens[delimiters[i - 1].token].content = "";
-            state.tokens[delimiters[startDelim.end + 1].token].content = "";
-            i--;
-          }
-        }
-      }
-      emphasis.postProcess = function emphasis3(state) {
-        var curr,
-          tokens_meta = state.tokens_meta,
-          max = state.tokens_meta.length;
-        postProcess(state, state.delimiters);
-        for (curr = 0; curr < max; curr++) {
-          if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
-            postProcess(state, tokens_meta[curr].delimiters);
-          }
-        }
-      };
-      var normalizeReference$1 = utils$1.normalizeReference;
-      var isSpace$1 = utils$1.isSpace;
-      var link = function link2(state, silent) {
-        var attrs,
-          code3,
-          label,
-          labelEnd,
-          labelStart,
-          pos,
-          res,
-          ref,
-          token2,
-          href = "",
-          title = "",
-          oldPos = state.pos,
-          max = state.posMax,
-          start2 = state.pos,
-          parseReference = true;
-        if (state.src.charCodeAt(state.pos) !== 91) {
-          return false;
-        }
-        labelStart = state.pos + 1;
-        labelEnd = state.md.helpers.parseLinkLabel(state, state.pos, true);
-        if (labelEnd < 0) {
-          return false;
-        }
-        pos = labelEnd + 1;
-        if (pos < max && state.src.charCodeAt(pos) === 40) {
-          parseReference = false;
-          pos++;
-          for (; pos < max; pos++) {
-            code3 = state.src.charCodeAt(pos);
-            if (!isSpace$1(code3) && code3 !== 10) {
-              break;
-            }
-          }
-          if (pos >= max) {
-            return false;
-          }
-          start2 = pos;
-          res = state.md.helpers.parseLinkDestination(
-            state.src,
-            pos,
-            state.posMax
-          );
-          if (res.ok) {
-            href = state.md.normalizeLink(res.str);
-            if (state.md.validateLink(href)) {
-              pos = res.pos;
-            } else {
-              href = "";
-            }
-            start2 = pos;
-            for (; pos < max; pos++) {
-              code3 = state.src.charCodeAt(pos);
-              if (!isSpace$1(code3) && code3 !== 10) {
-                break;
-              }
-            }
-            res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
-            if (pos < max && start2 !== pos && res.ok) {
-              title = res.str;
-              pos = res.pos;
-              for (; pos < max; pos++) {
-                code3 = state.src.charCodeAt(pos);
-                if (!isSpace$1(code3) && code3 !== 10) {
-                  break;
-                }
-              }
-            }
-          }
-          if (pos >= max || state.src.charCodeAt(pos) !== 41) {
-            parseReference = true;
-          }
-          pos++;
-        }
-        if (parseReference) {
-          if (typeof state.env.references === "undefined") {
-            return false;
-          }
-          if (pos < max && state.src.charCodeAt(pos) === 91) {
-            start2 = pos + 1;
-            pos = state.md.helpers.parseLinkLabel(state, pos);
-            if (pos >= 0) {
-              label = state.src.slice(start2, pos++);
-            } else {
-              pos = labelEnd + 1;
-            }
-          } else {
-            pos = labelEnd + 1;
-          }
-          if (!label) {
-            label = state.src.slice(labelStart, labelEnd);
-          }
-          ref = state.env.references[normalizeReference$1(label)];
-          if (!ref) {
-            state.pos = oldPos;
-            return false;
-          }
-          href = ref.href;
-          title = ref.title;
-        }
-        if (!silent) {
-          state.pos = labelStart;
-          state.posMax = labelEnd;
-          token2 = state.push("link_open", "a", 1);
-          token2.attrs = attrs = [["href", href]];
-          if (title) {
-            attrs.push(["title", title]);
-          }
-          state.md.inline.tokenize(state);
-          token2 = state.push("link_close", "a", -1);
-        }
-        state.pos = pos;
-        state.posMax = max;
-        return true;
-      };
-      var normalizeReference = utils$1.normalizeReference;
-      var isSpace = utils$1.isSpace;
-      var image = function image2(state, silent) {
-        var attrs,
-          code3,
-          content,
-          label,
-          labelEnd,
-          labelStart,
-          pos,
-          ref,
-          res,
-          title,
-          token2,
-          tokens,
-          start2,
-          href = "",
-          oldPos = state.pos,
-          max = state.posMax;
-        if (state.src.charCodeAt(state.pos) !== 33) {
-          return false;
-        }
-        if (state.src.charCodeAt(state.pos + 1) !== 91) {
-          return false;
-        }
-        labelStart = state.pos + 2;
-        labelEnd = state.md.helpers.parseLinkLabel(state, state.pos + 1, false);
-        if (labelEnd < 0) {
-          return false;
-        }
-        pos = labelEnd + 1;
-        if (pos < max && state.src.charCodeAt(pos) === 40) {
-          pos++;
-          for (; pos < max; pos++) {
-            code3 = state.src.charCodeAt(pos);
-            if (!isSpace(code3) && code3 !== 10) {
-              break;
-            }
-          }
-          if (pos >= max) {
-            return false;
-          }
-          start2 = pos;
-          res = state.md.helpers.parseLinkDestination(
-            state.src,
-            pos,
-            state.posMax
-          );
-          if (res.ok) {
-            href = state.md.normalizeLink(res.str);
-            if (state.md.validateLink(href)) {
-              pos = res.pos;
-            } else {
-              href = "";
-            }
-          }
-          start2 = pos;
-          for (; pos < max; pos++) {
-            code3 = state.src.charCodeAt(pos);
-            if (!isSpace(code3) && code3 !== 10) {
-              break;
-            }
-          }
-          res = state.md.helpers.parseLinkTitle(state.src, pos, state.posMax);
-          if (pos < max && start2 !== pos && res.ok) {
-            title = res.str;
-            pos = res.pos;
-            for (; pos < max; pos++) {
-              code3 = state.src.charCodeAt(pos);
-              if (!isSpace(code3) && code3 !== 10) {
-                break;
-              }
-            }
-          } else {
-            title = "";
-          }
-          if (pos >= max || state.src.charCodeAt(pos) !== 41) {
-            state.pos = oldPos;
-            return false;
-          }
-          pos++;
-        } else {
-          if (typeof state.env.references === "undefined") {
-            return false;
-          }
-          if (pos < max && state.src.charCodeAt(pos) === 91) {
-            start2 = pos + 1;
-            pos = state.md.helpers.parseLinkLabel(state, pos);
-            if (pos >= 0) {
-              label = state.src.slice(start2, pos++);
-            } else {
-              pos = labelEnd + 1;
-            }
-          } else {
-            pos = labelEnd + 1;
-          }
-          if (!label) {
-            label = state.src.slice(labelStart, labelEnd);
-          }
-          ref = state.env.references[normalizeReference(label)];
-          if (!ref) {
-            state.pos = oldPos;
-            return false;
-          }
-          href = ref.href;
-          title = ref.title;
-        }
-        if (!silent) {
-          content = state.src.slice(labelStart, labelEnd);
-          state.md.inline.parse(content, state.md, state.env, (tokens = []));
-          token2 = state.push("image", "img", 0);
-          token2.attrs = attrs = [
-            ["src", href],
-            ["alt", ""],
-          ];
-          token2.children = tokens;
-          token2.content = content;
-          if (title) {
-            attrs.push(["title", title]);
-          }
-        }
-        state.pos = pos;
-        state.posMax = max;
-        return true;
-      };
-      var EMAIL_RE =
-        /^([a-zA-Z0-9.!#$%&'*+\/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)$/;
-      var AUTOLINK_RE = /^([a-zA-Z][a-zA-Z0-9+.\-]{1,31}):([^<>\x00-\x20]*)$/;
-      var autolink = function autolink2(state, silent) {
-        var url,
-          fullUrl,
-          token2,
-          ch2,
-          start2,
-          max,
-          pos = state.pos;
-        if (state.src.charCodeAt(pos) !== 60) {
-          return false;
-        }
-        start2 = state.pos;
-        max = state.posMax;
-        for (;;) {
-          if (++pos >= max) return false;
-          ch2 = state.src.charCodeAt(pos);
-          if (ch2 === 60) return false;
-          if (ch2 === 62) break;
-        }
-        url = state.src.slice(start2 + 1, pos);
-        if (AUTOLINK_RE.test(url)) {
-          fullUrl = state.md.normalizeLink(url);
-          if (!state.md.validateLink(fullUrl)) {
-            return false;
-          }
-          if (!silent) {
-            token2 = state.push("link_open", "a", 1);
-            token2.attrs = [["href", fullUrl]];
-            token2.markup = "autolink";
-            token2.info = "auto";
-            token2 = state.push("text", "", 0);
-            token2.content = state.md.normalizeLinkText(url);
-            token2 = state.push("link_close", "a", -1);
-            token2.markup = "autolink";
-            token2.info = "auto";
-          }
-          state.pos += url.length + 2;
-          return true;
-        }
-        if (EMAIL_RE.test(url)) {
-          fullUrl = state.md.normalizeLink("mailto:" + url);
-          if (!state.md.validateLink(fullUrl)) {
-            return false;
-          }
-          if (!silent) {
-            token2 = state.push("link_open", "a", 1);
-            token2.attrs = [["href", fullUrl]];
-            token2.markup = "autolink";
-            token2.info = "auto";
-            token2 = state.push("text", "", 0);
-            token2.content = state.md.normalizeLinkText(url);
-            token2 = state.push("link_close", "a", -1);
-            token2.markup = "autolink";
-            token2.info = "auto";
-          }
-          state.pos += url.length + 2;
-          return true;
-        }
-        return false;
-      };
-      var HTML_TAG_RE = html_re.HTML_TAG_RE;
-      function isLetter(ch2) {
-        var lc2 = ch2 | 32;
-        return lc2 >= 97 && lc2 <= 122;
-      }
-      var html_inline = function html_inline2(state, silent) {
-        var ch2,
-          match2,
-          max,
-          token2,
-          pos = state.pos;
-        if (!state.md.options.html) {
-          return false;
-        }
-        max = state.posMax;
-        if (state.src.charCodeAt(pos) !== 60 || pos + 2 >= max) {
-          return false;
-        }
-        ch2 = state.src.charCodeAt(pos + 1);
-        if (ch2 !== 33 && ch2 !== 63 && ch2 !== 47 && !isLetter(ch2)) {
-          return false;
-        }
-        match2 = state.src.slice(pos).match(HTML_TAG_RE);
-        if (!match2) {
-          return false;
-        }
-        if (!silent) {
-          token2 = state.push("html_inline", "", 0);
-          token2.content = state.src.slice(pos, pos + match2[0].length);
-        }
-        state.pos += match2[0].length;
-        return true;
-      };
-      var entities = entities$1;
-      var has = utils$1.has;
-      var isValidEntityCode = utils$1.isValidEntityCode;
-      var fromCodePoint = utils$1.fromCodePoint;
-      var DIGITAL_RE = /^&#((?:x[a-f0-9]{1,6}|[0-9]{1,7}));/i;
-      var NAMED_RE = /^&([a-z][a-z0-9]{1,31});/i;
-      var entity = function entity2(state, silent) {
-        var ch2,
-          code3,
-          match2,
-          pos = state.pos,
-          max = state.posMax;
-        if (state.src.charCodeAt(pos) !== 38) {
-          return false;
-        }
-        if (pos + 1 < max) {
-          ch2 = state.src.charCodeAt(pos + 1);
-          if (ch2 === 35) {
-            match2 = state.src.slice(pos).match(DIGITAL_RE);
-            if (match2) {
-              if (!silent) {
-                code3 =
-                  match2[1][0].toLowerCase() === "x"
-                    ? parseInt(match2[1].slice(1), 16)
-                    : parseInt(match2[1], 10);
-                state.pending += isValidEntityCode(code3)
-                  ? fromCodePoint(code3)
-                  : fromCodePoint(65533);
-              }
-              state.pos += match2[0].length;
-              return true;
-            }
-          } else {
-            match2 = state.src.slice(pos).match(NAMED_RE);
-            if (match2) {
-              if (has(entities, match2[1])) {
-                if (!silent) {
-                  state.pending += entities[match2[1]];
-                }
-                state.pos += match2[0].length;
-                return true;
-              }
-            }
-          }
-        }
-        if (!silent) {
-          state.pending += "&";
-        }
-        state.pos++;
-        return true;
-      };
-      function processDelimiters(state, delimiters) {
-        var closerIdx,
-          openerIdx,
-          closer,
-          opener,
-          minOpenerIdx,
-          newMinOpenerIdx,
-          isOddMatch,
-          lastJump,
-          openersBottom = {},
-          max = delimiters.length;
-        if (!max) return;
-        var headerIdx = 0;
-        var lastTokenIdx = -2;
-        var jumps = [];
-        for (closerIdx = 0; closerIdx < max; closerIdx++) {
-          closer = delimiters[closerIdx];
-          jumps.push(0);
-          if (
-            delimiters[headerIdx].marker !== closer.marker ||
-            lastTokenIdx !== closer.token - 1
-          ) {
-            headerIdx = closerIdx;
-          }
-          lastTokenIdx = closer.token;
-          closer.length = closer.length || 0;
-          if (!closer.close) continue;
-          if (!openersBottom.hasOwnProperty(closer.marker)) {
-            openersBottom[closer.marker] = [-1, -1, -1, -1, -1, -1];
-          }
-          minOpenerIdx =
-            openersBottom[closer.marker][
-              (closer.open ? 3 : 0) + (closer.length % 3)
-            ];
-          openerIdx = headerIdx - jumps[headerIdx] - 1;
-          newMinOpenerIdx = openerIdx;
-          for (; openerIdx > minOpenerIdx; openerIdx -= jumps[openerIdx] + 1) {
-            opener = delimiters[openerIdx];
-            if (opener.marker !== closer.marker) continue;
-            if (opener.open && opener.end < 0) {
-              isOddMatch = false;
-              if (opener.close || closer.open) {
-                if ((opener.length + closer.length) % 3 === 0) {
-                  if (opener.length % 3 !== 0 || closer.length % 3 !== 0) {
-                    isOddMatch = true;
-                  }
-                }
-              }
-              if (!isOddMatch) {
-                lastJump =
-                  openerIdx > 0 && !delimiters[openerIdx - 1].open
-                    ? jumps[openerIdx - 1] + 1
-                    : 0;
-                jumps[closerIdx] = closerIdx - openerIdx + lastJump;
-                jumps[openerIdx] = lastJump;
-                closer.open = false;
-                opener.end = closerIdx;
-                opener.close = false;
-                newMinOpenerIdx = -1;
-                lastTokenIdx = -2;
-                break;
-              }
-            }
-          }
-          if (newMinOpenerIdx !== -1) {
-            openersBottom[closer.marker][
-              (closer.open ? 3 : 0) + ((closer.length || 0) % 3)
-            ] = newMinOpenerIdx;
-          }
-        }
-      }
-      var balance_pairs = function link_pairs(state) {
-        var curr,
-          tokens_meta = state.tokens_meta,
-          max = state.tokens_meta.length;
-        processDelimiters(state, state.delimiters);
-        for (curr = 0; curr < max; curr++) {
-          if (tokens_meta[curr] && tokens_meta[curr].delimiters) {
-            processDelimiters(state, tokens_meta[curr].delimiters);
-          }
-        }
-      };
-      var text_collapse = function text_collapse2(state) {
-        var curr,
-          last,
-          level = 0,
-          tokens = state.tokens,
-          max = state.tokens.length;
-        for (curr = last = 0; curr < max; curr++) {
-          if (tokens[curr].nesting < 0) level--;
-          tokens[curr].level = level;
-          if (tokens[curr].nesting > 0) level++;
-          if (
-            tokens[curr].type === "text" &&
-            curr + 1 < max &&
-            tokens[curr + 1].type === "text"
-          ) {
-            tokens[curr + 1].content =
-              tokens[curr].content + tokens[curr + 1].content;
-          } else {
-            if (curr !== last) {
-              tokens[last] = tokens[curr];
-            }
-            last++;
-          }
-        }
-        if (curr !== last) {
-          tokens.length = last;
-        }
-      };
-      var Token = token;
-      var isWhiteSpace = utils$1.isWhiteSpace;
-      var isPunctChar = utils$1.isPunctChar;
-      var isMdAsciiPunct = utils$1.isMdAsciiPunct;
-      function StateInline(src, md2, env, outTokens) {
-        this.src = src;
-        this.env = env;
-        this.md = md2;
-        this.tokens = outTokens;
-        this.tokens_meta = Array(outTokens.length);
-        this.pos = 0;
-        this.posMax = this.src.length;
-        this.level = 0;
-        this.pending = "";
-        this.pendingLevel = 0;
-        this.cache = {};
-        this.delimiters = [];
-        this._prev_delimiters = [];
-        this.backticks = {};
-        this.backticksScanned = false;
-      }
-      StateInline.prototype.pushPending = function () {
-        var token2 = new Token("text", "", 0);
-        token2.content = this.pending;
-        token2.level = this.pendingLevel;
-        this.tokens.push(token2);
-        this.pending = "";
-        return token2;
-      };
-      StateInline.prototype.push = function (type2, tag, nesting) {
-        if (this.pending) {
-          this.pushPending();
-        }
-        var token2 = new Token(type2, tag, nesting);
-        var token_meta = null;
-        if (nesting < 0) {
-          this.level--;
-          this.delimiters = this._prev_delimiters.pop();
-        }
-        token2.level = this.level;
-        if (nesting > 0) {
-          this.level++;
-          this._prev_delimiters.push(this.delimiters);
-          this.delimiters = [];
-          token_meta = { delimiters: this.delimiters };
-        }
-        this.pendingLevel = this.level;
-        this.tokens.push(token2);
-        this.tokens_meta.push(token_meta);
-        return token2;
-      };
-      StateInline.prototype.scanDelims = function (start2, canSplitWord) {
-        var pos = start2,
-          lastChar,
-          nextChar,
-          count,
-          can_open,
-          can_close,
-          isLastWhiteSpace,
-          isLastPunctChar,
-          isNextWhiteSpace,
-          isNextPunctChar,
-          left_flanking = true,
-          right_flanking = true,
-          max = this.posMax,
-          marker2 = this.src.charCodeAt(start2);
-        lastChar = start2 > 0 ? this.src.charCodeAt(start2 - 1) : 32;
-        while (pos < max && this.src.charCodeAt(pos) === marker2) {
-          pos++;
-        }
-        count = pos - start2;
-        nextChar = pos < max ? this.src.charCodeAt(pos) : 32;
-        isLastPunctChar =
-          isMdAsciiPunct(lastChar) ||
-          isPunctChar(String.fromCharCode(lastChar));
-        isNextPunctChar =
-          isMdAsciiPunct(nextChar) ||
-          isPunctChar(String.fromCharCode(nextChar));
-        isLastWhiteSpace = isWhiteSpace(lastChar);
-        isNextWhiteSpace = isWhiteSpace(nextChar);
-        if (isNextWhiteSpace) {
-          left_flanking = false;
-        } else if (isNextPunctChar) {
-          if (!(isLastWhiteSpace || isLastPunctChar)) {
-            left_flanking = false;
-          }
-        }
-        if (isLastWhiteSpace) {
-          right_flanking = false;
-        } else if (isLastPunctChar) {
-          if (!(isNextWhiteSpace || isNextPunctChar)) {
-            right_flanking = false;
-          }
-        }
-        if (!canSplitWord) {
-          can_open = left_flanking && (!right_flanking || isLastPunctChar);
-          can_close = right_flanking && (!left_flanking || isNextPunctChar);
-        } else {
-          can_open = left_flanking;
-          can_close = right_flanking;
-        }
-        return {
-          can_open,
-          can_close,
-          length: count,
-        };
-      };
-      StateInline.prototype.Token = Token;
-      var state_inline = StateInline;
-      var Ruler = ruler;
-      var _rules = [
-        ["text", text$1],
-        ["newline", newline],
-        ["escape", _escape],
-        ["backticks", backticks],
-        ["strikethrough", strikethrough.tokenize],
-        ["emphasis", emphasis.tokenize],
-        ["link", link],
-        ["image", image],
-        ["autolink", autolink],
-        ["html_inline", html_inline],
-        ["entity", entity],
-      ];
-      var _rules2 = [
-        ["balance_pairs", balance_pairs],
-        ["strikethrough", strikethrough.postProcess],
-        ["emphasis", emphasis.postProcess],
-        ["text_collapse", text_collapse],
-      ];
-      function ParserInline$1() {
-        var i;
-        this.ruler = new Ruler();
-        for (i = 0; i < _rules.length; i++) {
-          this.ruler.push(_rules[i][0], _rules[i][1]);
-        }
-        this.ruler2 = new Ruler();
-        for (i = 0; i < _rules2.length; i++) {
-          this.ruler2.push(_rules2[i][0], _rules2[i][1]);
-        }
-      }
-      ParserInline$1.prototype.skipToken = function (state) {
-        var ok2,
-          i,
-          pos = state.pos,
-          rules = this.ruler.getRules(""),
-          len = rules.length,
-          maxNesting = state.md.options.maxNesting,
-          cache = state.cache;
-        if (typeof cache[pos] !== "undefined") {
-          state.pos = cache[pos];
-          return;
-        }
-        if (state.level < maxNesting) {
-          for (i = 0; i < len; i++) {
-            state.level++;
-            ok2 = rules[i](state, true);
-            state.level--;
-            if (ok2) {
-              break;
-            }
-          }
-        } else {
-          state.pos = state.posMax;
-        }
-        if (!ok2) {
-          state.pos++;
-        }
-        cache[pos] = state.pos;
-      };
-      ParserInline$1.prototype.tokenize = function (state) {
-        var ok2,
-          i,
-          rules = this.ruler.getRules(""),
-          len = rules.length,
-          end2 = state.posMax,
-          maxNesting = state.md.options.maxNesting;
-        while (state.pos < end2) {
-          if (state.level < maxNesting) {
-            for (i = 0; i < len; i++) {
-              ok2 = rules[i](state, false);
-              if (ok2) {
-                break;
-              }
-            }
-          }
-          if (ok2) {
-            if (state.pos >= end2) {
-              break;
-            }
-            continue;
-          }
-          state.pending += state.src[state.pos++];
-        }
-        if (state.pending) {
-          state.pushPending();
-        }
-      };
-      ParserInline$1.prototype.parse = function (str, md2, env, outTokens) {
-        var i, rules, len;
-        var state = new this.State(str, md2, env, outTokens);
-        this.tokenize(state);
-        rules = this.ruler2.getRules("");
-        len = rules.length;
-        for (i = 0; i < len; i++) {
-          rules[i](state);
-        }
-      };
-      ParserInline$1.prototype.State = state_inline;
-      var parser_inline = ParserInline$1;
-      var re = function (opts) {
-        var re2 = {};
-        re2.src_Any = regex$3.source;
-        re2.src_Cc = regex$2.source;
-        re2.src_Z = regex.source;
-        re2.src_P = regex$4.source;
-        re2.src_ZPCc = [re2.src_Z, re2.src_P, re2.src_Cc].join("|");
-        re2.src_ZCc = [re2.src_Z, re2.src_Cc].join("|");
-        var text_separators = "[><\uFF5C]";
-        re2.src_pseudo_letter =
-          "(?:(?!" +
-          text_separators +
-          "|" +
-          re2.src_ZPCc +
-          ")" +
-          re2.src_Any +
-          ")";
-        re2.src_ip4 =
-          "(?:(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)";
-        re2.src_auth = "(?:(?:(?!" + re2.src_ZCc + "|[@/\\[\\]()]).)+@)?";
-        re2.src_port =
-          "(?::(?:6(?:[0-4]\\d{3}|5(?:[0-4]\\d{2}|5(?:[0-2]\\d|3[0-5])))|[1-5]?\\d{1,4}))?";
-        re2.src_host_terminator =
-          "(?=$|" +
-          text_separators +
-          "|" +
-          re2.src_ZPCc +
-          ")(?!-|_|:\\d|\\.-|\\.(?!$|" +
-          re2.src_ZPCc +
-          "))";
-        re2.src_path =
-          "(?:[/?#](?:(?!" +
-          re2.src_ZCc +
-          "|" +
-          text_separators +
-          `|[()[\\]{}.,"'?!\\-;]).|\\[(?:(?!` +
-          re2.src_ZCc +
-          "|\\]).)*\\]|\\((?:(?!" +
-          re2.src_ZCc +
-          "|[)]).)*\\)|\\{(?:(?!" +
-          re2.src_ZCc +
-          '|[}]).)*\\}|\\"(?:(?!' +
-          re2.src_ZCc +
-          `|["]).)+\\"|\\'(?:(?!` +
-          re2.src_ZCc +
-          "|[']).)+\\'|\\'(?=" +
-          re2.src_pseudo_letter +
-          "|[-]).|\\.{2,}[a-zA-Z0-9%/&]|\\.(?!" +
-          re2.src_ZCc +
-          "|[.]).|" +
-          (opts && opts["---"] ? "\\-(?!--(?:[^-]|$))(?:-*)|" : "\\-+|") +
-          ",(?!" +
-          re2.src_ZCc +
-          ").|;(?!" +
-          re2.src_ZCc +
-          ").|\\!+(?!" +
-          re2.src_ZCc +
-          "|[!]).|\\?(?!" +
-          re2.src_ZCc +
-          "|[?]).)+|\\/)?";
-        re2.src_email_name =
-          '[\\-;:&=\\+\\$,\\.a-zA-Z0-9_][\\-;:&=\\+\\$,\\"\\.a-zA-Z0-9_]*';
-        re2.src_xn = "xn--[a-z0-9\\-]{1,59}";
-        re2.src_domain_root =
-          "(?:" + re2.src_xn + "|" + re2.src_pseudo_letter + "{1,63})";
-        re2.src_domain =
-          "(?:" +
-          re2.src_xn +
-          "|(?:" +
-          re2.src_pseudo_letter +
-          ")|(?:" +
-          re2.src_pseudo_letter +
-          "(?:-|" +
-          re2.src_pseudo_letter +
-          "){0,61}" +
-          re2.src_pseudo_letter +
-          "))";
-        re2.src_host =
-          "(?:(?:(?:(?:" + re2.src_domain + ")\\.)*" + re2.src_domain + "))";
-        re2.tpl_host_fuzzy =
-          "(?:" +
-          re2.src_ip4 +
-          "|(?:(?:(?:" +
-          re2.src_domain +
-          ")\\.)+(?:%TLDS%)))";
-        re2.tpl_host_no_ip_fuzzy =
-          "(?:(?:(?:" + re2.src_domain + ")\\.)+(?:%TLDS%))";
-        re2.src_host_strict = re2.src_host + re2.src_host_terminator;
-        re2.tpl_host_fuzzy_strict =
-          re2.tpl_host_fuzzy + re2.src_host_terminator;
-        re2.src_host_port_strict =
-          re2.src_host + re2.src_port + re2.src_host_terminator;
-        re2.tpl_host_port_fuzzy_strict =
-          re2.tpl_host_fuzzy + re2.src_port + re2.src_host_terminator;
-        re2.tpl_host_port_no_ip_fuzzy_strict =
-          re2.tpl_host_no_ip_fuzzy + re2.src_port + re2.src_host_terminator;
-        re2.tpl_host_fuzzy_test =
-          "localhost|www\\.|\\.\\d{1,3}\\.|(?:\\.(?:%TLDS%)(?:" +
-          re2.src_ZPCc +
-          "|>|$))";
-        re2.tpl_email_fuzzy =
-          "(^|" +
-          text_separators +
-          '|"|\\(|' +
-          re2.src_ZCc +
-          ")(" +
-          re2.src_email_name +
-          "@" +
-          re2.tpl_host_fuzzy_strict +
-          ")";
-        re2.tpl_link_fuzzy =
-          "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" +
-          re2.src_ZPCc +
-          "))((?![$+<=>^`|\uFF5C])" +
-          re2.tpl_host_port_fuzzy_strict +
-          re2.src_path +
-          ")";
-        re2.tpl_link_no_ip_fuzzy =
-          "(^|(?![.:/\\-_@])(?:[$+<=>^`|\uFF5C]|" +
-          re2.src_ZPCc +
-          "))((?![$+<=>^`|\uFF5C])" +
-          re2.tpl_host_port_no_ip_fuzzy_strict +
-          re2.src_path +
-          ")";
-        return re2;
-      };
-      function assign(obj) {
-        var sources = Array.prototype.slice.call(arguments, 1);
-        sources.forEach(function (source) {
-          if (!source) {
-            return;
-          }
-          Object.keys(source).forEach(function (key) {
-            obj[key] = source[key];
-          });
-        });
-        return obj;
-      }
-      function _class(obj) {
-        return Object.prototype.toString.call(obj);
-      }
-      function isString$2(obj) {
-        return _class(obj) === "[object String]";
-      }
-      function isObject$6(obj) {
-        return _class(obj) === "[object Object]";
-      }
-      function isRegExp(obj) {
-        return _class(obj) === "[object RegExp]";
-      }
-      function isFunction(obj) {
-        return _class(obj) === "[object Function]";
-      }
-      function escapeRE(str) {
-        return str.replace(/[.?*+^$[\]\\(){}|-]/g, "\\$&");
-      }
-      var defaultOptions = {
-        fuzzyLink: true,
-        fuzzyEmail: true,
-        fuzzyIP: false,
-      };
-      function isOptionsObj(obj) {
-        return Object.keys(obj || {}).reduce(function (acc, k) {
-          return acc || defaultOptions.hasOwnProperty(k);
-        }, false);
-      }
-      var defaultSchemas = {
-        "http:": {
-          validate: function (text3, pos, self2) {
-            var tail = text3.slice(pos);
-            if (!self2.re.http) {
-              self2.re.http = new RegExp(
-                "^\\/\\/" +
-                  self2.re.src_auth +
-                  self2.re.src_host_port_strict +
-                  self2.re.src_path,
-                "i"
-              );
-            }
-            if (self2.re.http.test(tail)) {
-              return tail.match(self2.re.http)[0].length;
-            }
-            return 0;
-          },
-        },
-        "https:": "http:",
-        "ftp:": "http:",
-        "//": {
-          validate: function (text3, pos, self2) {
-            var tail = text3.slice(pos);
-            if (!self2.re.no_http) {
-              self2.re.no_http = new RegExp(
-                "^" +
-                  self2.re.src_auth +
-                  "(?:localhost|(?:(?:" +
-                  self2.re.src_domain +
-                  ")\\.)+" +
-                  self2.re.src_domain_root +
-                  ")" +
-                  self2.re.src_port +
-                  self2.re.src_host_terminator +
-                  self2.re.src_path,
-                "i"
-              );
-            }
-            if (self2.re.no_http.test(tail)) {
-              if (pos >= 3 && text3[pos - 3] === ":") {
-                return 0;
-              }
-              if (pos >= 3 && text3[pos - 3] === "/") {
-                return 0;
-              }
-              return tail.match(self2.re.no_http)[0].length;
-            }
-            return 0;
-          },
-        },
-        "mailto:": {
-          validate: function (text3, pos, self2) {
-            var tail = text3.slice(pos);
-            if (!self2.re.mailto) {
-              self2.re.mailto = new RegExp(
-                "^" + self2.re.src_email_name + "@" + self2.re.src_host_strict,
-                "i"
-              );
-            }
-            if (self2.re.mailto.test(tail)) {
-              return tail.match(self2.re.mailto)[0].length;
-            }
-            return 0;
-          },
-        },
-      };
-      var tlds_2ch_src_re =
-        "a[cdefgilmnoqrstuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrstuvwxyz]|n[acefgilopruz]|om|p[aefghklmnrstwy]|qa|r[eosuw]|s[abcdeghijklmnortuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]";
-      var tlds_default =
-        "biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|\u0440\u0444".split(
-          "|"
-        );
-      function resetScanCache(self2) {
-        self2.__index__ = -1;
-        self2.__text_cache__ = "";
-      }
-      function createValidator(re2) {
-        return function (text3, pos) {
-          var tail = text3.slice(pos);
-          if (re2.test(tail)) {
-            return tail.match(re2)[0].length;
-          }
-          return 0;
-        };
-      }
-      function createNormalizer() {
-        return function (match2, self2) {
-          self2.normalize(match2);
-        };
-      }
-      function compile(self2) {
-        var re$12 = (self2.re = re(self2.__opts__));
-        var tlds2 = self2.__tlds__.slice();
-        self2.onCompile();
-        if (!self2.__tlds_replaced__) {
-          tlds2.push(tlds_2ch_src_re);
-        }
-        tlds2.push(re$12.src_xn);
-        re$12.src_tlds = tlds2.join("|");
-        function untpl(tpl) {
-          return tpl.replace("%TLDS%", re$12.src_tlds);
-        }
-        re$12.email_fuzzy = RegExp(untpl(re$12.tpl_email_fuzzy), "i");
-        re$12.link_fuzzy = RegExp(untpl(re$12.tpl_link_fuzzy), "i");
-        re$12.link_no_ip_fuzzy = RegExp(untpl(re$12.tpl_link_no_ip_fuzzy), "i");
-        re$12.host_fuzzy_test = RegExp(untpl(re$12.tpl_host_fuzzy_test), "i");
-        var aliases = [];
-        self2.__compiled__ = {};
-        function schemaError(name2, val) {
-          throw new Error('(LinkifyIt) Invalid schema "' + name2 + '": ' + val);
-        }
-        Object.keys(self2.__schemas__).forEach(function (name2) {
-          var val = self2.__schemas__[name2];
-          if (val === null) {
-            return;
-          }
-          var compiled = { validate: null, link: null };
-          self2.__compiled__[name2] = compiled;
-          if (isObject$6(val)) {
-            if (isRegExp(val.validate)) {
-              compiled.validate = createValidator(val.validate);
-            } else if (isFunction(val.validate)) {
-              compiled.validate = val.validate;
-            } else {
-              schemaError(name2, val);
-            }
-            if (isFunction(val.normalize)) {
-              compiled.normalize = val.normalize;
-            } else if (!val.normalize) {
-              compiled.normalize = createNormalizer();
-            } else {
-              schemaError(name2, val);
-            }
-            return;
-          }
-          if (isString$2(val)) {
-            aliases.push(name2);
-            return;
-          }
-          schemaError(name2, val);
-        });
-        aliases.forEach(function (alias) {
-          if (!self2.__compiled__[self2.__schemas__[alias]]) {
-            return;
-          }
-          self2.__compiled__[alias].validate =
-            self2.__compiled__[self2.__schemas__[alias]].validate;
-          self2.__compiled__[alias].normalize =
-            self2.__compiled__[self2.__schemas__[alias]].normalize;
-        });
-        self2.__compiled__[""] = {
-          validate: null,
-          normalize: createNormalizer(),
-        };
-        var slist = Object.keys(self2.__compiled__)
-          .filter(function (name2) {
-            return name2.length > 0 && self2.__compiled__[name2];
-          })
-          .map(escapeRE)
-          .join("|");
-        self2.re.schema_test = RegExp(
-          "(^|(?!_)(?:[><\uFF5C]|" + re$12.src_ZPCc + "))(" + slist + ")",
-          "i"
-        );
-        self2.re.schema_search = RegExp(
-          "(^|(?!_)(?:[><\uFF5C]|" + re$12.src_ZPCc + "))(" + slist + ")",
-          "ig"
-        );
-        self2.re.pretest = RegExp(
-          "(" +
-            self2.re.schema_test.source +
-            ")|(" +
-            self2.re.host_fuzzy_test.source +
-            ")|@",
-          "i"
-        );
-        resetScanCache(self2);
-      }
-      function Match(self2, shift) {
-        var start2 = self2.__index__,
-          end2 = self2.__last_index__,
-          text3 = self2.__text_cache__.slice(start2, end2);
-        this.schema = self2.__schema__.toLowerCase();
-        this.index = start2 + shift;
-        this.lastIndex = end2 + shift;
-        this.raw = text3;
-        this.text = text3;
-        this.url = text3;
-      }
-      function createMatch(self2, shift) {
-        var match2 = new Match(self2, shift);
-        self2.__compiled__[match2.schema].normalize(match2, self2);
-        return match2;
-      }
-      function LinkifyIt$1(schemas, options) {
-        if (!(this instanceof LinkifyIt$1)) {
-          return new LinkifyIt$1(schemas, options);
-        }
-        if (!options) {
-          if (isOptionsObj(schemas)) {
-            options = schemas;
-            schemas = {};
-          }
-        }
-        this.__opts__ = assign({}, defaultOptions, options);
-        this.__index__ = -1;
-        this.__last_index__ = -1;
-        this.__schema__ = "";
-        this.__text_cache__ = "";
-        this.__schemas__ = assign({}, defaultSchemas, schemas);
-        this.__compiled__ = {};
-        this.__tlds__ = tlds_default;
-        this.__tlds_replaced__ = false;
-        this.re = {};
-        compile(this);
-      }
-      LinkifyIt$1.prototype.add = function add(schema, definition) {
-        this.__schemas__[schema] = definition;
-        compile(this);
-        return this;
-      };
-      LinkifyIt$1.prototype.set = function set(options) {
-        this.__opts__ = assign(this.__opts__, options);
-        return this;
-      };
-      LinkifyIt$1.prototype.test = function test(text3) {
-        this.__text_cache__ = text3;
-        this.__index__ = -1;
-        if (!text3.length) {
-          return false;
-        }
-        var m, ml, me2, len, shift, next, re2, tld_pos, at_pos;
-        if (this.re.schema_test.test(text3)) {
-          re2 = this.re.schema_search;
-          re2.lastIndex = 0;
-          while ((m = re2.exec(text3)) !== null) {
-            len = this.testSchemaAt(text3, m[2], re2.lastIndex);
-            if (len) {
-              this.__schema__ = m[2];
-              this.__index__ = m.index + m[1].length;
-              this.__last_index__ = m.index + m[0].length + len;
-              break;
-            }
-          }
-        }
-        if (this.__opts__.fuzzyLink && this.__compiled__["http:"]) {
-          tld_pos = text3.search(this.re.host_fuzzy_test);
-          if (tld_pos >= 0) {
-            if (this.__index__ < 0 || tld_pos < this.__index__) {
-              if (
-                (ml = text3.match(
-                  this.__opts__.fuzzyIP
-                    ? this.re.link_fuzzy
-                    : this.re.link_no_ip_fuzzy
-                )) !== null
-              ) {
-                shift = ml.index + ml[1].length;
-                if (this.__index__ < 0 || shift < this.__index__) {
-                  this.__schema__ = "";
-                  this.__index__ = shift;
-                  this.__last_index__ = ml.index + ml[0].length;
-                }
-              }
-            }
-          }
-        }
-        if (this.__opts__.fuzzyEmail && this.__compiled__["mailto:"]) {
-          at_pos = text3.indexOf("@");
-          if (at_pos >= 0) {
-            if ((me2 = text3.match(this.re.email_fuzzy)) !== null) {
-              shift = me2.index + me2[1].length;
-              next = me2.index + me2[0].length;
-              if (
-                this.__index__ < 0 ||
-                shift < this.__index__ ||
-                (shift === this.__index__ && next > this.__last_index__)
-              ) {
-                this.__schema__ = "mailto:";
-                this.__index__ = shift;
-                this.__last_index__ = next;
-              }
-            }
-          }
-        }
-        return this.__index__ >= 0;
-      };
-      LinkifyIt$1.prototype.pretest = function pretest(text3) {
-        return this.re.pretest.test(text3);
-      };
-      LinkifyIt$1.prototype.testSchemaAt = function testSchemaAt(
-        text3,
-        schema,
-        pos
-      ) {
-        if (!this.__compiled__[schema.toLowerCase()]) {
-          return 0;
-        }
-        return this.__compiled__[schema.toLowerCase()].validate(
-          text3,
-          pos,
-          this
-        );
-      };
-      LinkifyIt$1.prototype.match = function match(text3) {
-        var shift = 0,
-          result2 = [];
-        if (this.__index__ >= 0 && this.__text_cache__ === text3) {
-          result2.push(createMatch(this, shift));
-          shift = this.__last_index__;
-        }
-        var tail = shift ? text3.slice(shift) : text3;
-        while (this.test(tail)) {
-          result2.push(createMatch(this, shift));
-          tail = tail.slice(this.__last_index__);
-          shift += this.__last_index__;
-        }
-        if (result2.length) {
-          return result2;
-        }
-        return null;
-      };
-      LinkifyIt$1.prototype.tlds = function tlds(list3, keepOld) {
-        list3 = Array.isArray(list3) ? list3 : [list3];
-        if (!keepOld) {
-          this.__tlds__ = list3.slice();
-          this.__tlds_replaced__ = true;
-          compile(this);
-          return this;
-        }
-        this.__tlds__ = this.__tlds__
-          .concat(list3)
-          .sort()
-          .filter(function (el2, idx, arr) {
-            return el2 !== arr[idx - 1];
-          })
-          .reverse();
-        compile(this);
-        return this;
-      };
-      LinkifyIt$1.prototype.normalize = function normalize3(match2) {
-        if (!match2.schema) {
-          match2.url = "http://" + match2.url;
-        }
-        if (match2.schema === "mailto:" && !/^mailto:/i.test(match2.url)) {
-          match2.url = "mailto:" + match2.url;
-        }
-      };
-      LinkifyIt$1.prototype.onCompile = function onCompile() {};
-      var linkifyIt = LinkifyIt$1;
-      const maxInt = 2147483647;
-      const base = 36;
-      const tMin = 1;
-      const tMax = 26;
-      const skew = 38;
-      const damp = 700;
-      const initialBias = 72;
-      const initialN = 128;
-      const delimiter = "-";
-      const regexPunycode = /^xn--/;
-      const regexNonASCII = /[^\0-\x7E]/;
-      const regexSeparators = /[\x2E\u3002\uFF0E\uFF61]/g;
-      const errors = {
-        overflow: "Overflow: input needs wider integers to process",
-        "not-basic": "Illegal input >= 0x80 (not a basic code point)",
-        "invalid-input": "Invalid input",
-      };
-      const baseMinusTMin = base - tMin;
-      const floor = Math.floor;
-      const stringFromCharCode = String.fromCharCode;
-      function error(type2) {
-        throw new RangeError(errors[type2]);
-      }
-      function map(array, fn) {
-        const result2 = [];
-        let length = array.length;
-        while (length--) {
-          result2[length] = fn(array[length]);
-        }
-        return result2;
-      }
-      function mapDomain(string2, fn) {
-        const parts = string2.split("@");
-        let result2 = "";
-        if (parts.length > 1) {
-          result2 = parts[0] + "@";
-          string2 = parts[1];
-        }
-        string2 = string2.replace(regexSeparators, ".");
-        const labels = string2.split(".");
-        const encoded = map(labels, fn).join(".");
-        return result2 + encoded;
-      }
-      function ucs2decode(string2) {
-        const output = [];
-        let counter = 0;
-        const length = string2.length;
-        while (counter < length) {
-          const value = string2.charCodeAt(counter++);
-          if (value >= 55296 && value <= 56319 && counter < length) {
-            const extra = string2.charCodeAt(counter++);
-            if ((extra & 64512) == 56320) {
-              output.push(((value & 1023) << 10) + (extra & 1023) + 65536);
-            } else {
-              output.push(value);
-              counter--;
-            }
-          } else {
-            output.push(value);
-          }
-        }
-        return output;
-      }
-      const ucs2encode = (array) => String.fromCodePoint(...array);
-      const basicToDigit = function (codePoint) {
-        if (codePoint - 48 < 10) {
-          return codePoint - 22;
-        }
-        if (codePoint - 65 < 26) {
-          return codePoint - 65;
-        }
-        if (codePoint - 97 < 26) {
-          return codePoint - 97;
-        }
-        return base;
-      };
-      const digitToBasic = function (digit, flag) {
-        return digit + 22 + 75 * (digit < 26) - ((flag != 0) << 5);
-      };
-      const adapt = function (delta2, numPoints, firstTime) {
-        let k = 0;
-        delta2 = firstTime ? floor(delta2 / damp) : delta2 >> 1;
-        delta2 += floor(delta2 / numPoints);
-        for (; delta2 > (baseMinusTMin * tMax) >> 1; k += base) {
-          delta2 = floor(delta2 / baseMinusTMin);
-        }
-        return floor(k + ((baseMinusTMin + 1) * delta2) / (delta2 + skew));
-      };
-      const decode = function (input) {
-        const output = [];
-        const inputLength = input.length;
-        let i = 0;
-        let n2 = initialN;
-        let bias = initialBias;
-        let basic = input.lastIndexOf(delimiter);
-        if (basic < 0) {
-          basic = 0;
-        }
-        for (let j = 0; j < basic; ++j) {
-          if (input.charCodeAt(j) >= 128) {
-            error("not-basic");
-          }
-          output.push(input.charCodeAt(j));
-        }
-        for (let index = basic > 0 ? basic + 1 : 0; index < inputLength; ) {
-          let oldi = i;
-          for (let w2 = 1, k = base; ; k += base) {
-            if (index >= inputLength) {
-              error("invalid-input");
-            }
-            const digit = basicToDigit(input.charCodeAt(index++));
-            if (digit >= base || digit > floor((maxInt - i) / w2)) {
-              error("overflow");
-            }
-            i += digit * w2;
-            const t2 = k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-            if (digit < t2) {
-              break;
-            }
-            const baseMinusT = base - t2;
-            if (w2 > floor(maxInt / baseMinusT)) {
-              error("overflow");
-            }
-            w2 *= baseMinusT;
-          }
-          const out = output.length + 1;
-          bias = adapt(i - oldi, out, oldi == 0);
-          if (floor(i / out) > maxInt - n2) {
-            error("overflow");
-          }
-          n2 += floor(i / out);
-          i %= out;
-          output.splice(i++, 0, n2);
-        }
-        return String.fromCodePoint(...output);
-      };
-      const encode = function (input) {
-        const output = [];
-        input = ucs2decode(input);
-        let inputLength = input.length;
-        let n2 = initialN;
-        let delta2 = 0;
-        let bias = initialBias;
-        for (const currentValue of input) {
-          if (currentValue < 128) {
-            output.push(stringFromCharCode(currentValue));
-          }
-        }
-        let basicLength = output.length;
-        let handledCPCount = basicLength;
-        if (basicLength) {
-          output.push(delimiter);
-        }
-        while (handledCPCount < inputLength) {
-          let m = maxInt;
-          for (const currentValue of input) {
-            if (currentValue >= n2 && currentValue < m) {
-              m = currentValue;
-            }
-          }
-          const handledCPCountPlusOne = handledCPCount + 1;
-          if (m - n2 > floor((maxInt - delta2) / handledCPCountPlusOne)) {
-            error("overflow");
-          }
-          delta2 += (m - n2) * handledCPCountPlusOne;
-          n2 = m;
-          for (const currentValue of input) {
-            if (currentValue < n2 && ++delta2 > maxInt) {
-              error("overflow");
-            }
-            if (currentValue == n2) {
-              let q2 = delta2;
-              for (let k = base; ; k += base) {
-                const t2 =
-                  k <= bias ? tMin : k >= bias + tMax ? tMax : k - bias;
-                if (q2 < t2) {
-                  break;
-                }
-                const qMinusT = q2 - t2;
-                const baseMinusT = base - t2;
-                output.push(
-                  stringFromCharCode(
-                    digitToBasic(t2 + (qMinusT % baseMinusT), 0)
-                  )
-                );
-                q2 = floor(qMinusT / baseMinusT);
-              }
-              output.push(stringFromCharCode(digitToBasic(q2, 0)));
-              bias = adapt(
-                delta2,
-                handledCPCountPlusOne,
-                handledCPCount == basicLength
-              );
-              delta2 = 0;
-              ++handledCPCount;
-            }
-          }
-          ++delta2;
-          ++n2;
-        }
-        return output.join("");
-      };
-      const toUnicode = function (input) {
-        return mapDomain(input, function (string2) {
-          return regexPunycode.test(string2)
-            ? decode(string2.slice(4).toLowerCase())
-            : string2;
-        });
-      };
-      const toASCII = function (input) {
-        return mapDomain(input, function (string2) {
-          return regexNonASCII.test(string2)
-            ? "xn--" + encode(string2)
-            : string2;
-        });
-      };
-      const punycode$1 = {
-        version: "2.1.0",
-        ucs2: {
-          decode: ucs2decode,
-          encode: ucs2encode,
-        },
-        decode: decode,
-        encode: encode,
-        toASCII: toASCII,
-        toUnicode: toUnicode,
-      };
-      var punycode_es6 = /* @__PURE__ */ Object.freeze({
-        __proto__: null,
-        [Symbol.toStringTag]: "Module",
-        ucs2decode,
-        ucs2encode,
-        decode,
-        encode,
-        toASCII,
-        toUnicode,
-        default: punycode$1,
-      });
-      var require$$8 = /* @__PURE__ */ getAugmentedNamespace(punycode_es6);
-      var _default$1 = {
-        options: {
-          html: false,
-          xhtmlOut: false,
-          breaks: false,
-          langPrefix: "language-",
-          linkify: false,
-          typographer: false,
-          quotes: "\u201C\u201D\u2018\u2019",
-          highlight: null,
-          maxNesting: 100,
-        },
-        components: {
-          core: {},
-          block: {},
-          inline: {},
-        },
-      };
-      var zero = {
-        options: {
-          html: false,
-          xhtmlOut: false,
-          breaks: false,
-          langPrefix: "language-",
-          linkify: false,
-          typographer: false,
-          quotes: "\u201C\u201D\u2018\u2019",
-          highlight: null,
-          maxNesting: 20,
-        },
-        components: {
-          core: {
-            rules: ["normalize", "block", "inline"],
-          },
-          block: {
-            rules: ["paragraph"],
-          },
-          inline: {
-            rules: ["text"],
-            rules2: ["balance_pairs", "text_collapse"],
-          },
-        },
-      };
-      var commonmark = {
-        options: {
-          html: true,
-          xhtmlOut: true,
-          breaks: false,
-          langPrefix: "language-",
-          linkify: false,
-          typographer: false,
-          quotes: "\u201C\u201D\u2018\u2019",
-          highlight: null,
-          maxNesting: 20,
-        },
-        components: {
-          core: {
-            rules: ["normalize", "block", "inline"],
-          },
-          block: {
-            rules: [
-              "blockquote",
-              "code",
-              "fence",
-              "heading",
-              "hr",
-              "html_block",
-              "lheading",
-              "list",
-              "reference",
-              "paragraph",
-            ],
-          },
-          inline: {
-            rules: [
-              "autolink",
-              "backticks",
-              "emphasis",
-              "entity",
-              "escape",
-              "html_inline",
-              "image",
-              "link",
-              "newline",
-              "text",
-            ],
-            rules2: ["balance_pairs", "emphasis", "text_collapse"],
-          },
-        },
-      };
-      var utils = utils$1;
-      var helpers = helpers$1;
-      var Renderer = renderer;
-      var ParserCore = parser_core;
-      var ParserBlock = parser_block;
-      var ParserInline = parser_inline;
-      var LinkifyIt = linkifyIt;
-      var mdurl = mdurl$1;
-      var punycode = require$$8;
-      var config = {
-        default: _default$1,
-        zero,
-        commonmark,
-      };
-      var BAD_PROTO_RE = /^(vbscript|javascript|file|data):/;
-      var GOOD_DATA_RE = /^data:image\/(gif|png|jpeg|webp);/;
-      function validateLink(url) {
-        var str = url.trim().toLowerCase();
-        return BAD_PROTO_RE.test(str)
-          ? GOOD_DATA_RE.test(str)
-            ? true
-            : false
-          : true;
-      }
-      var RECODE_HOSTNAME_FOR = ["http:", "https:", "mailto:"];
-      function normalizeLink(url) {
-        var parsed = mdurl.parse(url, true);
-        if (parsed.hostname) {
-          if (
-            !parsed.protocol ||
-            RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0
-          ) {
-            try {
-              parsed.hostname = punycode.toASCII(parsed.hostname);
-            } catch (er) {}
-          }
-        }
-        return mdurl.encode(mdurl.format(parsed));
-      }
-      function normalizeLinkText(url) {
-        var parsed = mdurl.parse(url, true);
-        if (parsed.hostname) {
-          if (
-            !parsed.protocol ||
-            RECODE_HOSTNAME_FOR.indexOf(parsed.protocol) >= 0
-          ) {
-            try {
-              parsed.hostname = punycode.toUnicode(parsed.hostname);
-            } catch (er) {}
-          }
-        }
-        return mdurl.decode(
-          mdurl.format(parsed),
-          mdurl.decode.defaultChars + "%"
-        );
-      }
-      function MarkdownIt(presetName, options) {
-        if (!(this instanceof MarkdownIt)) {
-          return new MarkdownIt(presetName, options);
-        }
-        if (!options) {
-          if (!utils.isString(presetName)) {
-            options = presetName || {};
-            presetName = "default";
-          }
-        }
-        this.inline = new ParserInline();
-        this.block = new ParserBlock();
-        this.core = new ParserCore();
-        this.renderer = new Renderer();
-        this.linkify = new LinkifyIt();
-        this.validateLink = validateLink;
-        this.normalizeLink = normalizeLink;
-        this.normalizeLinkText = normalizeLinkText;
-        this.utils = utils;
-        this.helpers = utils.assign({}, helpers);
-        this.options = {};
-        this.configure(presetName);
-        if (options) {
-          this.set(options);
-        }
-      }
-      MarkdownIt.prototype.set = function (options) {
-        utils.assign(this.options, options);
-        return this;
-      };
-      MarkdownIt.prototype.configure = function (presets) {
-        var self2 = this,
-          presetName;
-        if (utils.isString(presets)) {
-          presetName = presets;
-          presets = config[presetName];
-          if (!presets) {
-            throw new Error(
-              'Wrong `markdown-it` preset "' + presetName + '", check name'
-            );
-          }
-        }
-        if (!presets) {
-          throw new Error("Wrong `markdown-it` preset, can't be empty");
-        }
-        if (presets.options) {
-          self2.set(presets.options);
-        }
-        if (presets.components) {
-          Object.keys(presets.components).forEach(function (name2) {
-            if (presets.components[name2].rules) {
-              self2[name2].ruler.enableOnly(presets.components[name2].rules);
-            }
-            if (presets.components[name2].rules2) {
-              self2[name2].ruler2.enableOnly(presets.components[name2].rules2);
-            }
-          });
-        }
-        return this;
-      };
-      MarkdownIt.prototype.enable = function (list3, ignoreInvalid) {
-        var result2 = [];
-        if (!Array.isArray(list3)) {
-          list3 = [list3];
-        }
-        ["core", "block", "inline"].forEach(function (chain) {
-          result2 = result2.concat(this[chain].ruler.enable(list3, true));
-        }, this);
-        result2 = result2.concat(this.inline.ruler2.enable(list3, true));
-        var missed = list3.filter(function (name2) {
-          return result2.indexOf(name2) < 0;
-        });
-        if (missed.length && !ignoreInvalid) {
-          throw new Error(
-            "MarkdownIt. Failed to enable unknown rule(s): " + missed
-          );
-        }
-        return this;
-      };
-      MarkdownIt.prototype.disable = function (list3, ignoreInvalid) {
-        var result2 = [];
-        if (!Array.isArray(list3)) {
-          list3 = [list3];
-        }
-        ["core", "block", "inline"].forEach(function (chain) {
-          result2 = result2.concat(this[chain].ruler.disable(list3, true));
-        }, this);
-        result2 = result2.concat(this.inline.ruler2.disable(list3, true));
-        var missed = list3.filter(function (name2) {
-          return result2.indexOf(name2) < 0;
-        });
-        if (missed.length && !ignoreInvalid) {
-          throw new Error(
-            "MarkdownIt. Failed to disable unknown rule(s): " + missed
-          );
-        }
-        return this;
-      };
-      MarkdownIt.prototype.use = function (plugin) {
-        var args = [this].concat(Array.prototype.slice.call(arguments, 1));
-        plugin.apply(plugin, args);
-        return this;
-      };
-      MarkdownIt.prototype.parse = function (src, env) {
-        if (typeof src !== "string") {
-          throw new Error("Input data should be a String");
-        }
-        var state = new this.core.State(src, this, env);
-        this.core.process(state);
-        return state.tokens;
-      };
-      MarkdownIt.prototype.render = function (src, env) {
-        env = env || {};
-        return this.renderer.render(this.parse(src, env), this.options, env);
-      };
-      MarkdownIt.prototype.parseInline = function (src, env) {
-        var state = new this.core.State(src, this, env);
-        state.inlineMode = true;
-        this.core.process(state);
-        return state.tokens;
-      };
-      MarkdownIt.prototype.renderInline = function (src, env) {
-        env = env || {};
-        return this.renderer.render(
-          this.parseInline(src, env),
-          this.options,
-          env
-        );
-      };
-      var lib = MarkdownIt;
-      var markdownIt = lib;
-      var invalidCharacters = Array.from({ length: 11 }, function (_, i) {
-        return String.fromCharCode(8192 + i);
-      }).concat(["\u2028", "\u2029", "\u202F", "\xA0"]);
-      var sanitizeRegex = new RegExp(
-        "[" + invalidCharacters.join("") + "]",
-        "g"
-      );
-      function normalizeWhitespace(line) {
-        return line.replace(sanitizeRegex, " ");
-      }
-      /*!
-       * escape-html
-       * Copyright(c) 2012-2013 TJ Holowaychuk
-       * Copyright(c) 2015 Andreas Lubbe
-       * Copyright(c) 2015 Tiancheng "Timothy" Gu
-       * MIT Licensed
-       */
-      var matchHtmlRegExp = /["'&<>]/;
-      var escapeHtml_1 = escapeHtml;
-      function escapeHtml(string2) {
-        var str = "" + string2;
-        var match2 = matchHtmlRegExp.exec(str);
-        if (!match2) {
-          return str;
-        }
-        var escape3;
-        var html = "";
-        var index = 0;
-        var lastIndex = 0;
-        for (index = match2.index; index < str.length; index++) {
-          switch (str.charCodeAt(index)) {
-            case 34:
-              escape3 = "&quot;";
-              break;
-            case 38:
-              escape3 = "&amp;";
-              break;
-            case 39:
-              escape3 = "&#39;";
-              break;
-            case 60:
-              escape3 = "&lt;";
-              break;
-            case 62:
-              escape3 = "&gt;";
-              break;
-            default:
-              continue;
-          }
-          if (lastIndex !== index) {
-            html += str.substring(lastIndex, index);
-          }
-          lastIndex = index + 1;
-          html += escape3;
-        }
-        return lastIndex !== index
-          ? html + str.substring(lastIndex, index)
-          : html;
-      }
-      var md$2 = new markdownIt();
-      function onHasCompletion(_cm, data, onHintInformationRender) {
-        Promise.resolve()
-          .then(function () {
-            return codemirror$1;
-          })
-          .then(function (_a2) {
-            var CodeMirror = _a2.default;
-            var information;
-            var deprecation;
-            CodeMirror.on(data, "select", function (ctx, el2) {
-              if (!information) {
-                var hintsUl_1 = el2.parentNode;
-                information = document.createElement("div");
-                information.className = "CodeMirror-hint-information";
-                hintsUl_1.appendChild(information);
-                deprecation = document.createElement("div");
-                deprecation.className = "CodeMirror-hint-deprecation";
-                hintsUl_1.appendChild(deprecation);
-                var onRemoveFn_1;
-                hintsUl_1.addEventListener(
-                  "DOMNodeRemoved",
-                  (onRemoveFn_1 = function (event) {
-                    if (event.target === hintsUl_1) {
-                      hintsUl_1.removeEventListener(
-                        "DOMNodeRemoved",
-                        onRemoveFn_1
-                      );
-                      information = null;
-                      deprecation = null;
-                      onRemoveFn_1 = null;
-                    }
-                  })
-                );
-              }
-              var description = ctx.description
-                ? md$2.render(ctx.description)
-                : "Self descriptive.";
-              var type2 = ctx.type
-                ? '<span class="infoType">' + renderType$2(ctx.type) + "</span>"
-                : "";
-              information.innerHTML =
-                '<div class="content">' +
-                (description.slice(0, 3) === "<p>"
-                  ? "<p>" + type2 + description.slice(3)
-                  : type2 + description) +
-                "</div>";
-              if (ctx && deprecation && ctx.deprecationReason) {
-                var reason = ctx.deprecationReason
-                  ? md$2.render(ctx.deprecationReason)
-                  : "";
-                deprecation.innerHTML =
-                  '<span class="deprecation-label">Deprecated</span>' + reason;
-                deprecation.style.display = "block";
-              } else if (deprecation) {
-                deprecation.style.display = "none";
-              }
-              if (onHintInformationRender) {
-                onHintInformationRender(information);
-              }
-            });
-          });
-      }
-      function renderType$2(type2) {
-        if (type2 instanceof GraphQLNonNull) {
-          return renderType$2(type2.ofType) + "!";
-        }
-        if (type2 instanceof GraphQLList) {
-          return "[" + renderType$2(type2.ofType) + "]";
-        }
-        return '<a class="typeName">' + escapeHtml_1(type2.name) + "</a>";
-      }
-      var _a;
-      var isMacOs = false;
-      if (typeof window === "object") {
-        isMacOs = window.navigator.platform === "MacIntel";
-      }
-      var commonKeys =
-        ((_a = {}),
-        (_a[isMacOs ? "Cmd-F" : "Ctrl-F"] = "findPersistent"),
-        (_a["Cmd-G"] = "findPersistent"),
-        (_a["Ctrl-G"] = "findPersistent"),
-        (_a["Ctrl-Left"] = "goSubwordLeft"),
-        (_a["Ctrl-Right"] = "goSubwordRight"),
-        (_a["Alt-Left"] = "goGroupLeft"),
-        (_a["Alt-Right"] = "goGroupRight"),
-        _a);
-      var __awaiter$6 =
-        (globalThis && globalThis.__awaiter) ||
-        function (thisArg, _arguments, P2, generator) {
-          function adopt(value) {
-            return value instanceof P2
-              ? value
-              : new P2(function (resolve) {
-                  resolve(value);
-                });
-          }
-          return new (P2 || (P2 = Promise))(function (resolve, reject2) {
-            function fulfilled(value) {
-              try {
-                step(generator.next(value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function rejected(value) {
-              try {
-                step(generator["throw"](value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function step(result2) {
-              result2.done
-                ? resolve(result2.value)
-                : adopt(result2.value).then(fulfilled, rejected);
-            }
-            step(
-              (generator = generator.apply(thisArg, _arguments || [])).next()
-            );
-          });
-        };
-      var __generator$6 =
-        (globalThis && globalThis.__generator) ||
-        function (thisArg, body) {
-          var _ = {
-              label: 0,
-              sent: function () {
-                if (t2[0] & 1) throw t2[1];
-                return t2[1];
-              },
-              trys: [],
-              ops: [],
-            },
-            f,
-            y2,
-            t2,
-            g;
-          return (
-            (g = { next: verb(0), throw: verb(1), return: verb(2) }),
-            typeof Symbol === "function" &&
-              (g[Symbol.iterator] = function () {
-                return this;
-              }),
-            g
-          );
-          function verb(n2) {
-            return function (v2) {
-              return step([n2, v2]);
-            };
-          }
-          function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_)
-              try {
-                if (
-                  ((f = 1),
-                  y2 &&
-                    (t2 =
-                      op[0] & 2
-                        ? y2["return"]
-                        : op[0]
-                        ? y2["throw"] || ((t2 = y2["return"]) && t2.call(y2), 0)
-                        : y2.next) &&
-                    !(t2 = t2.call(y2, op[1])).done)
-                )
-                  return t2;
-                if (((y2 = 0), t2)) op = [op[0] & 2, t2.value];
-                switch (op[0]) {
-                  case 0:
-                  case 1:
-                    t2 = op;
-                    break;
-                  case 4:
-                    _.label++;
-                    return { value: op[1], done: false };
-                  case 5:
-                    _.label++;
-                    y2 = op[1];
-                    op = [0];
-                    continue;
-                  case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                  default:
-                    if (
-                      !((t2 = _.trys),
-                      (t2 = t2.length > 0 && t2[t2.length - 1])) &&
-                      (op[0] === 6 || op[0] === 2)
-                    ) {
-                      _ = 0;
-                      continue;
-                    }
-                    if (
-                      op[0] === 3 &&
-                      (!t2 || (op[1] > t2[0] && op[1] < t2[3]))
-                    ) {
-                      _.label = op[1];
-                      break;
-                    }
-                    if (op[0] === 6 && _.label < t2[1]) {
-                      _.label = t2[1];
-                      t2 = op;
-                      break;
-                    }
-                    if (t2 && _.label < t2[2]) {
-                      _.label = t2[2];
-                      _.ops.push(op);
-                      break;
-                    }
-                    if (t2[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                }
-                op = body.call(thisArg, _);
-              } catch (e) {
-                op = [6, e];
-                y2 = 0;
-              } finally {
-                f = t2 = 0;
-              }
-            if (op[0] & 5) throw op[1];
-            return { value: op[0] ? op[1] : void 0, done: true };
-          }
-        };
-      var commonCodeMirrorAddons = [
-        Promise.resolve().then(function () {
-          return showHint$1;
-        }),
-        Promise.resolve().then(function () {
-          return matchbrackets$1;
-        }),
-        Promise.resolve().then(function () {
-          return closebrackets$1;
-        }),
-        Promise.resolve().then(function () {
-          return braceFold$1;
-        }),
-        Promise.resolve().then(function () {
-          return foldgutter$1;
-        }),
-        Promise.resolve().then(function () {
-          return lint$5;
-        }),
-        Promise.resolve().then(function () {
-          return searchcursor$1;
-        }),
-        Promise.resolve().then(function () {
-          return jumpToLine$1;
-        }),
-        Promise.resolve().then(function () {
-          return dialog$1;
-        }),
-        Promise.resolve().then(function () {
-          return sublime$1;
-        }),
-      ];
-      function importCodeMirror(addons, options) {
-        return __awaiter$6(this, void 0, void 0, function () {
-          var CodeMirror, allAddons;
-          return __generator$6(this, function (_a2) {
-            switch (_a2.label) {
-              case 0:
-                return [
-                  4,
-                  Promise.resolve().then(function () {
-                    return codemirror$1;
-                  }),
-                ];
-              case 1:
-                CodeMirror = _a2.sent().default;
-                allAddons =
-                  (options === null || options === void 0
-                    ? void 0
-                    : options.useCommonAddons) === false
-                    ? addons
-                    : commonCodeMirrorAddons.concat(addons);
-                return [
-                  4,
-                  Promise.all(
-                    allAddons.map(function (addon) {
-                      return addon;
-                    })
-                  ),
-                ];
-              case 2:
-                _a2.sent();
-                return [2, CodeMirror];
-            }
-          });
-        });
-      }
-      var __extends$b =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var __assign$a =
-        (globalThis && globalThis.__assign) ||
-        function () {
-          __assign$a =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign$a.apply(this, arguments);
-        };
-      var __awaiter$5 =
-        (globalThis && globalThis.__awaiter) ||
-        function (thisArg, _arguments, P2, generator) {
-          function adopt(value) {
-            return value instanceof P2
-              ? value
-              : new P2(function (resolve) {
-                  resolve(value);
-                });
-          }
-          return new (P2 || (P2 = Promise))(function (resolve, reject2) {
-            function fulfilled(value) {
-              try {
-                step(generator.next(value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function rejected(value) {
-              try {
-                step(generator["throw"](value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function step(result2) {
-              result2.done
-                ? resolve(result2.value)
-                : adopt(result2.value).then(fulfilled, rejected);
-            }
-            step(
-              (generator = generator.apply(thisArg, _arguments || [])).next()
-            );
-          });
-        };
-      var __generator$5 =
-        (globalThis && globalThis.__generator) ||
-        function (thisArg, body) {
-          var _ = {
-              label: 0,
-              sent: function () {
-                if (t2[0] & 1) throw t2[1];
-                return t2[1];
-              },
-              trys: [],
-              ops: [],
-            },
-            f,
-            y2,
-            t2,
-            g;
-          return (
-            (g = { next: verb(0), throw: verb(1), return: verb(2) }),
-            typeof Symbol === "function" &&
-              (g[Symbol.iterator] = function () {
-                return this;
-              }),
-            g
-          );
-          function verb(n2) {
-            return function (v2) {
-              return step([n2, v2]);
-            };
-          }
-          function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_)
-              try {
-                if (
-                  ((f = 1),
-                  y2 &&
-                    (t2 =
-                      op[0] & 2
-                        ? y2["return"]
-                        : op[0]
-                        ? y2["throw"] || ((t2 = y2["return"]) && t2.call(y2), 0)
-                        : y2.next) &&
-                    !(t2 = t2.call(y2, op[1])).done)
-                )
-                  return t2;
-                if (((y2 = 0), t2)) op = [op[0] & 2, t2.value];
-                switch (op[0]) {
-                  case 0:
-                  case 1:
-                    t2 = op;
-                    break;
-                  case 4:
-                    _.label++;
-                    return { value: op[1], done: false };
-                  case 5:
-                    _.label++;
-                    y2 = op[1];
-                    op = [0];
-                    continue;
-                  case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                  default:
-                    if (
-                      !((t2 = _.trys),
-                      (t2 = t2.length > 0 && t2[t2.length - 1])) &&
-                      (op[0] === 6 || op[0] === 2)
-                    ) {
-                      _ = 0;
-                      continue;
-                    }
-                    if (
-                      op[0] === 3 &&
-                      (!t2 || (op[1] > t2[0] && op[1] < t2[3]))
-                    ) {
-                      _.label = op[1];
-                      break;
-                    }
-                    if (op[0] === 6 && _.label < t2[1]) {
-                      _.label = t2[1];
-                      t2 = op;
-                      break;
-                    }
-                    if (t2 && _.label < t2[2]) {
-                      _.label = t2[2];
-                      _.ops.push(op);
-                      break;
-                    }
-                    if (t2[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                }
-                op = body.call(thisArg, _);
-              } catch (e) {
-                op = [6, e];
-                y2 = 0;
-              } finally {
-                f = t2 = 0;
-              }
-            if (op[0] & 5) throw op[1];
-            return { value: op[0] ? op[1] : void 0, done: true };
-          }
-        };
-      var md$1 = new markdownIt();
-      var AUTO_COMPLETE_AFTER_KEY = /^[a-zA-Z0-9_@(]$/;
-      var QueryEditor = (function (_super2) {
-        __extends$b(QueryEditor2, _super2);
-        function QueryEditor2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this.editor = null;
-          _this.ignoreChangeEvent = false;
-          _this._node = null;
-          _this.addonModules = function () {
-            return [
-              Promise.resolve().then(function () {
-                return comment$1;
-              }),
-              Promise.resolve().then(function () {
-                return search$1;
-              }),
-              Promise.resolve().then(function () {
-                return hint$2;
-              }),
-              Promise.resolve().then(function () {
-                return lint$2;
-              }),
-              Promise.resolve().then(function () {
-                return info;
-              }),
-              Promise.resolve().then(function () {
-                return jump;
-              }),
-              Promise.resolve().then(function () {
-                return mode$4;
-              }),
-            ];
-          };
-          _this._onKeyUp = function (_cm, event) {
-            if (AUTO_COMPLETE_AFTER_KEY.test(event.key) && _this.editor) {
-              _this.editor.execCommand("autocomplete");
-            }
-          };
-          _this._onEdit = function () {
-            if (!_this.ignoreChangeEvent && _this.editor) {
-              _this.cachedValue = _this.editor.getValue();
-              if (_this.props.onEdit) {
-                _this.props.onEdit(_this.cachedValue);
-              }
-            }
-          };
-          _this._onHasCompletion = function (cm, data) {
-            onHasCompletion(cm, data, _this.props.onHintInformationRender);
-          };
-          _this.cachedValue = props.value || "";
-          return _this;
-        }
-        QueryEditor2.prototype.componentDidMount = function () {
-          var _this = this;
-          this.initializeEditor()
-            .then(function (editor) {
-              if (editor) {
-                editor.on("change", _this._onEdit);
-                editor.on("keyup", _this._onKeyUp);
-                editor.on("hasCompletion", _this._onHasCompletion);
-                editor.on("beforeChange", _this._onBeforeChange);
-              }
-            })
-            .catch(console.error);
-        };
-        QueryEditor2.prototype.componentDidUpdate = function (prevProps) {
-          this.ignoreChangeEvent = true;
-          var signalChange = false;
-          if (this.props.schema !== prevProps.schema && this.editor) {
-            this.editor.options.lint.schema = this.props.schema;
-            this.editor.options.hintOptions.schema = this.props.schema;
-            this.editor.options.info.schema = this.props.schema;
-            this.editor.options.jump.schema = this.props.schema;
-            signalChange = true;
-          }
-          if (
-            this.props.externalFragments !== prevProps.externalFragments &&
-            this.editor
-          ) {
-            this.editor.options.lint.externalFragments =
-              this.props.externalFragments;
-            this.editor.options.hintOptions.externalFragments =
-              this.props.externalFragments;
-            signalChange = true;
-          }
-          if (signalChange) {
-            this.CodeMirror.signal(this.editor, "change", this.editor);
-          }
-          if (
-            this.props.value !== prevProps.value &&
-            this.props.value !== this.cachedValue &&
-            this.editor
-          ) {
-            this.cachedValue = this.props.value;
-            this.editor.setValue(this.props.value);
-          }
-          this.ignoreChangeEvent = false;
-        };
-        QueryEditor2.prototype.componentWillUnmount = function () {
-          if (this.editor) {
-            this.editor.off("change", this._onEdit);
-            this.editor.off("keyup", this._onKeyUp);
-            this.editor.off("hasCompletion", this._onHasCompletion);
-          }
-        };
-        QueryEditor2.prototype.render = function () {
-          var _this = this;
-          return React$1.createElement("section", {
-            className: "query-editor",
-            "aria-label": "Query Editor",
-            ref: function (node) {
-              _this._node = node;
-            },
-          });
-        };
-        QueryEditor2.prototype.initializeEditor = function () {
-          var _a2, _b, _c, _d;
-          return __awaiter$5(this, void 0, void 0, function () {
-            var CodeMirror, _e, editor;
-            var _this = this;
-            return __generator$5(this, function (_f) {
-              switch (_f.label) {
-                case 0:
-                  _e = this;
-                  return [4, importCodeMirror(this.addonModules())];
-                case 1:
-                  CodeMirror = _e.CodeMirror = _f.sent();
-                  editor = this.editor = CodeMirror(this._node, {
-                    value:
-                      (_a2 = this.props.value) !== null && _a2 !== void 0
-                        ? _a2
-                        : "",
-                    lineNumbers: true,
-                    tabSize: 2,
-                    foldGutter: {
-                      minFoldSize: 4,
-                    },
-                    mode: "graphql",
-                    theme: this.props.editorTheme || "graphiql",
-                    keyMap: "sublime",
-                    autoCloseBrackets: true,
-                    matchBrackets: true,
-                    showCursorWhenSelecting: true,
-                    readOnly: this.props.readOnly ? "nocursor" : false,
-                    lint: {
-                      schema: this.props.schema,
-                      validationRules:
-                        (_b = this.props.validationRules) !== null &&
-                        _b !== void 0
-                          ? _b
-                          : null,
-                      externalFragments:
-                        (_c = this.props) === null || _c === void 0
-                          ? void 0
-                          : _c.externalFragments,
-                    },
-                    hintOptions: {
-                      schema: this.props.schema,
-                      closeOnUnfocus: false,
-                      completeSingle: false,
-                      container: this._node,
-                      externalFragments:
-                        (_d = this.props) === null || _d === void 0
-                          ? void 0
-                          : _d.externalFragments,
-                    },
-                    info: {
-                      schema: this.props.schema,
-                      renderDescription: function (text3) {
-                        return md$1.render(text3);
-                      },
-                      onClick: function (reference3) {
-                        return (
-                          _this.props.onClickReference &&
-                          _this.props.onClickReference(reference3)
-                        );
-                      },
-                    },
-                    jump: {
-                      schema: this.props.schema,
-                      onClick: function (reference3) {
-                        return (
-                          _this.props.onClickReference &&
-                          _this.props.onClickReference(reference3)
-                        );
-                      },
-                    },
-                    gutters: [
-                      "CodeMirror-linenumbers",
-                      "CodeMirror-foldgutter",
-                    ],
-                    extraKeys: __assign$a(
-                      __assign$a(
-                        {
-                          "Cmd-Space": function () {
-                            return editor.showHint({
-                              completeSingle: true,
-                              container: _this._node,
-                            });
-                          },
-                          "Ctrl-Space": function () {
-                            return editor.showHint({
-                              completeSingle: true,
-                              container: _this._node,
-                            });
-                          },
-                          "Alt-Space": function () {
-                            return editor.showHint({
-                              completeSingle: true,
-                              container: _this._node,
-                            });
-                          },
-                          "Shift-Space": function () {
-                            return editor.showHint({
-                              completeSingle: true,
-                              container: _this._node,
-                            });
-                          },
-                          "Shift-Alt-Space": function () {
-                            return editor.showHint({
-                              completeSingle: true,
-                              container: _this._node,
-                            });
-                          },
-                          "Cmd-Enter": function () {
-                            if (_this.props.onRunQuery) {
-                              _this.props.onRunQuery();
-                            }
-                          },
-                          "Ctrl-Enter": function () {
-                            if (_this.props.onRunQuery) {
-                              _this.props.onRunQuery();
-                            }
-                          },
-                          "Shift-Ctrl-C": function () {
-                            if (_this.props.onCopyQuery) {
-                              _this.props.onCopyQuery();
-                            }
-                          },
-                          "Shift-Ctrl-P": function () {
-                            if (_this.props.onPrettifyQuery) {
-                              _this.props.onPrettifyQuery();
-                            }
-                          },
-                          "Shift-Ctrl-F": function () {
-                            if (_this.props.onPrettifyQuery) {
-                              _this.props.onPrettifyQuery();
-                            }
-                          },
-                          "Shift-Ctrl-M": function () {
-                            if (_this.props.onMergeQuery) {
-                              _this.props.onMergeQuery();
-                            }
-                          },
-                        },
-                        commonKeys
-                      ),
-                      {
-                        "Cmd-S": function () {
-                          if (_this.props.onRunQuery);
-                        },
-                        "Ctrl-S": function () {
-                          if (_this.props.onRunQuery);
-                        },
-                      }
-                    ),
-                  });
-                  return [2, editor];
-              }
-            });
-          });
-        };
-        QueryEditor2.prototype.getCodeMirror = function () {
-          return this.editor;
-        };
-        QueryEditor2.prototype.getClientHeight = function () {
-          return this._node && this._node.clientHeight;
-        };
-        QueryEditor2.prototype._onBeforeChange = function (_instance, change) {
-          if (change.origin === "paste") {
-            var text3 = change.text.map(normalizeWhitespace);
-            change.update(change.from, change.to, text3);
-          }
-        };
-        return QueryEditor2;
-      })(React$1.Component);
-      var __extends$a =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var __assign$9 =
-        (globalThis && globalThis.__assign) ||
-        function () {
-          __assign$9 =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign$9.apply(this, arguments);
-        };
-      var __awaiter$4 =
-        (globalThis && globalThis.__awaiter) ||
-        function (thisArg, _arguments, P2, generator) {
-          function adopt(value) {
-            return value instanceof P2
-              ? value
-              : new P2(function (resolve) {
-                  resolve(value);
-                });
-          }
-          return new (P2 || (P2 = Promise))(function (resolve, reject2) {
-            function fulfilled(value) {
-              try {
-                step(generator.next(value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function rejected(value) {
-              try {
-                step(generator["throw"](value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function step(result2) {
-              result2.done
-                ? resolve(result2.value)
-                : adopt(result2.value).then(fulfilled, rejected);
-            }
-            step(
-              (generator = generator.apply(thisArg, _arguments || [])).next()
-            );
-          });
-        };
-      var __generator$4 =
-        (globalThis && globalThis.__generator) ||
-        function (thisArg, body) {
-          var _ = {
-              label: 0,
-              sent: function () {
-                if (t2[0] & 1) throw t2[1];
-                return t2[1];
-              },
-              trys: [],
-              ops: [],
-            },
-            f,
-            y2,
-            t2,
-            g;
-          return (
-            (g = { next: verb(0), throw: verb(1), return: verb(2) }),
-            typeof Symbol === "function" &&
-              (g[Symbol.iterator] = function () {
-                return this;
-              }),
-            g
-          );
-          function verb(n2) {
-            return function (v2) {
-              return step([n2, v2]);
-            };
-          }
-          function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_)
-              try {
-                if (
-                  ((f = 1),
-                  y2 &&
-                    (t2 =
-                      op[0] & 2
-                        ? y2["return"]
-                        : op[0]
-                        ? y2["throw"] || ((t2 = y2["return"]) && t2.call(y2), 0)
-                        : y2.next) &&
-                    !(t2 = t2.call(y2, op[1])).done)
-                )
-                  return t2;
-                if (((y2 = 0), t2)) op = [op[0] & 2, t2.value];
-                switch (op[0]) {
-                  case 0:
-                  case 1:
-                    t2 = op;
-                    break;
-                  case 4:
-                    _.label++;
-                    return { value: op[1], done: false };
-                  case 5:
-                    _.label++;
-                    y2 = op[1];
-                    op = [0];
-                    continue;
-                  case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                  default:
-                    if (
-                      !((t2 = _.trys),
-                      (t2 = t2.length > 0 && t2[t2.length - 1])) &&
-                      (op[0] === 6 || op[0] === 2)
-                    ) {
-                      _ = 0;
-                      continue;
-                    }
-                    if (
-                      op[0] === 3 &&
-                      (!t2 || (op[1] > t2[0] && op[1] < t2[3]))
-                    ) {
-                      _.label = op[1];
-                      break;
-                    }
-                    if (op[0] === 6 && _.label < t2[1]) {
-                      _.label = t2[1];
-                      t2 = op;
-                      break;
-                    }
-                    if (t2 && _.label < t2[2]) {
-                      _.label = t2[2];
-                      _.ops.push(op);
-                      break;
-                    }
-                    if (t2[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                }
-                op = body.call(thisArg, _);
-              } catch (e) {
-                op = [6, e];
-                y2 = 0;
-              } finally {
-                f = t2 = 0;
-              }
-            if (op[0] & 5) throw op[1];
-            return { value: op[0] ? op[1] : void 0, done: true };
-          }
-        };
-      var VariableEditor = (function (_super2) {
-        __extends$a(VariableEditor2, _super2);
-        function VariableEditor2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this.editor = null;
-          _this._node = null;
-          _this.ignoreChangeEvent = false;
-          _this.addonModules = function () {
-            return [
-              Promise.resolve().then(function () {
-                return hint;
-              }),
-              Promise.resolve().then(function () {
-                return lint;
-              }),
-              Promise.resolve().then(function () {
-                return mode$2;
-              }),
-            ];
-          };
-          _this._onKeyUp = function (_cm, event) {
-            var code3 = event.keyCode;
-            if (!_this.editor) {
-              return;
-            }
-            if (
-              (code3 >= 65 && code3 <= 90) ||
-              (!event.shiftKey && code3 >= 48 && code3 <= 57) ||
-              (event.shiftKey && code3 === 189) ||
-              (event.shiftKey && code3 === 222)
-            ) {
-              _this.editor.execCommand("autocomplete");
-            }
-          };
-          _this._onEdit = function () {
-            if (!_this.editor) {
-              return;
-            }
-            if (!_this.ignoreChangeEvent) {
-              _this.cachedValue = _this.editor.getValue();
-              if (_this.props.onEdit) {
-                _this.props.onEdit(_this.cachedValue);
-              }
-            }
-          };
-          _this._onHasCompletion = function (instance, changeObj) {
-            onHasCompletion(
-              instance,
-              changeObj,
-              _this.props.onHintInformationRender
-            );
-          };
-          _this.cachedValue = props.value || "";
-          return _this;
-        }
-        VariableEditor2.prototype.componentDidMount = function () {
-          var _this = this;
-          this.initializeEditor()
-            .then(function (editor) {
-              editor.on("change", _this._onEdit);
-              editor.on("keyup", _this._onKeyUp);
-              editor.on("hasCompletion", _this._onHasCompletion);
-            })
-            .catch(console.error);
-        };
-        VariableEditor2.prototype.componentDidUpdate = function (prevProps) {
-          if (!this.editor) {
-            return;
-          }
-          if (!this.CodeMirror) {
-            return;
-          }
-          this.ignoreChangeEvent = true;
-          if (this.props.variableToType !== prevProps.variableToType) {
-            this.editor.options.lint.variableToType = this.props.variableToType;
-            this.editor.options.hintOptions.variableToType =
-              this.props.variableToType;
-            this.CodeMirror.signal(this.editor, "change", this.editor);
-          }
-          if (
-            this.props.value !== prevProps.value &&
-            this.props.value !== this.cachedValue
-          ) {
-            var thisValue = this.props.value || "";
-            this.cachedValue = thisValue;
-            this.editor.setValue(thisValue);
-          }
-          this.ignoreChangeEvent = false;
-        };
-        VariableEditor2.prototype.componentWillUnmount = function () {
-          if (!this.editor) {
-            return;
-          }
-          this.editor.off("change", this._onEdit);
-          this.editor.off("keyup", this._onKeyUp);
-          this.editor.off("hasCompletion", this._onHasCompletion);
-          this.editor = null;
-        };
-        VariableEditor2.prototype.render = function () {
-          var _this = this;
-          return React$1.createElement("div", {
-            className: "codemirrorWrap",
-            style: {
-              position: this.props.active ? "relative" : "absolute",
-              visibility: this.props.active ? "visible" : "hidden",
-            },
-            ref: function (node) {
-              _this._node = node;
-            },
-          });
-        };
-        VariableEditor2.prototype.initializeEditor = function () {
-          return __awaiter$4(this, void 0, void 0, function () {
-            var _a2, editor;
-            var _this = this;
-            return __generator$4(this, function (_b) {
-              switch (_b.label) {
-                case 0:
-                  _a2 = this;
-                  return [4, importCodeMirror(this.addonModules())];
-                case 1:
-                  _a2.CodeMirror = _b.sent();
-                  editor = this.editor = this.CodeMirror(this._node, {
-                    value: this.props.value || "",
-                    lineNumbers: true,
-                    tabSize: 2,
-                    mode: "graphql-variables",
-                    theme: this.props.editorTheme || "graphiql",
-                    keyMap: "sublime",
-                    autoCloseBrackets: true,
-                    matchBrackets: true,
-                    showCursorWhenSelecting: true,
-                    readOnly: this.props.readOnly ? "nocursor" : false,
-                    foldGutter: {
-                      minFoldSize: 4,
-                    },
-                    lint: {
-                      variableToType: this.props.variableToType,
-                    },
-                    hintOptions: {
-                      variableToType: this.props.variableToType,
-                      closeOnUnfocus: false,
-                      completeSingle: false,
-                      container: this._node,
-                    },
-                    gutters: [
-                      "CodeMirror-linenumbers",
-                      "CodeMirror-foldgutter",
-                    ],
-                    extraKeys: __assign$9(
-                      {
-                        "Cmd-Space": function () {
-                          return _this.editor.showHint({
-                            completeSingle: false,
-                            container: _this._node,
-                          });
-                        },
-                        "Ctrl-Space": function () {
-                          return _this.editor.showHint({
-                            completeSingle: false,
-                            container: _this._node,
-                          });
-                        },
-                        "Alt-Space": function () {
-                          return _this.editor.showHint({
-                            completeSingle: false,
-                            container: _this._node,
-                          });
-                        },
-                        "Shift-Space": function () {
-                          return _this.editor.showHint({
-                            completeSingle: false,
-                            container: _this._node,
-                          });
-                        },
-                        "Cmd-Enter": function () {
-                          if (_this.props.onRunQuery) {
-                            _this.props.onRunQuery();
-                          }
-                        },
-                        "Ctrl-Enter": function () {
-                          if (_this.props.onRunQuery) {
-                            _this.props.onRunQuery();
-                          }
-                        },
-                        "Shift-Ctrl-P": function () {
-                          if (_this.props.onPrettifyQuery) {
-                            _this.props.onPrettifyQuery();
-                          }
-                        },
-                        "Shift-Ctrl-M": function () {
-                          if (_this.props.onMergeQuery) {
-                            _this.props.onMergeQuery();
-                          }
-                        },
-                      },
-                      commonKeys
-                    ),
-                  });
-                  return [2, editor];
-              }
-            });
-          });
-        };
-        VariableEditor2.prototype.getCodeMirror = function () {
-          return this.editor;
-        };
-        VariableEditor2.prototype.getClientHeight = function () {
-          return this._node && this._node.clientHeight;
-        };
-        return VariableEditor2;
-      })(React$1.Component);
-      var __extends$9 =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var __assign$8 =
-        (globalThis && globalThis.__assign) ||
-        function () {
-          __assign$8 =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign$8.apply(this, arguments);
-        };
-      var __awaiter$3 =
-        (globalThis && globalThis.__awaiter) ||
-        function (thisArg, _arguments, P2, generator) {
-          function adopt(value) {
-            return value instanceof P2
-              ? value
-              : new P2(function (resolve) {
-                  resolve(value);
-                });
-          }
-          return new (P2 || (P2 = Promise))(function (resolve, reject2) {
-            function fulfilled(value) {
-              try {
-                step(generator.next(value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function rejected(value) {
-              try {
-                step(generator["throw"](value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function step(result2) {
-              result2.done
-                ? resolve(result2.value)
-                : adopt(result2.value).then(fulfilled, rejected);
-            }
-            step(
-              (generator = generator.apply(thisArg, _arguments || [])).next()
-            );
-          });
-        };
-      var __generator$3 =
-        (globalThis && globalThis.__generator) ||
-        function (thisArg, body) {
-          var _ = {
-              label: 0,
-              sent: function () {
-                if (t2[0] & 1) throw t2[1];
-                return t2[1];
-              },
-              trys: [],
-              ops: [],
-            },
-            f,
-            y2,
-            t2,
-            g;
-          return (
-            (g = { next: verb(0), throw: verb(1), return: verb(2) }),
-            typeof Symbol === "function" &&
-              (g[Symbol.iterator] = function () {
-                return this;
-              }),
-            g
-          );
-          function verb(n2) {
-            return function (v2) {
-              return step([n2, v2]);
-            };
-          }
-          function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_)
-              try {
-                if (
-                  ((f = 1),
-                  y2 &&
-                    (t2 =
-                      op[0] & 2
-                        ? y2["return"]
-                        : op[0]
-                        ? y2["throw"] || ((t2 = y2["return"]) && t2.call(y2), 0)
-                        : y2.next) &&
-                    !(t2 = t2.call(y2, op[1])).done)
-                )
-                  return t2;
-                if (((y2 = 0), t2)) op = [op[0] & 2, t2.value];
-                switch (op[0]) {
-                  case 0:
-                  case 1:
-                    t2 = op;
-                    break;
-                  case 4:
-                    _.label++;
-                    return { value: op[1], done: false };
-                  case 5:
-                    _.label++;
-                    y2 = op[1];
-                    op = [0];
-                    continue;
-                  case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                  default:
-                    if (
-                      !((t2 = _.trys),
-                      (t2 = t2.length > 0 && t2[t2.length - 1])) &&
-                      (op[0] === 6 || op[0] === 2)
-                    ) {
-                      _ = 0;
-                      continue;
-                    }
-                    if (
-                      op[0] === 3 &&
-                      (!t2 || (op[1] > t2[0] && op[1] < t2[3]))
-                    ) {
-                      _.label = op[1];
-                      break;
-                    }
-                    if (op[0] === 6 && _.label < t2[1]) {
-                      _.label = t2[1];
-                      t2 = op;
-                      break;
-                    }
-                    if (t2 && _.label < t2[2]) {
-                      _.label = t2[2];
-                      _.ops.push(op);
-                      break;
-                    }
-                    if (t2[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                }
-                op = body.call(thisArg, _);
-              } catch (e) {
-                op = [6, e];
-                y2 = 0;
-              } finally {
-                f = t2 = 0;
-              }
-            if (op[0] & 5) throw op[1];
-            return { value: op[0] ? op[1] : void 0, done: true };
-          }
-        };
-      var HeaderEditor = (function (_super2) {
-        __extends$9(HeaderEditor2, _super2);
-        function HeaderEditor2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this.editor = null;
-          _this._node = null;
-          _this.ignoreChangeEvent = false;
-          _this.addonModules = function () {
-            return [
-              Promise.resolve().then(function () {
-                return javascript$1;
-              }),
-            ];
-          };
-          _this._onKeyUp = function (_cm, event) {
-            var code3 = event.keyCode;
-            if (!_this.editor) {
-              return;
-            }
-            if (
-              (code3 >= 65 && code3 <= 90) ||
-              (!event.shiftKey && code3 >= 48 && code3 <= 57) ||
-              (event.shiftKey && code3 === 189) ||
-              (event.shiftKey && code3 === 222)
-            ) {
-              _this.editor.execCommand("autocomplete");
-            }
-          };
-          _this._onEdit = function () {
-            if (!_this.editor) {
-              return;
-            }
-            if (!_this.ignoreChangeEvent) {
-              _this.cachedValue = _this.editor.getValue();
-              if (_this.props.onEdit) {
-                _this.props.onEdit(_this.cachedValue);
-              }
-            }
-          };
-          _this._onHasCompletion = function (instance, changeObj) {
-            onHasCompletion(
-              instance,
-              changeObj,
-              _this.props.onHintInformationRender
-            );
-          };
-          _this.cachedValue = props.value || "";
-          return _this;
-        }
-        HeaderEditor2.prototype.componentDidMount = function () {
-          var _this = this;
-          this.initializeEditor()
-            .then(function (editor) {
-              editor.on("change", _this._onEdit);
-              editor.on("keyup", _this._onKeyUp);
-              editor.on("hasCompletion", _this._onHasCompletion);
-            })
-            .catch(console.error);
-        };
-        HeaderEditor2.prototype.componentDidUpdate = function (prevProps) {
-          if (!this.editor) {
-            return;
-          }
-          this.ignoreChangeEvent = true;
-          if (
-            this.props.value !== prevProps.value &&
-            this.props.value !== this.cachedValue
-          ) {
-            var thisValue = this.props.value || "";
-            this.cachedValue = thisValue;
-            this.editor.setValue(thisValue);
-          }
-          this.ignoreChangeEvent = false;
-        };
-        HeaderEditor2.prototype.componentWillUnmount = function () {
-          if (!this.editor) {
-            return;
-          }
-          this.editor.off("change", this._onEdit);
-          this.editor.off("keyup", this._onKeyUp);
-          this.editor.off("hasCompletion", this._onHasCompletion);
-          this.editor = null;
-        };
-        HeaderEditor2.prototype.render = function () {
-          var _this = this;
-          return React$1.createElement("div", {
-            className: "codemirrorWrap",
-            style: {
-              position: this.props.active ? "relative" : "absolute",
-              visibility: this.props.active ? "visible" : "hidden",
-            },
-            ref: function (node) {
-              _this._node = node;
-            },
-          });
-        };
-        HeaderEditor2.prototype.initializeEditor = function () {
-          return __awaiter$3(this, void 0, void 0, function () {
-            var _a2, editor;
-            var _this = this;
-            return __generator$3(this, function (_b) {
-              switch (_b.label) {
-                case 0:
-                  _a2 = this;
-                  return [4, importCodeMirror(this.addonModules())];
-                case 1:
-                  _a2.CodeMirror = _b.sent();
-                  editor = this.editor = this.CodeMirror(this._node, {
-                    value: this.props.value || "",
-                    lineNumbers: true,
-                    tabSize: 2,
-                    mode: { name: "javascript", json: true },
-                    theme: this.props.editorTheme || "graphiql",
-                    keyMap: "sublime",
-                    autoCloseBrackets: true,
-                    matchBrackets: true,
-                    showCursorWhenSelecting: true,
-                    readOnly: this.props.readOnly ? "nocursor" : false,
-                    foldGutter: {
-                      minFoldSize: 4,
-                    },
-                    gutters: [
-                      "CodeMirror-linenumbers",
-                      "CodeMirror-foldgutter",
-                    ],
-                    extraKeys: __assign$8(
-                      {
-                        "Cmd-Space": function () {
-                          return _this.editor.showHint({
-                            completeSingle: false,
-                            container: _this._node,
-                          });
-                        },
-                        "Ctrl-Space": function () {
-                          return _this.editor.showHint({
-                            completeSingle: false,
-                            container: _this._node,
-                          });
-                        },
-                        "Alt-Space": function () {
-                          return _this.editor.showHint({
-                            completeSingle: false,
-                            container: _this._node,
-                          });
-                        },
-                        "Shift-Space": function () {
-                          return _this.editor.showHint({
-                            completeSingle: false,
-                            container: _this._node,
-                          });
-                        },
-                        "Cmd-Enter": function () {
-                          if (_this.props.onRunQuery) {
-                            _this.props.onRunQuery();
-                          }
-                        },
-                        "Ctrl-Enter": function () {
-                          if (_this.props.onRunQuery) {
-                            _this.props.onRunQuery();
-                          }
-                        },
-                        "Shift-Ctrl-P": function () {
-                          if (_this.props.onPrettifyQuery) {
-                            _this.props.onPrettifyQuery();
-                          }
-                        },
-                        "Shift-Ctrl-M": function () {
-                          if (_this.props.onMergeQuery) {
-                            _this.props.onMergeQuery();
-                          }
-                        },
-                      },
-                      commonKeys
-                    ),
-                  });
-                  return [2, editor];
-              }
-            });
-          });
-        };
-        HeaderEditor2.prototype.getCodeMirror = function () {
-          return this.editor;
-        };
-        HeaderEditor2.prototype.getClientHeight = function () {
-          return this._node && this._node.clientHeight;
-        };
-        return HeaderEditor2;
-      })(React$1.Component);
-      var __extends$8 =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var __awaiter$2 =
-        (globalThis && globalThis.__awaiter) ||
-        function (thisArg, _arguments, P2, generator) {
-          function adopt(value) {
-            return value instanceof P2
-              ? value
-              : new P2(function (resolve) {
-                  resolve(value);
-                });
-          }
-          return new (P2 || (P2 = Promise))(function (resolve, reject2) {
-            function fulfilled(value) {
-              try {
-                step(generator.next(value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function rejected(value) {
-              try {
-                step(generator["throw"](value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function step(result2) {
-              result2.done
-                ? resolve(result2.value)
-                : adopt(result2.value).then(fulfilled, rejected);
-            }
-            step(
-              (generator = generator.apply(thisArg, _arguments || [])).next()
-            );
-          });
-        };
-      var __generator$2 =
-        (globalThis && globalThis.__generator) ||
-        function (thisArg, body) {
-          var _ = {
-              label: 0,
-              sent: function () {
-                if (t2[0] & 1) throw t2[1];
-                return t2[1];
-              },
-              trys: [],
-              ops: [],
-            },
-            f,
-            y2,
-            t2,
-            g;
-          return (
-            (g = { next: verb(0), throw: verb(1), return: verb(2) }),
-            typeof Symbol === "function" &&
-              (g[Symbol.iterator] = function () {
-                return this;
-              }),
-            g
-          );
-          function verb(n2) {
-            return function (v2) {
-              return step([n2, v2]);
-            };
-          }
-          function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_)
-              try {
-                if (
-                  ((f = 1),
-                  y2 &&
-                    (t2 =
-                      op[0] & 2
-                        ? y2["return"]
-                        : op[0]
-                        ? y2["throw"] || ((t2 = y2["return"]) && t2.call(y2), 0)
-                        : y2.next) &&
-                    !(t2 = t2.call(y2, op[1])).done)
-                )
-                  return t2;
-                if (((y2 = 0), t2)) op = [op[0] & 2, t2.value];
-                switch (op[0]) {
-                  case 0:
-                  case 1:
-                    t2 = op;
-                    break;
-                  case 4:
-                    _.label++;
-                    return { value: op[1], done: false };
-                  case 5:
-                    _.label++;
-                    y2 = op[1];
-                    op = [0];
-                    continue;
-                  case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                  default:
-                    if (
-                      !((t2 = _.trys),
-                      (t2 = t2.length > 0 && t2[t2.length - 1])) &&
-                      (op[0] === 6 || op[0] === 2)
-                    ) {
-                      _ = 0;
-                      continue;
-                    }
-                    if (
-                      op[0] === 3 &&
-                      (!t2 || (op[1] > t2[0] && op[1] < t2[3]))
-                    ) {
-                      _.label = op[1];
-                      break;
-                    }
-                    if (op[0] === 6 && _.label < t2[1]) {
-                      _.label = t2[1];
-                      t2 = op;
-                      break;
-                    }
-                    if (t2 && _.label < t2[2]) {
-                      _.label = t2[2];
-                      _.ops.push(op);
-                      break;
-                    }
-                    if (t2[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                }
-                op = body.call(thisArg, _);
-              } catch (e) {
-                op = [6, e];
-                y2 = 0;
-              } finally {
-                f = t2 = 0;
-              }
-            if (op[0] & 5) throw op[1];
-            return { value: op[0] ? op[1] : void 0, done: true };
-          }
-        };
-      var ResultViewer = (function (_super2) {
-        __extends$8(ResultViewer2, _super2);
-        function ResultViewer2() {
-          var _this =
-            (_super2 !== null && _super2.apply(this, arguments)) || this;
-          _this.viewer = null;
-          _this._node = null;
-          _this.allAddons = function () {
-            return [
-              Promise.resolve().then(function () {
-                return foldgutter$1;
-              }),
-              Promise.resolve().then(function () {
-                return braceFold$1;
-              }),
-              Promise.resolve().then(function () {
-                return dialog$1;
-              }),
-              Promise.resolve().then(function () {
-                return search$1;
-              }),
-              Promise.resolve().then(function () {
-                return searchcursor$1;
-              }),
-              Promise.resolve().then(function () {
-                return jumpToLine$1;
-              }),
-              Promise.resolve().then(function () {
-                return sublime$1;
-              }),
-              Promise.resolve().then(function () {
-                return mode;
-              }),
-            ];
-          };
-          return _this;
-        }
-        ResultViewer2.prototype.componentDidMount = function () {
-          this.initializeEditor();
-        };
-        ResultViewer2.prototype.shouldComponentUpdate = function (nextProps) {
-          return this.props.value !== nextProps.value;
-        };
-        ResultViewer2.prototype.componentDidUpdate = function () {
-          if (this.viewer) {
-            this.viewer.setValue(this.props.value || "");
-          }
-        };
-        ResultViewer2.prototype.componentWillUnmount = function () {
-          this.viewer = null;
-        };
-        ResultViewer2.prototype.render = function () {
-          var _this = this;
-          return React$1.createElement("section", {
-            className: "result-window",
-            "aria-label": "Result Window",
-            "aria-live": "polite",
-            "aria-atomic": "true",
-            ref: function (node) {
-              if (node) {
-                _this.props.registerRef(node);
-                _this._node = node;
-              }
-            },
-          });
-        };
-        ResultViewer2.prototype.initializeEditor = function () {
-          return __awaiter$2(this, void 0, void 0, function () {
-            var CodeMirror, Tooltip, ImagePreview2, tooltipDiv_1;
-            return __generator$2(this, function (_a2) {
-              switch (_a2.label) {
-                case 0:
-                  return [
-                    4,
-                    importCodeMirror(this.allAddons(), {
-                      useCommonAddons: false,
-                    }),
-                  ];
-                case 1:
-                  CodeMirror = _a2.sent();
-                  Tooltip = this.props.ResultsTooltip;
-                  ImagePreview2 = this.props.ImagePreview;
-                  if (!(Tooltip || ImagePreview2)) return [3, 3];
-                  return [
-                    4,
-                    Promise.resolve().then(function () {
-                      return infoAddon;
-                    }),
-                  ];
-                case 2:
-                  _a2.sent();
-                  tooltipDiv_1 = document.createElement("div");
-                  CodeMirror.registerHelper(
-                    "info",
-                    "graphql-results",
-                    function (token2, _options, _cm, pos) {
-                      var infoElements = [];
-                      if (Tooltip) {
-                        infoElements.push(
-                          React$1.createElement(Tooltip, { pos })
-                        );
-                      }
-                      if (
-                        ImagePreview2 &&
-                        typeof ImagePreview2.shouldRender === "function" &&
-                        ImagePreview2.shouldRender(token2)
-                      ) {
-                        infoElements.push(
-                          React$1.createElement(ImagePreview2, {
-                            token: token2,
-                          })
-                        );
-                      }
-                      if (!infoElements.length) {
-                        ReactDOM.unmountComponentAtNode(tooltipDiv_1);
-                        return null;
-                      }
-                      ReactDOM.render(
-                        React$1.createElement("div", null, infoElements),
-                        tooltipDiv_1
-                      );
-                      return tooltipDiv_1;
-                    }
-                  );
-                  _a2.label = 3;
-                case 3:
-                  this.viewer = CodeMirror(this._node, {
-                    lineWrapping: true,
-                    value: this.props.value || "",
-                    readOnly: true,
-                    theme: this.props.editorTheme || "graphiql",
-                    mode: "graphql-results",
-                    keyMap: "sublime",
-                    foldGutter: {
-                      minFoldSize: 4,
-                    },
-                    gutters: ["CodeMirror-foldgutter"],
-                    info: Boolean(
-                      this.props.ResultsTooltip || this.props.ImagePreview
-                    ),
-                    extraKeys: commonKeys,
-                  });
-                  return [2];
-              }
-            });
-          });
-        };
-        ResultViewer2.prototype.getCodeMirror = function () {
-          return this.viewer;
-        };
-        ResultViewer2.prototype.getClientHeight = function () {
-          return this._node && this._node.clientHeight;
-        };
-        return ResultViewer2;
-      })(React$1.Component);
-      function TypeLink(props) {
-        var onClick = props.onClick
-          ? props.onClick
-          : function () {
-              return null;
-            };
-        return renderType$1(props.type, onClick);
-      }
-      function renderType$1(type2, onClick) {
-        if (type2 instanceof GraphQLNonNull) {
-          return React$1.createElement(
-            "span",
-            null,
-            renderType$1(type2.ofType, onClick),
-            "!"
-          );
-        }
-        if (type2 instanceof GraphQLList) {
-          return React$1.createElement(
-            "span",
-            null,
-            "[",
-            renderType$1(type2.ofType, onClick),
-            "]"
-          );
-        }
-        return React$1.createElement(
-          "a",
-          {
-            className: "type-name",
-            onClick: function (event) {
-              event.preventDefault();
-              onClick(type2, event);
-            },
-            href: "#",
-          },
-          type2 === null || type2 === void 0 ? void 0 : type2.name
-        );
-      }
-      var printDefault = function (ast2) {
-        if (!ast2) {
-          return "";
-        }
-        return print(ast2);
-      };
-      function DefaultValue(_a2) {
-        var field = _a2.field;
-        if ("defaultValue" in field && field.defaultValue !== void 0) {
-          return React$1.createElement(
-            "span",
-            null,
-            " = ",
-            React$1.createElement(
-              "span",
-              { className: "arg-default-value" },
-              printDefault(astFromValue(field.defaultValue, field.type))
-            )
-          );
-        }
-        return null;
-      }
-      function Argument(_a2) {
-        var arg = _a2.arg,
-          onClickType = _a2.onClickType,
-          showDefaultValue = _a2.showDefaultValue;
-        return React$1.createElement(
-          "span",
-          { className: "arg" },
-          React$1.createElement("span", { className: "arg-name" }, arg.name),
-          ": ",
-          React$1.createElement(TypeLink, {
-            type: arg.type,
-            onClick: onClickType,
-          }),
-          showDefaultValue !== false &&
-            React$1.createElement(DefaultValue, { field: arg })
-        );
-      }
-      function Directive(_a2) {
-        var directive = _a2.directive;
-        return React$1.createElement(
-          "span",
-          { className: "doc-category-item", id: directive.name.value },
-          "@",
-          directive.name.value
-        );
-      }
-      var md = new markdownIt({
-        breaks: true,
-        linkify: true,
-      });
-      function MarkdownContent(_a2) {
-        var markdown = _a2.markdown,
-          className = _a2.className;
-        if (!markdown) {
-          return React$1.createElement("div", null);
-        }
-        return React$1.createElement("div", {
-          className,
-          dangerouslySetInnerHTML: { __html: md.render(markdown) },
-        });
-      }
-      var __read$5 =
-        (globalThis && globalThis.__read) ||
-        function (o, n2) {
-          var m = typeof Symbol === "function" && o[Symbol.iterator];
-          if (!m) return o;
-          var i = m.call(o),
-            r2,
-            ar = [],
-            e;
-          try {
-            while ((n2 === void 0 || n2-- > 0) && !(r2 = i.next()).done)
-              ar.push(r2.value);
-          } catch (error2) {
-            e = { error: error2 };
-          } finally {
-            try {
-              if (r2 && !r2.done && (m = i["return"])) m.call(i);
-            } finally {
-              if (e) throw e.error;
-            }
-          }
-          return ar;
-        };
-      function FieldDoc(_a2) {
-        var field = _a2.field,
-          onClickType = _a2.onClickType;
-        var _b = __read$5(React$1.useState(false), 2),
-          showDeprecated = _b[0],
-          handleShowDeprecated = _b[1];
-        var argsDef;
-        var deprecatedArgsDef;
-        if (field && "args" in field && field.args.length > 0) {
-          argsDef = React$1.createElement(
-            "div",
-            { id: "doc-args", className: "doc-category" },
-            React$1.createElement(
-              "div",
-              { className: "doc-category-title" },
-              "arguments"
-            ),
-            field.args
-              .filter(function (arg) {
-                return !arg.deprecationReason;
-              })
-              .map(function (arg) {
-                return React$1.createElement(
-                  "div",
-                  { key: arg.name, className: "doc-category-item" },
-                  React$1.createElement(
-                    "div",
-                    null,
-                    React$1.createElement(Argument, { arg, onClickType })
-                  ),
-                  React$1.createElement(MarkdownContent, {
-                    className: "doc-value-description",
-                    markdown: arg.description,
-                  }),
-                  arg &&
-                    "deprecationReason" in arg &&
-                    React$1.createElement(MarkdownContent, {
-                      className: "doc-deprecation",
-                      markdown:
-                        arg === null || arg === void 0
-                          ? void 0
-                          : arg.deprecationReason,
-                    })
-                );
-              })
-          );
-          var deprecatedArgs = field.args.filter(function (arg) {
-            return Boolean(arg.deprecationReason);
-          });
-          if (deprecatedArgs.length > 0) {
-            deprecatedArgsDef = React$1.createElement(
-              "div",
-              { id: "doc-deprecated-args", className: "doc-category" },
-              React$1.createElement(
-                "div",
-                { className: "doc-category-title" },
-                "deprecated arguments"
-              ),
-              !showDeprecated
-                ? React$1.createElement(
-                    "button",
-                    {
-                      className: "show-btn",
-                      onClick: function () {
-                        return handleShowDeprecated(!showDeprecated);
-                      },
-                    },
-                    "Show deprecated arguments..."
-                  )
-                : deprecatedArgs.map(function (arg, i) {
-                    return React$1.createElement(
-                      "div",
-                      { key: i },
-                      React$1.createElement(
-                        "div",
-                        null,
-                        React$1.createElement(Argument, { arg, onClickType })
-                      ),
-                      React$1.createElement(MarkdownContent, {
-                        className: "doc-value-description",
-                        markdown: arg.description,
-                      }),
-                      arg &&
-                        "deprecationReason" in arg &&
-                        React$1.createElement(MarkdownContent, {
-                          className: "doc-deprecation",
-                          markdown:
-                            arg === null || arg === void 0
-                              ? void 0
-                              : arg.deprecationReason,
-                        })
-                    );
-                  })
-            );
-          }
-        }
-        var directivesDef;
-        if (
-          field &&
-          field.astNode &&
-          field.astNode.directives &&
-          field.astNode.directives.length > 0
-        ) {
-          directivesDef = React$1.createElement(
-            "div",
-            { id: "doc-directives", className: "doc-category" },
-            React$1.createElement(
-              "div",
-              { className: "doc-category-title" },
-              "directives"
-            ),
-            field.astNode.directives.map(function (directive) {
-              return React$1.createElement(
-                "div",
-                { key: directive.name.value, className: "doc-category-item" },
-                React$1.createElement(
-                  "div",
-                  null,
-                  React$1.createElement(Directive, { directive })
-                )
-              );
-            })
-          );
-        }
-        return React$1.createElement(
-          "div",
-          null,
-          React$1.createElement(MarkdownContent, {
-            className: "doc-type-description",
-            markdown:
-              (field === null || field === void 0
-                ? void 0
-                : field.description) || "No Description",
-          }),
-          field &&
-            "deprecationReason" in field &&
-            React$1.createElement(MarkdownContent, {
-              className: "doc-deprecation",
-              markdown:
-                field === null || field === void 0
-                  ? void 0
-                  : field.deprecationReason,
-            }),
-          React$1.createElement(
-            "div",
-            { className: "doc-category" },
-            React$1.createElement(
-              "div",
-              { className: "doc-category-title" },
-              "type"
-            ),
-            React$1.createElement(TypeLink, {
-              type: field === null || field === void 0 ? void 0 : field.type,
-              onClick: onClickType,
-            })
-          ),
-          argsDef,
-          directivesDef,
-          deprecatedArgsDef
-        );
-      }
-      function SchemaDoc(_a2) {
-        var schema = _a2.schema,
-          onClickType = _a2.onClickType;
-        var queryType = schema.getQueryType();
-        var mutationType = schema.getMutationType && schema.getMutationType();
-        var subscriptionType =
-          schema.getSubscriptionType && schema.getSubscriptionType();
-        return React$1.createElement(
-          "div",
-          null,
-          React$1.createElement(MarkdownContent, {
-            className: "doc-type-description",
-            markdown:
-              schema.description ||
-              "A GraphQL schema provides a root type for each kind of operation.",
-          }),
-          React$1.createElement(
-            "div",
-            { className: "doc-category" },
-            React$1.createElement(
-              "div",
-              { className: "doc-category-title" },
-              "root types"
-            ),
-            React$1.createElement(
-              "div",
-              { className: "doc-category-item" },
-              React$1.createElement("span", { className: "keyword" }, "query"),
-              ": ",
-              React$1.createElement(TypeLink, {
-                type: queryType,
-                onClick: onClickType,
-              })
-            ),
-            mutationType &&
-              React$1.createElement(
-                "div",
-                { className: "doc-category-item" },
-                React$1.createElement(
-                  "span",
-                  { className: "keyword" },
-                  "mutation"
-                ),
-                ": ",
-                React$1.createElement(TypeLink, {
-                  type: mutationType,
-                  onClick: onClickType,
-                })
-              ),
-            subscriptionType &&
-              React$1.createElement(
-                "div",
-                { className: "doc-category-item" },
-                React$1.createElement(
-                  "span",
-                  { className: "keyword" },
-                  "subscription"
-                ),
-                ": ",
-                React$1.createElement(TypeLink, {
-                  type: subscriptionType,
-                  onClick: onClickType,
-                })
-              )
-          )
-        );
-      }
-      function debounce(duration, fn) {
-        var timeout;
-        return function () {
-          var _this = this;
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-          }
-          if (timeout) {
-            window.clearTimeout(timeout);
-          }
-          timeout = window.setTimeout(function () {
-            timeout = null;
-            fn.apply(_this, args);
-          }, duration);
-        };
-      }
-      var __extends$7 =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var SearchBox = (function (_super2) {
-        __extends$7(SearchBox2, _super2);
-        function SearchBox2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this.handleChange = function (event) {
-            var value = event.currentTarget.value;
-            _this.setState({ value });
-            _this.debouncedOnSearch(value);
-          };
-          _this.handleClear = function () {
-            _this.setState({ value: "" });
-            _this.props.onSearch("");
-          };
-          _this.state = { value: props.value || "" };
-          _this.debouncedOnSearch = debounce(200, _this.props.onSearch);
-          return _this;
-        }
-        SearchBox2.prototype.render = function () {
-          return React$1.createElement(
-            "label",
-            { className: "search-box" },
-            React$1.createElement(
-              "div",
-              { className: "search-box-icon", "aria-hidden": "true" },
-              "\u26B2"
-            ),
-            React$1.createElement("input", {
-              value: this.state.value,
-              onChange: this.handleChange,
-              type: "text",
-              placeholder: this.props.placeholder,
-              "aria-label": this.props.placeholder,
-            }),
-            this.state.value &&
-              React$1.createElement(
-                "button",
-                {
-                  className: "search-box-clear",
-                  onClick: this.handleClear,
-                  "aria-label": "Clear search input",
-                },
-                "\u2715"
-              )
-          );
-        };
-        return SearchBox2;
-      })(React$1.Component);
-      var __extends$6 =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var __values$3 =
-        (globalThis && globalThis.__values) ||
-        function (o) {
-          var s = typeof Symbol === "function" && Symbol.iterator,
-            m = s && o[s],
-            i = 0;
-          if (m) return m.call(o);
-          if (o && typeof o.length === "number")
-            return {
-              next: function () {
-                if (o && i >= o.length) o = void 0;
-                return { value: o && o[i++], done: !o };
-              },
-            };
-          throw new TypeError(
-            s ? "Object is not iterable." : "Symbol.iterator is not defined."
-          );
-        };
-      var SearchResults = (function (_super2) {
-        __extends$6(SearchResults2, _super2);
-        function SearchResults2() {
-          return (_super2 !== null && _super2.apply(this, arguments)) || this;
-        }
-        SearchResults2.prototype.shouldComponentUpdate = function (nextProps) {
-          return (
-            this.props.schema !== nextProps.schema ||
-            this.props.searchValue !== nextProps.searchValue
-          );
-        };
-        SearchResults2.prototype.render = function () {
-          var e_1, _a2;
-          var searchValue = this.props.searchValue;
-          var withinType = this.props.withinType;
-          var schema = this.props.schema;
-          var onClickType = this.props.onClickType;
-          var onClickField = this.props.onClickField;
-          var matchedWithin = [];
-          var matchedTypes = [];
-          var matchedFields = [];
-          var typeMap = schema.getTypeMap();
-          var typeNames = Object.keys(typeMap);
-          if (withinType) {
-            typeNames = typeNames.filter(function (n2) {
-              return n2 !== withinType.name;
-            });
-            typeNames.unshift(withinType.name);
-          }
-          var _loop_1 = function (typeName2) {
-            if (
-              matchedWithin.length +
-                matchedTypes.length +
-                matchedFields.length >=
-              100
-            ) {
-              return "break";
-            }
-            var type2 = typeMap[typeName2];
-            if (withinType !== type2 && isMatch(typeName2, searchValue)) {
-              matchedTypes.push(
-                React$1.createElement(
-                  "div",
-                  { className: "doc-category-item", key: typeName2 },
-                  React$1.createElement(TypeLink, {
-                    type: type2,
-                    onClick: onClickType,
-                  })
-                )
-              );
-            }
-            if (type2 && "getFields" in type2) {
-              var fields_1 = type2.getFields();
-              Object.keys(fields_1).forEach(function (fieldName) {
-                var field = fields_1[fieldName];
-                var matchingArgs;
-                if (!isMatch(fieldName, searchValue)) {
-                  if ("args" in field && field.args.length) {
-                    matchingArgs = field.args.filter(function (arg) {
-                      return isMatch(arg.name, searchValue);
-                    });
-                    if (matchingArgs.length === 0) {
-                      return;
-                    }
-                  } else {
-                    return;
-                  }
-                }
-                var match2 = React$1.createElement(
-                  "div",
-                  {
-                    className: "doc-category-item",
-                    key: typeName2 + "." + fieldName,
-                  },
-                  withinType !== type2 && [
-                    React$1.createElement(TypeLink, {
-                      key: "type",
-                      type: type2,
-                      onClick: onClickType,
-                    }),
-                    ".",
-                  ],
-                  React$1.createElement(
-                    "a",
-                    {
-                      className: "field-name",
-                      onClick: function (event) {
-                        return onClickField(field, type2, event);
-                      },
-                    },
-                    field.name
-                  ),
-                  matchingArgs && [
-                    "(",
-                    React$1.createElement(
-                      "span",
-                      { key: "args" },
-                      matchingArgs.map(function (arg) {
-                        return React$1.createElement(Argument, {
-                          key: arg.name,
-                          arg,
-                          onClickType,
-                          showDefaultValue: false,
-                        });
-                      })
-                    ),
-                    ")",
-                  ]
-                );
-                if (withinType === type2) {
-                  matchedWithin.push(match2);
-                } else {
-                  matchedFields.push(match2);
-                }
-              });
-            }
-          };
-          try {
-            for (
-              var typeNames_1 = __values$3(typeNames),
-                typeNames_1_1 = typeNames_1.next();
-              !typeNames_1_1.done;
-              typeNames_1_1 = typeNames_1.next()
-            ) {
-              var typeName = typeNames_1_1.value;
-              var state_1 = _loop_1(typeName);
-              if (state_1 === "break") break;
-            }
-          } catch (e_1_1) {
-            e_1 = { error: e_1_1 };
-          } finally {
-            try {
-              if (
-                typeNames_1_1 &&
-                !typeNames_1_1.done &&
-                (_a2 = typeNames_1.return)
-              )
-                _a2.call(typeNames_1);
-            } finally {
-              if (e_1) throw e_1.error;
-            }
-          }
-          if (
-            matchedWithin.length +
-              matchedTypes.length +
-              matchedFields.length ===
-            0
-          ) {
-            return React$1.createElement(
-              "span",
-              { className: "doc-alert-text" },
-              "No results found."
-            );
-          }
-          if (withinType && matchedTypes.length + matchedFields.length > 0) {
-            return React$1.createElement(
-              "div",
-              null,
-              matchedWithin,
-              React$1.createElement(
-                "div",
-                { className: "doc-category" },
-                React$1.createElement(
-                  "div",
-                  { className: "doc-category-title" },
-                  "other results"
-                ),
-                matchedTypes,
-                matchedFields
-              )
-            );
-          }
-          return React$1.createElement(
-            "div",
-            { className: "doc-search-items" },
-            matchedWithin,
-            matchedTypes,
-            matchedFields
-          );
-        };
-        return SearchResults2;
-      })(React$1.Component);
-      function isMatch(sourceText, searchValue) {
-        try {
-          var escaped = searchValue.replace(/[^_0-9A-Za-z]/g, function (ch2) {
-            return "\\" + ch2;
-          });
-          return sourceText.search(new RegExp(escaped, "i")) !== -1;
-        } catch (e) {
-          return (
-            sourceText.toLowerCase().indexOf(searchValue.toLowerCase()) !== -1
-          );
-        }
-      }
-      var __extends$5 =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var TypeDoc = (function (_super2) {
-        __extends$5(TypeDoc2, _super2);
-        function TypeDoc2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this.handleShowDeprecated = function () {
-            return _this.setState({ showDeprecated: true });
-          };
-          _this.state = { showDeprecated: false };
-          return _this;
-        }
-        TypeDoc2.prototype.shouldComponentUpdate = function (
-          nextProps,
-          nextState
-        ) {
-          return (
-            this.props.type !== nextProps.type ||
-            this.props.schema !== nextProps.schema ||
-            this.state.showDeprecated !== nextState.showDeprecated
-          );
-        };
-        TypeDoc2.prototype.render = function () {
-          var schema = this.props.schema;
-          var type2 = this.props.type;
-          var onClickType = this.props.onClickType;
-          var onClickField = this.props.onClickField;
-          var typesTitle = null;
-          var types = [];
-          if (type2 instanceof GraphQLUnionType) {
-            typesTitle = "possible types";
-            types = schema.getPossibleTypes(type2);
-          } else if (type2 instanceof GraphQLInterfaceType) {
-            typesTitle = "implementations";
-            types = schema.getPossibleTypes(type2);
-          } else if (type2 instanceof GraphQLObjectType) {
-            typesTitle = "implements";
-            types = type2.getInterfaces();
-          }
-          var typesDef;
-          if (types && types.length > 0) {
-            typesDef = React$1.createElement(
-              "div",
-              { id: "doc-types", className: "doc-category" },
-              React$1.createElement(
-                "div",
-                { className: "doc-category-title" },
-                typesTitle
-              ),
-              types.map(function (subtype) {
-                return React$1.createElement(
-                  "div",
-                  { key: subtype.name, className: "doc-category-item" },
-                  React$1.createElement(TypeLink, {
-                    type: subtype,
-                    onClick: onClickType,
-                  })
-                );
-              })
-            );
-          }
-          var fieldsDef;
-          var deprecatedFieldsDef;
-          if (type2 && "getFields" in type2) {
-            var fieldMap_1 = type2.getFields();
-            var fields = Object.keys(fieldMap_1).map(function (name2) {
-              return fieldMap_1[name2];
-            });
-            fieldsDef = React$1.createElement(
-              "div",
-              { id: "doc-fields", className: "doc-category" },
-              React$1.createElement(
-                "div",
-                { className: "doc-category-title" },
-                "fields"
-              ),
-              fields
-                .filter(function (field) {
-                  return !field.deprecationReason;
-                })
-                .map(function (field) {
-                  return React$1.createElement(Field, {
-                    key: field.name,
-                    type: type2,
-                    field,
-                    onClickType,
-                    onClickField,
-                  });
-                })
-            );
-            var deprecatedFields = fields.filter(function (field) {
-              return Boolean(field.deprecationReason);
-            });
-            if (deprecatedFields.length > 0) {
-              deprecatedFieldsDef = React$1.createElement(
-                "div",
-                { id: "doc-deprecated-fields", className: "doc-category" },
-                React$1.createElement(
-                  "div",
-                  { className: "doc-category-title" },
-                  "deprecated fields"
-                ),
-                !this.state.showDeprecated
-                  ? React$1.createElement(
-                      "button",
-                      {
-                        className: "show-btn",
-                        onClick: this.handleShowDeprecated,
-                      },
-                      "Show deprecated fields..."
-                    )
-                  : deprecatedFields.map(function (field) {
-                      return React$1.createElement(Field, {
-                        key: field.name,
-                        type: type2,
-                        field,
-                        onClickType,
-                        onClickField,
-                      });
-                    })
-              );
-            }
-          }
-          var valuesDef;
-          var deprecatedValuesDef;
-          if (type2 instanceof GraphQLEnumType) {
-            var values = type2.getValues();
-            valuesDef = React$1.createElement(
-              "div",
-              { className: "doc-category" },
-              React$1.createElement(
-                "div",
-                { className: "doc-category-title" },
-                "values"
-              ),
-              values
-                .filter(function (value) {
-                  return Boolean(!value.deprecationReason);
-                })
-                .map(function (value) {
-                  return React$1.createElement(EnumValue, {
-                    key: value.name,
-                    value,
-                  });
-                })
-            );
-            var deprecatedValues = values.filter(function (value) {
-              return Boolean(value.deprecationReason);
-            });
-            if (deprecatedValues.length > 0) {
-              deprecatedValuesDef = React$1.createElement(
-                "div",
-                { className: "doc-category" },
-                React$1.createElement(
-                  "div",
-                  { className: "doc-category-title" },
-                  "deprecated values"
-                ),
-                !this.state.showDeprecated
-                  ? React$1.createElement(
-                      "button",
-                      {
-                        className: "show-btn",
-                        onClick: this.handleShowDeprecated,
-                      },
-                      "Show deprecated values..."
-                    )
-                  : deprecatedValues.map(function (value) {
-                      return React$1.createElement(EnumValue, {
-                        key: value.name,
-                        value,
-                      });
-                    })
-              );
-            }
-          }
-          return React$1.createElement(
-            "div",
-            null,
-            React$1.createElement(MarkdownContent, {
-              className: "doc-type-description",
-              markdown:
-                ("description" in type2 && type2.description) ||
-                "No Description",
-            }),
-            type2 instanceof GraphQLObjectType && typesDef,
-            fieldsDef,
-            deprecatedFieldsDef,
-            valuesDef,
-            deprecatedValuesDef,
-            !(type2 instanceof GraphQLObjectType) && typesDef
-          );
-        };
-        return TypeDoc2;
-      })(React$1.Component);
-      function Field(_a2) {
-        var type2 = _a2.type,
-          field = _a2.field,
-          onClickType = _a2.onClickType,
-          onClickField = _a2.onClickField;
-        return React$1.createElement(
-          "div",
-          { className: "doc-category-item" },
-          React$1.createElement(
-            "a",
-            {
-              className: "field-name",
-              onClick: function (event) {
-                return onClickField(field, type2, event);
-              },
-            },
-            field.name
-          ),
-          "args" in field &&
-            field.args &&
-            field.args.length > 0 && [
-              "(",
-              React$1.createElement(
-                "span",
-                { key: "args" },
-                field.args
-                  .filter(function (arg) {
-                    return !arg.deprecationReason;
-                  })
-                  .map(function (arg) {
-                    return React$1.createElement(Argument, {
-                      key: arg.name,
-                      arg,
-                      onClickType,
-                    });
-                  })
-              ),
-              ")",
-            ],
-          ": ",
-          React$1.createElement(TypeLink, {
-            type: field.type,
-            onClick: onClickType,
-          }),
-          React$1.createElement(DefaultValue, { field }),
-          field.description &&
-            React$1.createElement(MarkdownContent, {
-              className: "field-short-description",
-              markdown: field.description,
-            }),
-          "deprecationReason" in field &&
-            field.deprecationReason &&
-            React$1.createElement(MarkdownContent, {
-              className: "doc-deprecation",
-              markdown: field.deprecationReason,
-            })
-        );
-      }
-      function EnumValue(_a2) {
-        var value = _a2.value;
-        return React$1.createElement(
-          "div",
-          { className: "doc-category-item" },
-          React$1.createElement("div", { className: "enum-value" }, value.name),
-          React$1.createElement(MarkdownContent, {
-            className: "doc-value-description",
-            markdown: value.description,
-          }),
-          value.deprecationReason &&
-            React$1.createElement(MarkdownContent, {
-              className: "doc-deprecation",
-              markdown: value.deprecationReason,
-            })
-        );
-      }
-      var __extends$4 =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var __assign$7 =
-        (globalThis && globalThis.__assign) ||
-        function () {
-          __assign$7 =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign$7.apply(this, arguments);
-        };
-      var initialNav = {
-        name: "Schema",
-        title: "Documentation Explorer",
-      };
-      var DocExplorer = (function (_super2) {
-        __extends$4(DocExplorer2, _super2);
-        function DocExplorer2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this.handleNavBackClick = function () {
-            if (_this.state.navStack.length > 1) {
-              _this.setState({ navStack: _this.state.navStack.slice(0, -1) });
-            }
-          };
-          _this.handleClickType = function (type2) {
-            _this.showDoc(type2);
-          };
-          _this.handleClickField = function (field) {
-            _this.showDoc(field);
-          };
-          _this.handleSearch = function (value) {
-            _this.showSearch(value);
-          };
-          _this.state = { navStack: [initialNav] };
-          return _this;
-        }
-        DocExplorer2.prototype.shouldComponentUpdate = function (
-          nextProps,
-          nextState
-        ) {
-          return (
-            this.props.schema !== nextProps.schema ||
-            this.state.navStack !== nextState.navStack ||
-            this.props.schemaErrors !== nextProps.schemaErrors
-          );
-        };
-        DocExplorer2.prototype.render = function () {
-          var _a2 = this.props,
-            schema = _a2.schema,
-            schemaErrors = _a2.schemaErrors;
-          var navStack = this.state.navStack;
-          var navItem = navStack[navStack.length - 1];
-          var content;
-          if (schemaErrors) {
-            content = React$1.createElement(
-              "div",
-              { className: "error-container" },
-              "Error fetching schema"
-            );
-          } else if (schema === void 0) {
-            content = React$1.createElement(
-              "div",
-              { className: "spinner-container" },
-              React$1.createElement("div", { className: "spinner" })
-            );
-          } else if (!schema) {
-            content = React$1.createElement(
-              "div",
-              { className: "error-container" },
-              "No Schema Available"
-            );
-          } else if (navItem.search) {
-            content = React$1.createElement(SearchResults, {
-              searchValue: navItem.search,
-              withinType: navItem.def,
-              schema,
-              onClickType: this.handleClickType,
-              onClickField: this.handleClickField,
-            });
-          } else if (navStack.length === 1) {
-            content = React$1.createElement(SchemaDoc, {
-              schema,
-              onClickType: this.handleClickType,
-            });
-          } else if (isType(navItem.def)) {
-            content = React$1.createElement(TypeDoc, {
-              schema,
-              type: navItem.def,
-              onClickType: this.handleClickType,
-              onClickField: this.handleClickField,
-            });
-          } else {
-            content = React$1.createElement(FieldDoc, {
-              field: navItem.def,
-              onClickType: this.handleClickType,
-            });
-          }
-          var shouldSearchBoxAppear =
-            navStack.length === 1 ||
-            (isType(navItem.def) && "getFields" in navItem.def);
-          var prevName;
-          if (navStack.length > 1) {
-            prevName = navStack[navStack.length - 2].name;
-          }
-          return React$1.createElement(
-            "section",
-            {
-              className: "doc-explorer",
-              key: navItem.name,
-              "aria-label": "Documentation Explorer",
-            },
-            React$1.createElement(
-              "div",
-              { className: "doc-explorer-title-bar" },
-              prevName &&
-                React$1.createElement(
-                  "button",
-                  {
-                    className: "doc-explorer-back",
-                    onClick: this.handleNavBackClick,
-                    "aria-label": "Go back to " + prevName,
-                  },
-                  prevName
-                ),
-              React$1.createElement(
-                "div",
-                { className: "doc-explorer-title" },
-                navItem.title || navItem.name
-              ),
-              React$1.createElement(
-                "div",
-                { className: "doc-explorer-rhs" },
-                this.props.children
-              )
-            ),
-            React$1.createElement(
-              "div",
-              { className: "doc-explorer-contents" },
-              shouldSearchBoxAppear &&
-                React$1.createElement(SearchBox, {
-                  value: navItem.search,
-                  placeholder: "Search " + navItem.name + "...",
-                  onSearch: this.handleSearch,
-                }),
-              content
-            )
-          );
-        };
-        DocExplorer2.prototype.showDoc = function (typeOrField) {
-          var navStack = this.state.navStack;
-          var topNav = navStack[navStack.length - 1];
-          if (topNav.def !== typeOrField) {
-            this.setState({
-              navStack: navStack.concat([
-                {
-                  name: typeOrField.name,
-                  def: typeOrField,
-                },
-              ]),
-            });
-          }
-        };
-        DocExplorer2.prototype.showDocForReference = function (reference3) {
-          if (reference3 && reference3.kind === "Type") {
-            this.showDoc(reference3.type);
-          } else if (reference3.kind === "Field") {
-            this.showDoc(reference3.field);
-          } else if (reference3.kind === "Argument" && reference3.field) {
-            this.showDoc(reference3.field);
-          } else if (reference3.kind === "EnumValue" && reference3.type) {
-            this.showDoc(reference3.type);
-          }
-        };
-        DocExplorer2.prototype.showSearch = function (search2) {
-          var navStack = this.state.navStack.slice();
-          var topNav = navStack[navStack.length - 1];
-          navStack[navStack.length - 1] = __assign$7(__assign$7({}, topNav), {
-            search: search2,
-          });
-          this.setState({ navStack });
-        };
-        DocExplorer2.prototype.reset = function () {
-          this.setState({ navStack: [initialNav] });
-        };
-        return DocExplorer2;
-      })(React$1.Component);
-      var __extends$3 =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var HistoryQuery = (function (_super2) {
-        __extends$3(HistoryQuery2, _super2);
-        function HistoryQuery2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this.state = {
-            editable: false,
-          };
-          _this.editField = null;
-          return _this;
-        }
-        HistoryQuery2.prototype.render = function () {
-          var _this = this;
-          var _a2;
-          var displayName =
-            this.props.label ||
-            this.props.operationName ||
-            ((_a2 = this.props.query) === null || _a2 === void 0
-              ? void 0
-              : _a2
-                  .split("\n")
-                  .filter(function (line) {
-                    return line.indexOf("#") !== 0;
-                  })
-                  .join(""));
-          var starIcon = this.props.favorite ? "\u2605" : "\u2606";
-          return React$1.createElement(
-            "li",
-            { className: this.state.editable ? "editable" : void 0 },
-            this.state.editable
-              ? React$1.createElement("input", {
-                  type: "text",
-                  defaultValue: this.props.label,
-                  ref: function (c) {
-                    _this.editField = c;
-                  },
-                  onBlur: this.handleFieldBlur.bind(this),
-                  onKeyDown: this.handleFieldKeyDown.bind(this),
-                  placeholder: "Type a label",
-                })
-              : React$1.createElement(
-                  "button",
-                  {
-                    className: "history-label",
-                    onClick: this.handleClick.bind(this),
-                  },
-                  displayName
-                ),
-            React$1.createElement(
-              "button",
-              {
-                onClick: this.handleEditClick.bind(this),
-                "aria-label": "Edit label",
-              },
-              "\u270E"
-            ),
-            React$1.createElement(
-              "button",
-              {
-                className: this.props.favorite ? "favorited" : void 0,
-                onClick: this.handleStarClick.bind(this),
-                "aria-label": this.props.favorite
-                  ? "Remove favorite"
-                  : "Add favorite",
-              },
-              starIcon
-            )
-          );
-        };
-        HistoryQuery2.prototype.handleClick = function () {
-          this.props.onSelect(
-            this.props.query,
-            this.props.variables,
-            this.props.headers,
-            this.props.operationName,
-            this.props.label
-          );
-        };
-        HistoryQuery2.prototype.handleStarClick = function (e) {
-          e.stopPropagation();
-          this.props.handleToggleFavorite(
-            this.props.query,
-            this.props.variables,
-            this.props.headers,
-            this.props.operationName,
-            this.props.label,
-            this.props.favorite
-          );
-        };
-        HistoryQuery2.prototype.handleFieldBlur = function (e) {
-          e.stopPropagation();
-          this.setState({ editable: false });
-          this.props.handleEditLabel(
-            this.props.query,
-            this.props.variables,
-            this.props.headers,
-            this.props.operationName,
-            e.target.value,
-            this.props.favorite
-          );
-        };
-        HistoryQuery2.prototype.handleFieldKeyDown = function (e) {
-          if (e.keyCode === 13) {
-            e.stopPropagation();
-            this.setState({ editable: false });
-            this.props.handleEditLabel(
-              this.props.query,
-              this.props.variables,
-              this.props.headers,
-              this.props.operationName,
-              e.currentTarget.value,
-              this.props.favorite
-            );
-          }
-        };
-        HistoryQuery2.prototype.handleEditClick = function (e) {
-          var _this = this;
-          e.stopPropagation();
-          this.setState({ editable: true }, function () {
-            if (_this.editField) {
-              _this.editField.focus();
-            }
-          });
-        };
-        return HistoryQuery2;
-      })(React$1.Component);
-      var __read$4 =
-        (globalThis && globalThis.__read) ||
-        function (o, n2) {
-          var m = typeof Symbol === "function" && o[Symbol.iterator];
-          if (!m) return o;
-          var i = m.call(o),
-            r2,
-            ar = [],
-            e;
-          try {
-            while ((n2 === void 0 || n2-- > 0) && !(r2 = i.next()).done)
-              ar.push(r2.value);
-          } catch (error2) {
-            e = { error: error2 };
-          } finally {
-            try {
-              if (r2 && !r2.done && (m = i["return"])) m.call(i);
-            } finally {
-              if (e) throw e.error;
-            }
-          }
-          return ar;
-        };
-      var __spread$3 =
-        (globalThis && globalThis.__spread) ||
-        function () {
-          for (var ar = [], i = 0; i < arguments.length; i++)
-            ar = ar.concat(__read$4(arguments[i]));
-          return ar;
-        };
-      var QueryStore = (function () {
-        function QueryStore2(key, storage, maxSize) {
-          if (maxSize === void 0) {
-            maxSize = null;
-          }
-          this.key = key;
-          this.storage = storage;
-          this.maxSize = maxSize;
-          this.items = this.fetchAll();
-        }
-        Object.defineProperty(QueryStore2.prototype, "length", {
-          get: function () {
-            return this.items.length;
-          },
-          enumerable: false,
-          configurable: true,
-        });
-        QueryStore2.prototype.contains = function (item) {
-          return this.items.some(function (x2) {
-            return (
-              x2.query === item.query &&
-              x2.variables === item.variables &&
-              x2.headers === item.headers &&
-              x2.operationName === item.operationName
-            );
-          });
-        };
-        QueryStore2.prototype.edit = function (item) {
-          var itemIndex = this.items.findIndex(function (x2) {
-            return (
-              x2.query === item.query &&
-              x2.variables === item.variables &&
-              x2.headers === item.headers &&
-              x2.operationName === item.operationName
-            );
-          });
-          if (itemIndex !== -1) {
-            this.items.splice(itemIndex, 1, item);
-            this.save();
-          }
-        };
-        QueryStore2.prototype.delete = function (item) {
-          var itemIndex = this.items.findIndex(function (x2) {
-            return (
-              x2.query === item.query &&
-              x2.variables === item.variables &&
-              x2.headers === item.headers &&
-              x2.operationName === item.operationName
-            );
-          });
-          if (itemIndex !== -1) {
-            this.items.splice(itemIndex, 1);
-            this.save();
-          }
-        };
-        QueryStore2.prototype.fetchRecent = function () {
-          return this.items[this.items.length - 1];
-        };
-        QueryStore2.prototype.fetchAll = function () {
-          var raw = this.storage.get(this.key);
-          if (raw) {
-            return JSON.parse(raw)[this.key];
-          }
-          return [];
-        };
-        QueryStore2.prototype.push = function (item) {
-          var _a2;
-          var items = __spread$3(this.items, [item]);
-          if (this.maxSize && items.length > this.maxSize) {
-            items.shift();
-          }
-          for (var attempts = 0; attempts < 5; attempts++) {
-            var response = this.storage.set(
-              this.key,
-              JSON.stringify(((_a2 = {}), (_a2[this.key] = items), _a2))
-            );
-            if (!response || !response.error) {
-              this.items = items;
-            } else if (response.isQuotaError && this.maxSize) {
-              items.shift();
-            } else {
-              return;
-            }
-          }
-        };
-        QueryStore2.prototype.save = function () {
-          var _a2;
-          this.storage.set(
-            this.key,
-            JSON.stringify(((_a2 = {}), (_a2[this.key] = this.items), _a2))
-          );
-        };
-        return QueryStore2;
-      })();
-      var __assign$6 =
-        (globalThis && globalThis.__assign) ||
-        function () {
-          __assign$6 =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign$6.apply(this, arguments);
-        };
-      var __read$3 =
-        (globalThis && globalThis.__read) ||
-        function (o, n2) {
-          var m = typeof Symbol === "function" && o[Symbol.iterator];
-          if (!m) return o;
-          var i = m.call(o),
-            r2,
-            ar = [],
-            e;
-          try {
-            while ((n2 === void 0 || n2-- > 0) && !(r2 = i.next()).done)
-              ar.push(r2.value);
-          } catch (error2) {
-            e = { error: error2 };
-          } finally {
-            try {
-              if (r2 && !r2.done && (m = i["return"])) m.call(i);
-            } finally {
-              if (e) throw e.error;
-            }
-          }
-          return ar;
-        };
-      var __spread$2 =
-        (globalThis && globalThis.__spread) ||
-        function () {
-          for (var ar = [], i = 0; i < arguments.length; i++)
-            ar = ar.concat(__read$3(arguments[i]));
-          return ar;
-        };
-      var MAX_QUERY_SIZE = 1e5;
-      var HistoryStore = (function () {
-        function HistoryStore2(storage, maxHistoryLength) {
-          var _this = this;
-          this.storage = storage;
-          this.maxHistoryLength = maxHistoryLength;
-          this.shouldSaveQuery = function (
-            query,
-            variables,
-            headers,
-            lastQuerySaved
-          ) {
-            if (!query) {
-              return false;
-            }
-            try {
-              parse$1(query);
-            } catch (e) {
-              return false;
-            }
-            if (query.length > MAX_QUERY_SIZE) {
-              return false;
-            }
-            if (!lastQuerySaved) {
-              return true;
-            }
-            if (
-              JSON.stringify(query) === JSON.stringify(lastQuerySaved.query)
-            ) {
-              if (
-                JSON.stringify(variables) ===
-                JSON.stringify(lastQuerySaved.variables)
-              ) {
-                if (
-                  JSON.stringify(headers) ===
-                  JSON.stringify(lastQuerySaved.headers)
-                ) {
-                  return false;
-                }
-                if (headers && !lastQuerySaved.headers) {
-                  return false;
-                }
-              }
-              if (variables && !lastQuerySaved.variables) {
-                return false;
-              }
-            }
-            return true;
-          };
-          this.fetchAllQueries = function () {
-            var historyQueries = _this.history.fetchAll();
-            var favoriteQueries = _this.favorite.fetchAll();
-            return historyQueries.concat(favoriteQueries);
-          };
-          this.updateHistory = function (
-            query,
-            variables,
-            headers,
-            operationName
-          ) {
-            if (
-              _this.shouldSaveQuery(
-                query,
-                variables,
-                headers,
-                _this.history.fetchRecent()
-              )
-            ) {
-              _this.history.push({
-                query,
-                variables,
-                headers,
-                operationName,
-              });
-              var historyQueries = _this.history.items;
-              var favoriteQueries = _this.favorite.items;
-              _this.queries = historyQueries.concat(favoriteQueries);
-            }
-          };
-          this.toggleFavorite = function (
-            query,
-            variables,
-            headers,
-            operationName,
-            label,
-            favorite
-          ) {
-            var item = {
-              query,
-              variables,
-              headers,
-              operationName,
-              label,
-            };
-            if (!_this.favorite.contains(item)) {
-              item.favorite = true;
-              _this.favorite.push(item);
-            } else if (favorite) {
-              item.favorite = false;
-              _this.favorite.delete(item);
-            }
-            _this.queries = __spread$2(
-              _this.history.items,
-              _this.favorite.items
-            );
-          };
-          this.editLabel = function (
-            query,
-            variables,
-            headers,
-            operationName,
-            label,
-            favorite
-          ) {
-            var item = {
-              query,
-              variables,
-              headers,
-              operationName,
-              label,
-            };
-            if (favorite) {
-              _this.favorite.edit(
-                __assign$6(__assign$6({}, item), { favorite })
-              );
-            } else {
-              _this.history.edit(item);
-            }
-            _this.queries = __spread$2(
-              _this.history.items,
-              _this.favorite.items
-            );
-          };
-          this.history = new QueryStore(
-            "queries",
-            this.storage,
-            this.maxHistoryLength
-          );
-          this.favorite = new QueryStore("favorites", this.storage, null);
-          this.queries = this.fetchAllQueries();
-        }
-        return HistoryStore2;
-      })();
-      var __extends$2 =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var __assign$5 =
-        (globalThis && globalThis.__assign) ||
-        function () {
-          __assign$5 =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign$5.apply(this, arguments);
-        };
-      var QueryHistory = (function (_super2) {
-        __extends$2(QueryHistory2, _super2);
-        function QueryHistory2(props) {
-          var _this = _super2.call(this, props) || this;
-          _this.onUpdateHistory = function (
-            query,
-            variables,
-            headers,
-            operationName
-          ) {
-            _this.historyStore.updateHistory(
-              query,
-              variables,
-              headers,
-              operationName
-            );
-            _this.setState({ queries: _this.historyStore.queries });
-          };
-          _this.onHandleEditLabel = function (
-            query,
-            variables,
-            headers,
-            operationName,
-            label,
-            favorite
-          ) {
-            _this.historyStore.editLabel(
-              query,
-              variables,
-              headers,
-              operationName,
-              label,
-              favorite
-            );
-            _this.setState({ queries: _this.historyStore.queries });
-          };
-          _this.onToggleFavorite = function (
-            query,
-            variables,
-            headers,
-            operationName,
-            label,
-            favorite
-          ) {
-            _this.historyStore.toggleFavorite(
-              query,
-              variables,
-              headers,
-              operationName,
-              label,
-              favorite
-            );
-            _this.setState({ queries: _this.historyStore.queries });
-          };
-          _this.historyStore = new HistoryStore(
-            _this.props.storage,
-            _this.props.maxHistoryLength
-          );
-          var queries = _this.historyStore.queries;
-          _this.state = { queries };
-          return _this;
-        }
-        QueryHistory2.prototype.render = function () {
-          var _this = this;
-          var queries = this.state.queries.slice().reverse();
-          var queryNodes = queries.map(function (query, i) {
-            return React$1.createElement(
-              HistoryQuery,
-              __assign$5(
-                {
-                  handleEditLabel: _this.onHandleEditLabel,
-                  handleToggleFavorite: _this.onToggleFavorite,
-                  key: i + ":" + (query.label || query.query),
-                  onSelect: _this.props.onSelectQuery,
-                },
-                query
-              )
-            );
-          });
-          return React$1.createElement(
-            "section",
-            { "aria-label": "History" },
-            React$1.createElement(
-              "div",
-              { className: "history-title-bar" },
-              React$1.createElement(
-                "div",
-                { className: "history-title" },
-                "History"
-              ),
-              React$1.createElement(
-                "div",
-                { className: "doc-explorer-rhs" },
-                this.props.children
-              )
-            ),
-            React$1.createElement(
-              "ul",
-              { className: "history-contents" },
-              queryNodes
-            )
-          );
-        };
-        return QueryHistory2;
-      })(React$1.Component);
-      var CodeMirrorSizer = (function () {
-        function CodeMirrorSizer2() {
-          this.sizes = [];
-        }
-        CodeMirrorSizer2.prototype.updateSizes = function (components) {
-          var _this = this;
-          components.forEach(function (component, i) {
-            if (component) {
-              var size = component.getClientHeight();
-              if (i <= _this.sizes.length && size !== _this.sizes[i]) {
-                var editor = component.getCodeMirror();
-                if (editor) {
-                  editor.setSize(null, null);
-                }
-              }
-              _this.sizes[i] = size;
-            }
-          });
-        };
-        return CodeMirrorSizer2;
-      })();
-      function isQuotaError(storage, e) {
-        return (
-          e instanceof DOMException &&
-          (e.code === 22 ||
-            e.code === 1014 ||
-            e.name === "QuotaExceededError" ||
-            e.name === "NS_ERROR_DOM_QUOTA_REACHED") &&
-          storage.length !== 0
-        );
-      }
-      var StorageAPI = (function () {
-        function StorageAPI2(storage) {
-          this.storage =
-            storage ||
-            (typeof window !== "undefined" ? window.localStorage : null);
-        }
-        StorageAPI2.prototype.get = function (name2) {
-          if (this.storage) {
-            var value = this.storage.getItem("graphiql:" + name2);
-            if (value === "null" || value === "undefined") {
-              this.storage.removeItem("graphiql:" + name2);
-              return null;
-            }
-            if (value) {
-              return value;
-            }
-          }
-          return null;
-        };
-        StorageAPI2.prototype.set = function (name2, value) {
-          var quotaError = false;
-          var error2 = null;
-          if (this.storage) {
-            var key = "graphiql:" + name2;
-            if (value) {
-              try {
-                this.storage.setItem(key, value);
-              } catch (e) {
-                error2 = e;
-                quotaError = isQuotaError(this.storage, e);
-              }
-            } else {
-              this.storage.removeItem(key);
-            }
-          }
-          return {
-            isQuotaError: quotaError,
-            error: error2,
-          };
-        };
-        return StorageAPI2;
-      })();
-      function getSelectedOperationName(
-        prevOperations,
-        prevSelectedOperationName,
-        operations
-      ) {
-        if (!operations || operations.length < 1) {
-          return;
-        }
-        var names = operations.map(function (op) {
-          return op.name && op.name.value;
-        });
-        if (
-          prevSelectedOperationName &&
-          names.indexOf(prevSelectedOperationName) !== -1
-        ) {
-          return prevSelectedOperationName;
-        }
-        if (prevSelectedOperationName && prevOperations) {
-          var prevNames = prevOperations.map(function (op) {
-            return op.name && op.name.value;
-          });
-          var prevIndex = prevNames.indexOf(prevSelectedOperationName);
-          if (prevIndex !== -1 && prevIndex < names.length) {
-            return names[prevIndex];
-          }
-        }
-        return names[0];
-      }
-      function find$1(list3, predicate) {
-        for (var i = 0; i < list3.length; i++) {
-          if (predicate(list3[i])) {
-            return list3[i];
-          }
-        }
-      }
-      function fillLeafs(schema, docString, getDefaultFieldNames) {
-        var insertions = [];
-        if (!schema || !docString) {
-          return { insertions, result: docString };
-        }
-        var ast2;
-        try {
-          ast2 = parse$1(docString);
-        } catch (error2) {
-          return { insertions, result: docString };
-        }
-        var fieldNameFn = getDefaultFieldNames || defaultGetDefaultFieldNames$1;
-        var typeInfo = new TypeInfo(schema);
-        visit(ast2, {
-          leave: function (node) {
-            typeInfo.leave(node);
-          },
-          enter: function (node) {
-            typeInfo.enter(node);
-            if (node.kind === "Field" && !node.selectionSet) {
-              var fieldType = typeInfo.getType();
-              var selectionSet = buildSelectionSet(
-                isFieldType(fieldType),
-                fieldNameFn
-              );
-              if (selectionSet && node.loc) {
-                var indent2 = getIndentation(docString, node.loc.start);
-                insertions.push({
-                  index: node.loc.end,
-                  string:
-                    " " + print(selectionSet).replace(/\n/g, "\n" + indent2),
-                });
-              }
-            }
-          },
-        });
-        return {
-          insertions,
-          result: withInsertions(docString, insertions),
-        };
-      }
-      function defaultGetDefaultFieldNames$1(type2) {
-        if (!("getFields" in type2)) {
-          return [];
-        }
-        var fields = type2.getFields();
-        if (fields.id) {
-          return ["id"];
-        }
-        if (fields.edges) {
-          return ["edges"];
-        }
-        if (fields.node) {
-          return ["node"];
-        }
-        var leafFieldNames = [];
-        Object.keys(fields).forEach(function (fieldName) {
-          if (isLeafType(fields[fieldName].type)) {
-            leafFieldNames.push(fieldName);
-          }
-        });
-        return leafFieldNames;
-      }
-      function buildSelectionSet(type2, getDefaultFieldNames) {
-        var namedType = getNamedType(type2);
-        if (!type2 || isLeafType(type2)) {
-          return;
-        }
-        var fieldNames = getDefaultFieldNames(namedType);
-        if (
-          !Array.isArray(fieldNames) ||
-          fieldNames.length === 0 ||
-          !("getFields" in namedType)
-        ) {
-          return;
-        }
-        return {
-          kind: Kind.SELECTION_SET,
-          selections: fieldNames.map(function (fieldName) {
-            var fieldDef = namedType.getFields()[fieldName];
-            var fieldType = fieldDef ? fieldDef.type : null;
-            return {
-              kind: Kind.FIELD,
-              name: {
-                kind: Kind.NAME,
-                value: fieldName,
-              },
-              selectionSet: buildSelectionSet(fieldType, getDefaultFieldNames),
-            };
-          }),
-        };
-      }
-      function withInsertions(initial, insertions) {
-        if (insertions.length === 0) {
-          return initial;
-        }
-        var edited = "";
-        var prevIndex = 0;
-        insertions.forEach(function (_a2) {
-          var index = _a2.index,
-            string2 = _a2.string;
-          edited += initial.slice(prevIndex, index) + string2;
-          prevIndex = index;
-        });
-        edited += initial.slice(prevIndex);
-        return edited;
-      }
-      function getIndentation(str, index) {
-        var indentStart = index;
-        var indentEnd = index;
-        while (indentStart) {
-          var c = str.charCodeAt(indentStart - 1);
-          if (c === 10 || c === 13 || c === 8232 || c === 8233) {
-            break;
-          }
-          indentStart--;
-          if (c !== 9 && c !== 11 && c !== 12 && c !== 32 && c !== 160) {
-            indentEnd = indentStart;
-          }
-        }
-        return str.substring(indentStart, indentEnd);
-      }
-      function isFieldType(fieldType) {
-        if (fieldType) {
-          return fieldType;
-        }
-      }
-      function getLeft(initialElem) {
-        var pt = 0;
-        var elem = initialElem;
-        while (elem.offsetParent) {
-          pt += elem.offsetLeft;
-          elem = elem.offsetParent;
-        }
-        return pt;
-      }
-      function getTop(initialElem) {
-        var pt = 0;
-        var elem = initialElem;
-        while (elem.offsetParent) {
-          pt += elem.offsetTop;
-          elem = elem.offsetParent;
-        }
-        return pt;
-      }
-      var __assign$4 =
-        (globalThis && globalThis.__assign) ||
-        function () {
-          __assign$4 =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign$4.apply(this, arguments);
-        };
-      var __values$2 =
-        (globalThis && globalThis.__values) ||
-        function (o) {
-          var s = typeof Symbol === "function" && Symbol.iterator,
-            m = s && o[s],
-            i = 0;
-          if (m) return m.call(o);
-          if (o && typeof o.length === "number")
-            return {
-              next: function () {
-                if (o && i >= o.length) o = void 0;
-                return { value: o && o[i++], done: !o };
-              },
-            };
-          throw new TypeError(
-            s ? "Object is not iterable." : "Symbol.iterator is not defined."
-          );
-        };
-      var __read$2 =
-        (globalThis && globalThis.__read) ||
-        function (o, n2) {
-          var m = typeof Symbol === "function" && o[Symbol.iterator];
-          if (!m) return o;
-          var i = m.call(o),
-            r2,
-            ar = [],
-            e;
-          try {
-            while ((n2 === void 0 || n2-- > 0) && !(r2 = i.next()).done)
-              ar.push(r2.value);
-          } catch (error2) {
-            e = { error: error2 };
-          } finally {
-            try {
-              if (r2 && !r2.done && (m = i["return"])) m.call(i);
-            } finally {
-              if (e) throw e.error;
-            }
-          }
-          return ar;
-        };
-      var __spread$1 =
-        (globalThis && globalThis.__spread) ||
-        function () {
-          for (var ar = [], i = 0; i < arguments.length; i++)
-            ar = ar.concat(__read$2(arguments[i]));
-          return ar;
-        };
-      function uniqueBy(array, iteratee) {
-        var e_1, _a2;
-        var FilteredMap = /* @__PURE__ */ new Map();
-        var result2 = [];
-        try {
-          for (
-            var array_1 = __values$2(array), array_1_1 = array_1.next();
-            !array_1_1.done;
-            array_1_1 = array_1.next()
-          ) {
-            var item = array_1_1.value;
-            if (item.kind === "Field") {
-              var uniqueValue = iteratee(item);
-              var existing = FilteredMap.get(uniqueValue);
-              if (item.directives && item.directives.length) {
-                var itemClone = __assign$4({}, item);
-                result2.push(itemClone);
-              } else if (
-                existing &&
-                existing.selectionSet &&
-                item.selectionSet
-              ) {
-                existing.selectionSet.selections = __spread$1(
-                  existing.selectionSet.selections,
-                  item.selectionSet.selections
-                );
-              } else if (!existing) {
-                var itemClone = __assign$4({}, item);
-                FilteredMap.set(uniqueValue, itemClone);
-                result2.push(itemClone);
-              }
-            } else {
-              result2.push(item);
-            }
-          }
-        } catch (e_1_1) {
-          e_1 = { error: e_1_1 };
-        } finally {
-          try {
-            if (array_1_1 && !array_1_1.done && (_a2 = array_1.return))
-              _a2.call(array_1);
-          } finally {
-            if (e_1) throw e_1.error;
-          }
-        }
-        return result2;
-      }
-      function inlineRelevantFragmentSpreads(
-        fragmentDefinitions,
-        selections,
-        selectionSetType
-      ) {
-        var e_2, _a2;
-        var _b;
-        var selectionSetTypeName = selectionSetType
-          ? getNamedType(selectionSetType).name
-          : null;
-        var outputSelections = [];
-        var seenSpreads = [];
-        try {
-          for (
-            var selections_1 = __values$2(selections),
-              selections_1_1 = selections_1.next();
-            !selections_1_1.done;
-            selections_1_1 = selections_1.next()
-          ) {
-            var selection = selections_1_1.value;
-            if (selection.kind === "FragmentSpread") {
-              var fragmentName = selection.name.value;
-              if (!selection.directives || selection.directives.length === 0) {
-                if (seenSpreads.indexOf(fragmentName) >= 0) {
-                  continue;
-                } else {
-                  seenSpreads.push(fragmentName);
-                }
-              }
-              var fragmentDefinition =
-                fragmentDefinitions[selection.name.value];
-              if (fragmentDefinition) {
-                var typeCondition = fragmentDefinition.typeCondition,
-                  directives = fragmentDefinition.directives,
-                  selectionSet = fragmentDefinition.selectionSet;
-                selection = {
-                  kind: Kind.INLINE_FRAGMENT,
-                  typeCondition,
-                  directives,
-                  selectionSet,
-                };
-              }
-            }
-            if (
-              selection.kind === Kind.INLINE_FRAGMENT &&
-              (!selection.directives ||
-                ((_b = selection.directives) === null || _b === void 0
-                  ? void 0
-                  : _b.length) === 0)
-            ) {
-              var fragmentTypeName = selection.typeCondition
-                ? selection.typeCondition.name.value
-                : null;
-              if (
-                !fragmentTypeName ||
-                fragmentTypeName === selectionSetTypeName
-              ) {
-                outputSelections.push.apply(
-                  outputSelections,
-                  __spread$1(
-                    inlineRelevantFragmentSpreads(
-                      fragmentDefinitions,
-                      selection.selectionSet.selections,
-                      selectionSetType
-                    )
-                  )
-                );
-                continue;
-              }
-            }
-            outputSelections.push(selection);
-          }
-        } catch (e_2_1) {
-          e_2 = { error: e_2_1 };
-        } finally {
-          try {
-            if (
-              selections_1_1 &&
-              !selections_1_1.done &&
-              (_a2 = selections_1.return)
-            )
-              _a2.call(selections_1);
-          } finally {
-            if (e_2) throw e_2.error;
-          }
-        }
-        return outputSelections;
-      }
-      function mergeAST(documentAST, schema) {
-        var e_3, _a2;
-        var typeInfo = schema ? new TypeInfo(schema) : null;
-        var fragmentDefinitions = /* @__PURE__ */ Object.create(null);
-        try {
-          for (
-            var _b = __values$2(documentAST.definitions), _c = _b.next();
-            !_c.done;
-            _c = _b.next()
-          ) {
-            var definition = _c.value;
-            if (definition.kind === Kind.FRAGMENT_DEFINITION) {
-              fragmentDefinitions[definition.name.value] = definition;
-            }
-          }
-        } catch (e_3_1) {
-          e_3 = { error: e_3_1 };
-        } finally {
-          try {
-            if (_c && !_c.done && (_a2 = _b.return)) _a2.call(_b);
-          } finally {
-            if (e_3) throw e_3.error;
-          }
-        }
-        var visitors = {
-          SelectionSet: function (node) {
-            var selectionSetType = typeInfo ? typeInfo.getParentType() : null;
-            var selections = node.selections;
-            selections = inlineRelevantFragmentSpreads(
-              fragmentDefinitions,
-              selections,
-              selectionSetType
-            );
-            selections = uniqueBy(selections, function (selection) {
-              return selection.alias
-                ? selection.alias.value
-                : selection.name.value;
-            });
-            return __assign$4(__assign$4({}, node), { selections });
-          },
-          FragmentDefinition: function () {
-            return null;
-          },
-        };
-        return visit(
-          documentAST,
-          typeInfo ? visitWithTypeInfo(typeInfo, visitors) : visitors
-        );
-      }
-      var staticName = "IntrospectionQuery";
-      var introspectionQueryName = staticName;
-      /*!
-       * is-primitive <https://github.com/jonschlinkert/is-primitive>
-       *
-       * Copyright (c) 2014-present, Jon Schlinkert.
-       * Released under the MIT License.
-       */
-      var isPrimitive$1 = function isPrimitive(val) {
-        if (typeof val === "object") {
-          return val === null;
-        }
-        return typeof val !== "function";
-      };
-      /*!
-       * isobject <https://github.com/jonschlinkert/isobject>
-       *
-       * Copyright (c) 2014-2017, Jon Schlinkert.
-       * Released under the MIT License.
-       */
-      var isobject = function isObject(val) {
-        return (
-          val != null && typeof val === "object" && Array.isArray(val) === false
-        );
-      };
-      /*!
-       * is-plain-object <https://github.com/jonschlinkert/is-plain-object>
-       *
-       * Copyright (c) 2014-2017, Jon Schlinkert.
-       * Released under the MIT License.
-       */
-      var isObject$5 = isobject;
-      function isObjectObject(o) {
-        return (
-          isObject$5(o) === true &&
-          Object.prototype.toString.call(o) === "[object Object]"
-        );
-      }
-      var isPlainObject$1 = function isPlainObject(o) {
-        var ctor, prot;
-        if (isObjectObject(o) === false) return false;
-        ctor = o.constructor;
-        if (typeof ctor !== "function") return false;
-        prot = ctor.prototype;
-        if (isObjectObject(prot) === false) return false;
-        if (prot.hasOwnProperty("isPrototypeOf") === false) {
-          return false;
-        }
-        return true;
-      };
-      /*!
-       * set-value <https://github.com/jonschlinkert/set-value>
-       *
-       * Copyright (c) Jon Schlinkert (https://github.com/jonschlinkert).
-       * Released under the MIT License.
-       */
-      const { deleteProperty } = Reflect;
-      const isPrimitive2 = isPrimitive$1;
-      const isPlainObject2 = isPlainObject$1;
-      const isObject$4 = (value) => {
-        return (
-          (typeof value === "object" && value !== null) ||
-          typeof value === "function"
-        );
-      };
-      const isUnsafeKey = (key) => {
-        return (
-          key === "__proto__" || key === "constructor" || key === "prototype"
-        );
-      };
-      const validateKey = (key) => {
-        if (!isPrimitive2(key)) {
-          throw new TypeError("Object keys must be strings or symbols");
-        }
-        if (isUnsafeKey(key)) {
-          throw new Error(`Cannot set unsafe key: "${key}"`);
-        }
-      };
-      const toStringKey = (input) => {
-        return Array.isArray(input)
-          ? input.flat().map(String).join(",")
-          : input;
-      };
-      const createMemoKey = (input, options) => {
-        if (typeof input !== "string" || !options) return input;
-        let key = input + ";";
-        if (options.arrays !== void 0) key += `arrays=${options.arrays};`;
-        if (options.separator !== void 0)
-          key += `separator=${options.separator};`;
-        if (options.split !== void 0) key += `split=${options.split};`;
-        if (options.merge !== void 0) key += `merge=${options.merge};`;
-        if (options.preservePaths !== void 0)
-          key += `preservePaths=${options.preservePaths};`;
-        return key;
-      };
-      const memoize = (input, options, fn) => {
-        const key = toStringKey(
-          options ? createMemoKey(input, options) : input
-        );
-        validateKey(key);
-        const value = setValue.cache.get(key) || fn();
-        setValue.cache.set(key, value);
-        return value;
-      };
-      const splitString = (input, options = {}) => {
-        const sep = options.separator || ".";
-        const preserve = sep === "/" ? false : options.preservePaths;
-        if (
-          typeof input === "string" &&
-          preserve !== false &&
-          /\//.test(input)
-        ) {
-          return [input];
-        }
-        const parts = [];
-        let part2 = "";
-        const push2 = (part3) => {
-          let number;
-          if (
-            part3.trim() !== "" &&
-            Number.isInteger((number = Number(part3)))
-          ) {
-            parts.push(number);
-          } else {
-            parts.push(part3);
-          }
-        };
-        for (let i = 0; i < input.length; i++) {
-          const value = input[i];
-          if (value === "\\") {
-            part2 += input[++i];
-            continue;
-          }
-          if (value === sep) {
-            push2(part2);
-            part2 = "";
-            continue;
-          }
-          part2 += value;
-        }
-        if (part2) {
-          push2(part2);
-        }
-        return parts;
-      };
-      const split = (input, options) => {
-        if (options && typeof options.split === "function")
-          return options.split(input);
-        if (typeof input === "symbol") return [input];
-        if (Array.isArray(input)) return input;
-        return memoize(input, options, () => splitString(input, options));
-      };
-      const assignProp = (obj, prop2, value, options) => {
-        validateKey(prop2);
-        if (value === void 0) {
-          deleteProperty(obj, prop2);
-        } else if (options && options.merge) {
-          const merge2 =
-            options.merge === "function" ? options.merge : Object.assign;
-          if (merge2 && isPlainObject2(obj[prop2]) && isPlainObject2(value)) {
-            obj[prop2] = merge2(obj[prop2], value);
-          } else {
-            obj[prop2] = value;
-          }
-        } else {
-          obj[prop2] = value;
-        }
-        return obj;
-      };
-      const setValue = (target2, path, value, options) => {
-        if (!path || !isObject$4(target2)) return target2;
-        const keys = split(path, options);
-        let obj = target2;
-        for (let i = 0; i < keys.length; i++) {
-          const key = keys[i];
-          const next = keys[i + 1];
-          validateKey(key);
-          if (next === void 0) {
-            assignProp(obj, key, value, options);
-            break;
-          }
-          if (typeof next === "number" && !Array.isArray(obj[key])) {
-            obj = obj[key] = [];
-            continue;
-          }
-          if (!isObject$4(obj[key])) {
-            obj[key] = {};
-          }
-          obj = obj[key];
-        }
-        return target2;
-      };
-      setValue.split = split;
-      setValue.cache = /* @__PURE__ */ new Map();
-      setValue.clear = () => {
-        setValue.cache = /* @__PURE__ */ new Map();
-      };
-      var setValue_1 = setValue;
-      var __assign$3 =
-        (globalThis && globalThis.__assign) ||
-        function () {
-          __assign$3 =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign$3.apply(this, arguments);
-        };
-      function TabCloseButton(props) {
-        return React$1.createElement("div", {
-          role: "button",
-          "aria-pressed": false,
-          className: "close",
-          "aria-label": "Close Tab",
-          title: "Close Tab",
-          onClick: function (ev) {
-            ev.stopPropagation();
-            props.onClick();
-          },
-        });
-      }
-      function Tab(props) {
-        return React$1.createElement(
-          "button",
-          __assign$3({}, props.tabProps, {
-            role: "tab",
-            type: "button",
-            "aria-selected": props.isActive,
-            title: props.title,
-            className: "tab" + (props.isActive ? " active" : ""),
-            onClick: props.onSelect,
-          }),
-          props.title,
-          props.isCloseable
-            ? React$1.createElement(TabCloseButton, {
-                onClick: function () {
-                  return props.onClose();
-                },
-              })
-            : null
-        );
-      }
-      function TabAddButton(props) {
-        return React$1.createElement(
-          "button",
-          {
-            onClick: props.onClick,
-            className: "tab-add",
-            title: "Create new tab",
-          },
-          React$1.createElement("span", null, "+")
-        );
-      }
-      function Tabs(props) {
-        return React$1.createElement(
-          "div",
-          __assign$3({ role: "tablist", className: "tabs" }, props.tabsProps),
-          props.children
-        );
-      }
-      function fuzzyExtractOperationTitle(str) {
-        var _a2;
-        var regex2 =
-          /^(?!.*#).*(query|subscription|mutation)\s+([a-zA-Z0-9_]+)/;
-        var match2 = regex2.exec(str);
-        return (_a2 =
-          match2 === null || match2 === void 0 ? void 0 : match2[2]) !== null &&
-          _a2 !== void 0
-          ? _a2
-          : "<untitled>";
-      }
-      function idFromTabContents(params) {
-        var _a2, _b, _c;
-        return [
-          (_a2 = params.query) !== null && _a2 !== void 0 ? _a2 : "",
-          (_b = params.variables) !== null && _b !== void 0 ? _b : "",
-          (_c = params.headers) !== null && _c !== void 0 ? _c : "",
-        ].join("|");
-      }
-      function guid() {
-        var s4 = function () {
-          return Math.floor((1 + Math.random()) * 65536)
-            .toString(16)
-            .substring(1);
-        };
-        return (
-          s4() +
-          s4() +
-          "-" +
-          s4() +
-          "-" +
-          s4() +
-          "-" +
-          s4() +
-          "-" +
-          s4() +
-          s4() +
-          s4()
-        );
-      }
-      var __extends$1 =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var __assign$2 =
-        (globalThis && globalThis.__assign) ||
-        function () {
-          __assign$2 =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign$2.apply(this, arguments);
-        };
-      var __awaiter$1 =
-        (globalThis && globalThis.__awaiter) ||
-        function (thisArg, _arguments, P2, generator) {
-          function adopt(value) {
-            return value instanceof P2
-              ? value
-              : new P2(function (resolve) {
-                  resolve(value);
-                });
-          }
-          return new (P2 || (P2 = Promise))(function (resolve, reject2) {
-            function fulfilled(value) {
-              try {
-                step(generator.next(value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function rejected(value) {
-              try {
-                step(generator["throw"](value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function step(result2) {
-              result2.done
-                ? resolve(result2.value)
-                : adopt(result2.value).then(fulfilled, rejected);
-            }
-            step(
-              (generator = generator.apply(thisArg, _arguments || [])).next()
-            );
-          });
-        };
-      var __generator$1 =
-        (globalThis && globalThis.__generator) ||
-        function (thisArg, body) {
-          var _ = {
-              label: 0,
-              sent: function () {
-                if (t2[0] & 1) throw t2[1];
-                return t2[1];
-              },
-              trys: [],
-              ops: [],
-            },
-            f,
-            y2,
-            t2,
-            g;
-          return (
-            (g = { next: verb(0), throw: verb(1), return: verb(2) }),
-            typeof Symbol === "function" &&
-              (g[Symbol.iterator] = function () {
-                return this;
-              }),
-            g
-          );
-          function verb(n2) {
-            return function (v2) {
-              return step([n2, v2]);
-            };
-          }
-          function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_)
-              try {
-                if (
-                  ((f = 1),
-                  y2 &&
-                    (t2 =
-                      op[0] & 2
-                        ? y2["return"]
-                        : op[0]
-                        ? y2["throw"] || ((t2 = y2["return"]) && t2.call(y2), 0)
-                        : y2.next) &&
-                    !(t2 = t2.call(y2, op[1])).done)
-                )
-                  return t2;
-                if (((y2 = 0), t2)) op = [op[0] & 2, t2.value];
-                switch (op[0]) {
-                  case 0:
-                  case 1:
-                    t2 = op;
-                    break;
-                  case 4:
-                    _.label++;
-                    return { value: op[1], done: false };
-                  case 5:
-                    _.label++;
-                    y2 = op[1];
-                    op = [0];
-                    continue;
-                  case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                  default:
-                    if (
-                      !((t2 = _.trys),
-                      (t2 = t2.length > 0 && t2[t2.length - 1])) &&
-                      (op[0] === 6 || op[0] === 2)
-                    ) {
-                      _ = 0;
-                      continue;
-                    }
-                    if (
-                      op[0] === 3 &&
-                      (!t2 || (op[1] > t2[0] && op[1] < t2[3]))
-                    ) {
-                      _.label = op[1];
-                      break;
-                    }
-                    if (op[0] === 6 && _.label < t2[1]) {
-                      _.label = t2[1];
-                      t2 = op;
-                      break;
-                    }
-                    if (t2 && _.label < t2[2]) {
-                      _.label = t2[2];
-                      _.ops.push(op);
-                      break;
-                    }
-                    if (t2[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                }
-                op = body.call(thisArg, _);
-              } catch (e) {
-                op = [6, e];
-                y2 = 0;
-              } finally {
-                f = t2 = 0;
-              }
-            if (op[0] & 5) throw op[1];
-            return { value: op[0] ? op[1] : void 0, done: true };
-          }
-        };
-      var __rest =
-        (globalThis && globalThis.__rest) ||
-        function (s, e) {
-          var t2 = {};
-          for (var p2 in s)
-            if (
-              Object.prototype.hasOwnProperty.call(s, p2) &&
-              e.indexOf(p2) < 0
-            )
-              t2[p2] = s[p2];
-          if (s != null && typeof Object.getOwnPropertySymbols === "function")
-            for (
-              var i = 0, p2 = Object.getOwnPropertySymbols(s);
-              i < p2.length;
-              i++
-            ) {
-              if (
-                e.indexOf(p2[i]) < 0 &&
-                Object.prototype.propertyIsEnumerable.call(s, p2[i])
-              )
-                t2[p2[i]] = s[p2[i]];
-            }
-          return t2;
-        };
-      var __asyncValues$1 =
-        (globalThis && globalThis.__asyncValues) ||
-        function (o) {
-          if (!Symbol.asyncIterator)
-            throw new TypeError("Symbol.asyncIterator is not defined.");
-          var m = o[Symbol.asyncIterator],
-            i;
-          return m
-            ? m.call(o)
-            : ((o =
-                typeof __values$1 === "function"
-                  ? __values$1(o)
-                  : o[Symbol.iterator]()),
-              (i = {}),
-              verb("next"),
-              verb("throw"),
-              verb("return"),
-              (i[Symbol.asyncIterator] = function () {
-                return this;
-              }),
-              i);
-          function verb(n2) {
-            i[n2] =
-              o[n2] &&
-              function (v2) {
-                return new Promise(function (resolve, reject2) {
-                  (v2 = o[n2](v2)), settle(resolve, reject2, v2.done, v2.value);
-                });
-              };
-          }
-          function settle(resolve, reject2, d, v2) {
-            Promise.resolve(v2).then(function (v3) {
-              resolve({ value: v3, done: d });
-            }, reject2);
-          }
-        };
-      var __read$1 =
-        (globalThis && globalThis.__read) ||
-        function (o, n2) {
-          var m = typeof Symbol === "function" && o[Symbol.iterator];
-          if (!m) return o;
-          var i = m.call(o),
-            r2,
-            ar = [],
-            e;
-          try {
-            while ((n2 === void 0 || n2-- > 0) && !(r2 = i.next()).done)
-              ar.push(r2.value);
-          } catch (error2) {
-            e = { error: error2 };
-          } finally {
-            try {
-              if (r2 && !r2.done && (m = i["return"])) m.call(i);
-            } finally {
-              if (e) throw e.error;
-            }
-          }
-          return ar;
-        };
-      var __spread =
-        (globalThis && globalThis.__spread) ||
-        function () {
-          for (var ar = [], i = 0; i < arguments.length; i++)
-            ar = ar.concat(__read$1(arguments[i]));
-          return ar;
-        };
-      var __values$1 =
-        (globalThis && globalThis.__values) ||
-        function (o) {
-          var s = typeof Symbol === "function" && Symbol.iterator,
-            m = s && o[s],
-            i = 0;
-          if (m) return m.call(o);
-          if (o && typeof o.length === "number")
-            return {
-              next: function () {
-                if (o && i >= o.length) o = void 0;
-                return { value: o && o[i++], done: !o };
-              },
-            };
-          throw new TypeError(
-            s ? "Object is not iterable." : "Symbol.iterator is not defined."
-          );
-        };
-      var DEFAULT_DOC_EXPLORER_WIDTH = 350;
-      var majorVersion = parseInt(React$1.version.slice(0, 2), 10);
-      if (majorVersion < 16) {
-        throw Error(
-          [
-            "GraphiQL 0.18.0 and after is not compatible with React 15 or below.",
-            "If you are using a CDN source (jsdelivr, unpkg, etc), follow this example:",
-            "https://github.com/graphql/graphiql/blob/master/examples/graphiql-cdn/index.html#L49",
-          ].join("\n")
-        );
-      }
-      var stringify$1 = function (obj) {
-        return JSON.stringify(obj, null, 2);
-      };
-      var formatSingleError = function (error2) {
-        return __assign$2(__assign$2({}, error2), {
-          message: error2.message,
-          stack: error2.stack,
-        });
-      };
-      var handleSingleError = function (error2) {
-        if (error2 instanceof GraphQLError) {
-          return error2.toString();
-        }
-        if (error2 instanceof Error) {
-          return formatSingleError(error2);
-        }
-        return error2;
-      };
-      var GraphiQL = (function (_super2) {
-        __extends$1(GraphiQL2, _super2);
-        function GraphiQL2(props) {
-          var e_1, _a2, e_2, _b;
-          var _c, _d, _e, _f, _g, _h, _j;
-          var _this = _super2.call(this, props) || this;
-          _this._editorQueryID = 0;
-          _this.safeSetState = function (nextState, callback) {
-            _this.componentIsMounted && _this.setState(nextState, callback);
-          };
-          _this.persistTabsState = function () {
-            var _a3, _b2;
-            if (_this.props.tabs) {
-              _this._storage.set(
-                "tabState",
-                JSON.stringify(_this.state.tabs, function (key, value) {
-                  return key === "response" ||
-                    (_this.state.shouldPersistHeaders && key === "headers")
-                    ? void 0
-                    : value;
-                })
-              );
-              if (typeof _this.props.tabs === "object") {
-                (_b2 = (_a3 = _this.props.tabs).onTabChange) === null ||
-                _b2 === void 0
-                  ? void 0
-                  : _b2.call(_a3, _this.state.tabs);
-              }
-            }
-          };
-          _this.makeHandleOnSelectTab = function (index2) {
-            return function () {
-              _this.handleStopQuery();
-              _this.setState(function (state) {
-                return stateOnSelectTabReducer(index2, state);
-              }, _this.persistTabsState);
-            };
-          };
-          _this.makeHandleOnCloseTab = function (index2) {
-            return function () {
-              if (_this.state.tabs.activeTabIndex === index2) {
-                _this.handleStopQuery();
-              }
-              _this.setState(function (state) {
-                return stateOnCloseTabReducer(index2, state);
-              }, _this.persistTabsState);
-            };
-          };
-          _this.handleOnAddTab = function () {
-            _this.setState(function (state) {
-              return stateOnTabAddReducer(state);
-            }, _this.persistTabsState);
-          };
-          _this.handleClickReference = function (reference3) {
-            _this.setState({ docExplorerOpen: true }, function () {
-              if (_this.docExplorerComponent) {
-                _this.docExplorerComponent.showDocForReference(reference3);
-              }
-            });
-            _this._storage.set(
-              "docExplorerOpen",
-              JSON.stringify(_this.state.docExplorerOpen)
-            );
-          };
-          _this.handleRunQuery = function (selectedOperationName) {
-            return __awaiter$1(_this, void 0, void 0, function () {
-              var queryID,
-                editedQuery,
-                variables2,
-                headers2,
-                shouldPersistHeaders2,
-                operationName2,
-                fullResponse_1,
-                subscription,
-                error_1;
-              var _this2 = this;
-              return __generator$1(this, function (_a3) {
-                switch (_a3.label) {
-                  case 0:
-                    this._editorQueryID++;
-                    queryID = this._editorQueryID;
-                    editedQuery = this.autoCompleteLeafs() || this.state.query;
-                    variables2 = this.state.variables;
-                    headers2 = this.state.headers;
-                    shouldPersistHeaders2 = this.state.shouldPersistHeaders;
-                    operationName2 = this.state.operationName;
-                    if (
-                      selectedOperationName &&
-                      selectedOperationName !== operationName2
-                    ) {
-                      operationName2 = selectedOperationName;
-                      this.handleEditOperationName(operationName2);
-                    }
-                    _a3.label = 1;
-                  case 1:
-                    _a3.trys.push([1, 3, , 4]);
-                    this.setState({
-                      isWaitingForResponse: true,
-                      response: void 0,
-                      operationName: operationName2,
-                    });
-                    this._storage.set("operationName", operationName2);
-                    if (this._queryHistory) {
-                      this._queryHistory.onUpdateHistory(
-                        editedQuery,
-                        variables2,
-                        headers2,
-                        operationName2
-                      );
-                    } else {
-                      if (this._historyStore) {
-                        this._historyStore.updateHistory(
-                          editedQuery,
-                          variables2,
-                          headers2,
-                          operationName2
-                        );
-                      }
-                    }
-                    fullResponse_1 = { data: {} };
-                    return [
-                      4,
-                      this._fetchQuery(
-                        editedQuery,
-                        variables2,
-                        headers2,
-                        operationName2,
-                        shouldPersistHeaders2,
-                        function (result2) {
-                          var e_3, _a4;
-                          if (queryID === _this2._editorQueryID) {
-                            var maybeMultipart = Array.isArray(result2)
-                              ? result2
-                              : false;
-                            if (
-                              !maybeMultipart &&
-                              typeof result2 !== "string" &&
-                              result2 !== null &&
-                              "hasNext" in result2
-                            ) {
-                              maybeMultipart = [result2];
-                            }
-                            if (maybeMultipart) {
-                              var payload = { data: fullResponse_1.data };
-                              var maybeErrors = __spread(
-                                (fullResponse_1 === null ||
-                                fullResponse_1 === void 0
-                                  ? void 0
-                                  : fullResponse_1.errors) || [],
-                                maybeMultipart
-                                  .map(function (i) {
-                                    return i.errors;
-                                  })
-                                  .flat()
-                                  .filter(Boolean)
-                              );
-                              if (maybeErrors.length) {
-                                payload.errors = maybeErrors;
-                              }
-                              try {
-                                for (
-                                  var maybeMultipart_1 =
-                                      __values$1(maybeMultipart),
-                                    maybeMultipart_1_1 =
-                                      maybeMultipart_1.next();
-                                  !maybeMultipart_1_1.done;
-                                  maybeMultipart_1_1 = maybeMultipart_1.next()
-                                ) {
-                                  var part2 = maybeMultipart_1_1.value;
-                                  var path = part2.path,
-                                    data = part2.data,
-                                    _errors = part2.errors,
-                                    rest = __rest(part2, [
-                                      "path",
-                                      "data",
-                                      "errors",
-                                    ]);
-                                  if (path) {
-                                    if (!data) {
-                                      throw new Error(
-                                        "Expected part to contain a data property, but got " +
-                                          part2
-                                      );
-                                    }
-                                    setValue_1(payload.data, path, data, {
-                                      merge: true,
-                                    });
-                                  } else if (data) {
-                                    payload.data = part2.data;
-                                  }
-                                  fullResponse_1 = __assign$2(
-                                    __assign$2({}, payload),
-                                    rest
-                                  );
-                                }
-                              } catch (e_3_1) {
-                                e_3 = { error: e_3_1 };
-                              } finally {
-                                try {
-                                  if (
-                                    maybeMultipart_1_1 &&
-                                    !maybeMultipart_1_1.done &&
-                                    (_a4 = maybeMultipart_1.return)
-                                  )
-                                    _a4.call(maybeMultipart_1);
-                                } finally {
-                                  if (e_3) throw e_3.error;
-                                }
-                              }
-                              _this2.setState({
-                                isWaitingForResponse: false,
-                                response:
-                                  GraphiQL2.formatResult(fullResponse_1),
-                              });
-                            } else {
-                              var response_1 = GraphiQL2.formatResult(result2);
-                              _this2.setState(function (state) {
-                                return __assign$2(__assign$2({}, state), {
-                                  tabs: __assign$2(__assign$2({}, state.tabs), {
-                                    tabs: state.tabs.tabs.map(function (
-                                      tab2,
-                                      index2
-                                    ) {
-                                      if (
-                                        index2 !== state.tabs.activeTabIndex
-                                      ) {
-                                        return tab2;
-                                      }
-                                      return __assign$2(__assign$2({}, tab2), {
-                                        response: response_1,
-                                      });
-                                    }),
-                                  }),
-                                  isWaitingForResponse: false,
-                                  response: response_1,
-                                });
-                              }, _this2.persistTabsState);
-                            }
-                          }
-                        }
-                      ),
-                    ];
-                  case 2:
-                    subscription = _a3.sent();
-                    this.setState({ subscription });
-                    return [3, 4];
-                  case 3:
-                    error_1 = _a3.sent();
-                    this.setState({
-                      isWaitingForResponse: false,
-                      response: error_1.message,
-                    });
-                    return [3, 4];
-                  case 4:
-                    return [2];
-                }
-              });
-            });
-          };
-          _this.handleStopQuery = function () {
-            var subscription = _this.state.subscription;
-            _this.setState({
-              isWaitingForResponse: false,
-              subscription: null,
-            });
-            if (subscription) {
-              subscription.unsubscribe();
-            }
-          };
-          _this.handlePrettifyQuery = function () {
-            var _a3, _b2, _c2;
-            var editor = _this.getQueryEditor();
-            var editorContent =
-              (_a3 =
-                editor === null || editor === void 0
-                  ? void 0
-                  : editor.getValue()) !== null && _a3 !== void 0
-                ? _a3
-                : "";
-            var prettifiedEditorContent = print(parse$1(editorContent));
-            if (prettifiedEditorContent !== editorContent) {
-              editor === null || editor === void 0
-                ? void 0
-                : editor.setValue(prettifiedEditorContent);
-            }
-            var variableEditor = _this.getVariableEditor();
-            var variableEditorContent =
-              (_b2 =
-                variableEditor === null || variableEditor === void 0
-                  ? void 0
-                  : variableEditor.getValue()) !== null && _b2 !== void 0
-                ? _b2
-                : "";
-            try {
-              var prettifiedVariableEditorContent = JSON.stringify(
-                JSON.parse(variableEditorContent),
-                null,
-                2
-              );
-              if (prettifiedVariableEditorContent !== variableEditorContent) {
-                variableEditor === null || variableEditor === void 0
-                  ? void 0
-                  : variableEditor.setValue(prettifiedVariableEditorContent);
-              }
-            } catch (_d2) {}
-            var headerEditor = _this.getHeaderEditor();
-            var headerEditorContent =
-              (_c2 =
-                headerEditor === null || headerEditor === void 0
-                  ? void 0
-                  : headerEditor.getValue()) !== null && _c2 !== void 0
-                ? _c2
-                : "";
-            try {
-              var prettifiedHeaderEditorContent = JSON.stringify(
-                JSON.parse(headerEditorContent),
-                null,
-                2
-              );
-              if (prettifiedHeaderEditorContent !== headerEditorContent) {
-                headerEditor === null || headerEditor === void 0
-                  ? void 0
-                  : headerEditor.setValue(prettifiedHeaderEditorContent);
-              }
-            } catch (_e2) {}
-          };
-          _this.handleMergeQuery = function () {
-            var editor = _this.getQueryEditor();
-            var query2 = editor.getValue();
-            if (!query2) {
-              return;
-            }
-            var ast2 = _this.state.documentAST;
-            editor.setValue(print(mergeAST(ast2, _this.state.schema)));
-          };
-          _this.handleEditQuery = debounce(100, function (value) {
-            var queryFacts2 = _this._updateQueryFacts(
-              value,
-              _this.state.operationName,
-              _this.state.operations,
-              _this.state.schema
-            );
-            _this.setState(function (state) {
-              return __assign$2(
-                __assign$2(
-                  __assign$2(__assign$2({}, state), { query: value }),
-                  queryFacts2
-                ),
-                {
-                  tabs: tabsStateEditQueryReducer(
-                    value,
-                    state.tabs,
-                    queryFacts2 === null || queryFacts2 === void 0
-                      ? void 0
-                      : queryFacts2.operationName
-                  ),
-                }
-              );
-            }, _this.persistTabsState);
-            _this._storage.set("query", value);
-            if (_this.props.onEditQuery) {
-              return _this.props.onEditQuery(
-                value,
-                queryFacts2 === null || queryFacts2 === void 0
-                  ? void 0
-                  : queryFacts2.documentAST
-              );
-            }
-          });
-          _this.handleCopyQuery = function () {
-            var editor = _this.getQueryEditor();
-            var query2 = editor && editor.getValue();
-            if (!query2) {
-              return;
-            }
-            copyToClipboard(query2);
-            if (_this.props.onCopyQuery) {
-              return _this.props.onCopyQuery(query2);
-            }
-          };
-          _this._updateQueryFacts = function (
-            query2,
-            operationName2,
-            prevOperations,
-            schema2
-          ) {
-            var queryFacts2 = getOperationFacts(schema2, query2);
-            if (queryFacts2) {
-              var updatedOperationName = getSelectedOperationName(
-                prevOperations,
-                operationName2,
-                queryFacts2.operations
-              );
-              var onEditOperationName = _this.props.onEditOperationName;
-              if (
-                onEditOperationName &&
-                updatedOperationName &&
-                operationName2 !== updatedOperationName
-              ) {
-                onEditOperationName(updatedOperationName);
-              }
-              return __assign$2(
-                { operationName: updatedOperationName },
-                queryFacts2
-              );
-            }
-          };
-          _this.handleEditVariables = function (value) {
-            _this.setState(function (state) {
-              return __assign$2(__assign$2({}, state), {
-                variables: value,
-                tabs: tabsStateEditVariablesReducer(value, state.tabs),
-              });
-            }, _this.persistTabsState);
-            debounce(500, function () {
-              return _this._storage.set("variables", value);
-            })();
-            if (_this.props.onEditVariables) {
-              _this.props.onEditVariables(value);
-            }
-          };
-          _this.handleEditHeaders = function (value) {
-            _this.setState(function (state) {
-              return __assign$2(__assign$2({}, state), {
-                headers: value,
-                tabs: tabsStateEditHeadersReducer(value, state.tabs),
-              });
-            }, _this.persistTabsState);
-            _this.props.shouldPersistHeaders &&
-              debounce(500, function () {
-                return _this._storage.set("headers", value);
-              })();
-            if (_this.props.onEditHeaders) {
-              _this.props.onEditHeaders(value);
-            }
-          };
-          _this.handleEditOperationName = function (operationName2) {
-            var onEditOperationName = _this.props.onEditOperationName;
-            if (onEditOperationName) {
-              onEditOperationName(operationName2);
-            }
-          };
-          _this.handleHintInformationRender = function (elem) {
-            elem.addEventListener("click", _this._onClickHintInformation);
-            var onRemoveFn;
-            elem.addEventListener(
-              "DOMNodeRemoved",
-              (onRemoveFn = function () {
-                elem.removeEventListener("DOMNodeRemoved", onRemoveFn);
-                elem.removeEventListener(
-                  "click",
-                  _this._onClickHintInformation
-                );
-              })
-            );
-          };
-          _this.handleEditorRunQuery = function () {
-            _this._runQueryAtCursor();
-          };
-          _this._onClickHintInformation = function (event) {
-            if (
-              (event === null || event === void 0
-                ? void 0
-                : event.currentTarget) &&
-              "className" in event.currentTarget &&
-              event.currentTarget.className === "typeName"
-            ) {
-              var typeName = event.currentTarget.innerHTML;
-              var schema2 = _this.state.schema;
-              if (schema2) {
-                var type_1 = schema2.getType(typeName);
-                if (type_1) {
-                  _this.setState({ docExplorerOpen: true }, function () {
-                    if (_this.docExplorerComponent) {
-                      _this.docExplorerComponent.showDoc(type_1);
-                    }
-                  });
-                  debounce(500, function () {
-                    return _this._storage.set(
-                      "docExplorerOpen",
-                      JSON.stringify(_this.state.docExplorerOpen)
-                    );
-                  })();
-                }
-              }
-            }
-          };
-          _this.handleToggleDocs = function () {
-            if (typeof _this.props.onToggleDocs === "function") {
-              _this.props.onToggleDocs(!_this.state.docExplorerOpen);
-            }
-            _this._storage.set(
-              "docExplorerOpen",
-              JSON.stringify(!_this.state.docExplorerOpen)
-            );
-            _this.setState({ docExplorerOpen: !_this.state.docExplorerOpen });
-          };
-          _this.handleToggleHistory = function () {
-            if (typeof _this.props.onToggleHistory === "function") {
-              _this.props.onToggleHistory(!_this.state.historyPaneOpen);
-            }
-            _this._storage.set(
-              "historyPaneOpen",
-              JSON.stringify(!_this.state.historyPaneOpen)
-            );
-            _this.setState({ historyPaneOpen: !_this.state.historyPaneOpen });
-          };
-          _this.handleSelectHistoryQuery = function (
-            query2,
-            variables2,
-            headers2,
-            operationName2
-          ) {
-            if (query2) {
-              _this.handleEditQuery(query2);
-            }
-            if (variables2) {
-              _this.handleEditVariables(variables2);
-            }
-            if (headers2) {
-              _this.handleEditHeaders(headers2);
-            }
-            if (operationName2) {
-              _this.handleEditOperationName(operationName2);
-            }
-          };
-          _this.handleResizeStart = function (downEvent) {
-            if (!_this._didClickDragBar(downEvent)) {
-              return;
-            }
-            downEvent.preventDefault();
-            var offset = downEvent.clientX - getLeft(downEvent.target);
-            var onMouseMove = function (moveEvent) {
-              if (moveEvent.buttons === 0) {
-                return onMouseUp();
-              }
-              var editorBar = _this.editorBarComponent;
-              var leftSize = moveEvent.clientX - getLeft(editorBar) - offset;
-              var rightSize = editorBar.clientWidth - leftSize;
-              _this.setState({ editorFlex: leftSize / rightSize });
-              debounce(500, function () {
-                return _this._storage.set(
-                  "editorFlex",
-                  JSON.stringify(_this.state.editorFlex)
-                );
-              })();
-            };
-            var onMouseUp = function () {
-              document.removeEventListener("mousemove", onMouseMove);
-              document.removeEventListener("mouseup", onMouseUp);
-              onMouseMove = null;
-              onMouseUp = null;
-            };
-            document.addEventListener("mousemove", onMouseMove);
-            document.addEventListener("mouseup", onMouseUp);
-          };
-          _this.handleResetResize = function () {
-            _this.setState({ editorFlex: 1 });
-            _this._storage.set(
-              "editorFlex",
-              JSON.stringify(_this.state.editorFlex)
-            );
-          };
-          _this.handleDocsResizeStart = function (downEvent) {
-            downEvent.preventDefault();
-            var hadWidth = _this.state.docExplorerWidth;
-            var offset = downEvent.clientX - getLeft(downEvent.target);
-            var onMouseMove = function (moveEvent) {
-              if (moveEvent.buttons === 0) {
-                return onMouseUp();
-              }
-              var app = _this.graphiqlContainer;
-              var cursorPos = moveEvent.clientX - getLeft(app) - offset;
-              var docsSize = app.clientWidth - cursorPos;
-              if (docsSize < 100) {
-                if (typeof _this.props.onToggleDocs === "function") {
-                  _this.props.onToggleDocs(!_this.state.docExplorerOpen);
-                }
-                _this._storage.set(
-                  "docExplorerOpen",
-                  JSON.stringify(_this.state.docExplorerOpen)
-                );
-                _this.setState({ docExplorerOpen: false });
-              } else {
-                _this.setState({
-                  docExplorerOpen: true,
-                  docExplorerWidth: Math.min(docsSize, 650),
-                });
-                debounce(500, function () {
-                  return _this._storage.set(
-                    "docExplorerWidth",
-                    JSON.stringify(_this.state.docExplorerWidth)
-                  );
-                })();
-              }
-              _this._storage.set(
-                "docExplorerOpen",
-                JSON.stringify(_this.state.docExplorerOpen)
-              );
-            };
-            var onMouseUp = function () {
-              if (!_this.state.docExplorerOpen) {
-                _this.setState({ docExplorerWidth: hadWidth });
-                debounce(500, function () {
-                  return _this._storage.set(
-                    "docExplorerWidth",
-                    JSON.stringify(_this.state.docExplorerWidth)
-                  );
-                })();
-              }
-              document.removeEventListener("mousemove", onMouseMove);
-              document.removeEventListener("mouseup", onMouseUp);
-              onMouseMove = null;
-              onMouseUp = null;
-            };
-            document.addEventListener("mousemove", onMouseMove);
-            document.addEventListener("mouseup", onMouseUp);
-          };
-          _this.handleDocsResetResize = function () {
-            _this.setState({
-              docExplorerWidth: DEFAULT_DOC_EXPLORER_WIDTH,
-            });
-            debounce(500, function () {
-              return _this._storage.set(
-                "docExplorerWidth",
-                JSON.stringify(_this.state.docExplorerWidth)
-              );
-            })();
-          };
-          _this.handleTabClickPropogation = function (downEvent) {
-            downEvent.preventDefault();
-            downEvent.stopPropagation();
-          };
-          _this.handleOpenHeaderEditorTab = function (_clickEvent) {
-            _this.setState({
-              headerEditorActive: true,
-              variableEditorActive: false,
-              secondaryEditorOpen: true,
-            });
-          };
-          _this.handleOpenVariableEditorTab = function (_clickEvent) {
-            _this.setState({
-              headerEditorActive: false,
-              variableEditorActive: true,
-              secondaryEditorOpen: true,
-            });
-          };
-          _this.handleSecondaryEditorResizeStart = function (downEvent) {
-            downEvent.preventDefault();
-            var didMove = false;
-            var wasOpen = _this.state.secondaryEditorOpen;
-            var hadHeight = _this.state.secondaryEditorHeight;
-            var offset = downEvent.clientY - getTop(downEvent.target);
-            var onMouseMove = function (moveEvent) {
-              if (moveEvent.buttons === 0) {
-                return onMouseUp();
-              }
-              didMove = true;
-              var editorBar = _this.editorBarComponent;
-              var topSize = moveEvent.clientY - getTop(editorBar) - offset;
-              var bottomSize = editorBar.clientHeight - topSize;
-              if (bottomSize < 60) {
-                _this.setState({
-                  secondaryEditorOpen: false,
-                  secondaryEditorHeight: hadHeight,
-                });
-              } else {
-                _this.setState({
-                  secondaryEditorOpen: true,
-                  secondaryEditorHeight: bottomSize,
-                });
-              }
-              debounce(500, function () {
-                return _this._storage.set(
-                  "secondaryEditorHeight",
-                  JSON.stringify(_this.state.secondaryEditorHeight)
-                );
-              })();
-            };
-            var onMouseUp = function () {
-              if (!didMove) {
-                _this.setState({ secondaryEditorOpen: !wasOpen });
-              }
-              document.removeEventListener("mousemove", onMouseMove);
-              document.removeEventListener("mouseup", onMouseUp);
-              onMouseMove = null;
-              onMouseUp = null;
-            };
-            document.addEventListener("mousemove", onMouseMove);
-            document.addEventListener("mouseup", onMouseUp);
-          };
-          if (typeof props.fetcher !== "function") {
-            throw new TypeError("GraphiQL requires a fetcher function.");
-          }
-          _this._storage = new StorageAPI(props.storage);
-          var maxHistoryLength =
-            (_c = props.maxHistoryLength) !== null && _c !== void 0 ? _c : 20;
-          _this._historyStore = new HistoryStore(
-            _this._storage,
-            maxHistoryLength
-          );
-          _this.componentIsMounted = false;
-          var query =
-            props.query !== void 0
-              ? props.query
-              : _this._storage.get("query")
-              ? _this._storage.get("query")
-              : props.defaultQuery !== void 0
-              ? props.defaultQuery
-              : defaultQuery;
-          var queryFacts = getOperationFacts(props.schema, query);
-          var variables =
-            props.variables !== void 0
-              ? props.variables
-              : _this._storage.get("variables");
-          var headers =
-            props.headers !== void 0
-              ? props.headers
-              : _this._storage.get("headers");
-          var operationName =
-            props.operationName !== void 0
-              ? props.operationName
-              : getSelectedOperationName(
-                  void 0,
-                  _this._storage.get("operationName"),
-                  queryFacts && queryFacts.operations
-                );
-          var docExplorerOpen = props.docExplorerOpen || false;
-          if (_this._storage.get("docExplorerOpen")) {
-            docExplorerOpen = _this._storage.get("docExplorerOpen") === "true";
-          }
-          var secondaryEditorOpen;
-          if (props.defaultVariableEditorOpen !== void 0) {
-            secondaryEditorOpen = props.defaultVariableEditorOpen;
-          } else if (props.defaultSecondaryEditorOpen !== void 0) {
-            secondaryEditorOpen = props.defaultSecondaryEditorOpen;
-          } else {
-            secondaryEditorOpen = Boolean(variables || headers);
-          }
-          var headerEditorEnabled =
-            (_d = props.headerEditorEnabled) !== null && _d !== void 0
-              ? _d
-              : true;
-          var shouldPersistHeaders =
-            (_e = props.shouldPersistHeaders) !== null && _e !== void 0
-              ? _e
-              : false;
-          var schema = props.schema;
-          var response = props.response;
-          var schemaErrors = void 0;
-          if (schema && !_this.props.dangerouslyAssumeSchemaIsValid) {
-            var validationErrors = validateSchema(schema);
-            if (validationErrors && validationErrors.length > 0) {
-              response = GraphiQL2.formatError(validationErrors);
-              schema = void 0;
-              schemaErrors = validationErrors;
-            }
-          }
-          _this._introspectionQuery = getIntrospectionQuery({
-            schemaDescription:
-              (_f = props.schemaDescription) !== null && _f !== void 0
-                ? _f
-                : void 0,
-            inputValueDeprecation:
-              (_g = props.inputValueDeprecation) !== null && _g !== void 0
-                ? _g
-                : void 0,
-          });
-          _this._introspectionQueryName =
-            (_h = props.introspectionQueryName) !== null && _h !== void 0
-              ? _h
-              : introspectionQueryName;
-          _this._introspectionQuerySansSubscriptions =
-            _this._introspectionQuery.replace("subscriptionType { name }", "");
-          var initialTabHash = idFromTabContents({
-            query,
-            variables,
-            headers,
-          });
-          var initialTab = {
-            id: guid(),
-            hash: initialTabHash,
-            title:
-              operationName !== null && operationName !== void 0
-                ? operationName
-                : "<untitled>",
-            query,
-            variables,
-            headers,
-            operationName,
-            response: void 0,
-          };
-          var rawTabState = null;
-          if (_this.props.tabs) {
-            rawTabState = _this._storage.get("tabState");
-          }
-          var tabsState;
-          if (rawTabState === null) {
-            tabsState = {
-              activeTabIndex: 0,
-              tabs: [initialTab],
-            };
-          } else {
-            tabsState = JSON.parse(rawTabState);
-            var queryParameterOperationIsWithinTabs = false;
-            try {
-              for (
-                var _k = __values$1(tabsState.tabs), _l = _k.next();
-                !_l.done;
-                _l = _k.next()
-              ) {
-                var tab = _l.value;
-                tab.query = tab.query;
-                tab.variables = tab.variables;
-                tab.headers = shouldPersistHeaders ? tab.headers : void 0;
-                tab.response = void 0;
-                tab.operationName = void 0;
-                tab.id = guid();
-                tab.hash = idFromTabContents(tab);
-                if (tab.hash === initialTabHash) {
-                  queryParameterOperationIsWithinTabs = true;
-                }
-              }
-            } catch (e_1_1) {
-              e_1 = { error: e_1_1 };
-            } finally {
-              try {
-                if (_l && !_l.done && (_a2 = _k.return)) _a2.call(_k);
-              } finally {
-                if (e_1) throw e_1.error;
-              }
-            }
-            if (queryParameterOperationIsWithinTabs === false) {
-              tabsState.tabs.push(initialTab);
-              tabsState.activeTabIndex = tabsState.tabs.length - 1;
-            }
-          }
-          var activeTab = tabsState.tabs[0];
-          var index = 0;
-          try {
-            for (
-              var _m = __values$1(tabsState.tabs), _o = _m.next();
-              !_o.done;
-              _o = _m.next()
-            ) {
-              var tab = _o.value;
-              if (tab.hash === initialTabHash) {
-                tabsState.activeTabIndex = index;
-                activeTab = tab;
-                break;
-              }
-              index++;
-            }
-          } catch (e_2_1) {
-            e_2 = { error: e_2_1 };
-          } finally {
-            try {
-              if (_o && !_o.done && (_b = _m.return)) _b.call(_m);
-            } finally {
-              if (e_2) throw e_2.error;
-            }
-          }
-          _this.state = __assign$2(
-            {
-              tabs: tabsState,
-              schema,
-              query:
-                activeTab === null || activeTab === void 0
-                  ? void 0
-                  : activeTab.query,
-              variables:
-                activeTab === null || activeTab === void 0
-                  ? void 0
-                  : activeTab.variables,
-              headers:
-                activeTab === null || activeTab === void 0
-                  ? void 0
-                  : activeTab.headers,
-              operationName:
-                activeTab === null || activeTab === void 0
-                  ? void 0
-                  : activeTab.operationName,
-              response:
-                (_j =
-                  activeTab === null || activeTab === void 0
-                    ? void 0
-                    : activeTab.response) !== null && _j !== void 0
-                  ? _j
-                  : response,
-              docExplorerOpen,
-              schemaErrors,
-              editorFlex: Number(_this._storage.get("editorFlex")) || 1,
-              secondaryEditorOpen,
-              secondaryEditorHeight:
-                Number(_this._storage.get("secondaryEditorHeight")) || 200,
-              variableEditorActive:
-                _this._storage.get("variableEditorActive") === "true" ||
-                props.headerEditorEnabled
-                  ? _this._storage.get("headerEditorActive") !== "true"
-                  : true,
-              headerEditorActive:
-                _this._storage.get("headerEditorActive") === "true",
-              headerEditorEnabled,
-              shouldPersistHeaders,
-              historyPaneOpen:
-                _this._storage.get("historyPaneOpen") === "true" || false,
-              docExplorerWidth:
-                Number(_this._storage.get("docExplorerWidth")) ||
-                DEFAULT_DOC_EXPLORER_WIDTH,
-              isWaitingForResponse: false,
-              subscription: null,
-              maxHistoryLength,
-            },
-            queryFacts
-          );
-          return _this;
-        }
-        GraphiQL2.formatResult = function (result2) {
-          return JSON.stringify(result2, null, 2);
-        };
-        GraphiQL2.prototype.componentDidMount = function () {
-          this.componentIsMounted = true;
-          if (this.state.schema === void 0) {
-            this.fetchSchema();
-          }
-          this.codeMirrorSizer = new CodeMirrorSizer();
-          if (typeof window !== "undefined") {
-            window.g = this;
-          }
-        };
-        GraphiQL2.prototype.UNSAFE_componentWillMount = function () {
-          this.componentIsMounted = false;
-        };
-        GraphiQL2.prototype.UNSAFE_componentWillReceiveProps = function (
-          nextProps
-        ) {
-          var _this = this;
-          var nextSchema = this.state.schema;
-          var nextQuery = this.state.query;
-          var nextVariables = this.state.variables;
-          var nextHeaders = this.state.headers;
-          var nextOperationName = this.state.operationName;
-          var nextResponse = this.state.response;
-          if (nextProps.schema !== void 0) {
-            nextSchema = nextProps.schema;
-          }
-          if (
-            nextProps.query !== void 0 &&
-            this.props.query !== nextProps.query
-          ) {
-            nextQuery = nextProps.query;
-          }
-          if (
-            nextProps.variables !== void 0 &&
-            this.props.variables !== nextProps.variables
-          ) {
-            nextVariables = nextProps.variables;
-          }
-          if (
-            nextProps.headers !== void 0 &&
-            this.props.headers !== nextProps.headers
-          ) {
-            nextHeaders = nextProps.headers;
-          }
-          if (nextProps.operationName !== void 0) {
-            nextOperationName = nextProps.operationName;
-          }
-          if (nextProps.response !== void 0) {
-            nextResponse = nextProps.response;
-          }
-          if (
-            nextQuery &&
-            nextSchema &&
-            (nextSchema !== this.state.schema ||
-              nextQuery !== this.state.query ||
-              nextOperationName !== this.state.operationName)
-          ) {
-            if (!this.props.dangerouslyAssumeSchemaIsValid) {
-              var validationErrors = validateSchema(nextSchema);
-              if (validationErrors && validationErrors.length > 0) {
-                this.handleSchemaErrors(validationErrors);
-                nextSchema = void 0;
-              }
-            }
-            var updatedQueryAttributes = this._updateQueryFacts(
-              nextQuery,
-              nextOperationName,
-              this.state.operations,
-              nextSchema
-            );
-            if (updatedQueryAttributes !== void 0) {
-              nextOperationName = updatedQueryAttributes.operationName;
-              this.setState(updatedQueryAttributes);
-            }
-          }
-          if (
-            nextProps.schema === void 0 &&
-            nextProps.fetcher !== this.props.fetcher
-          ) {
-            nextSchema = void 0;
-          }
-          this._storage.set("operationName", nextOperationName);
-          this.setState(
-            {
-              schema: nextSchema,
-              query: nextQuery,
-              variables: nextVariables,
-              headers: nextHeaders,
-              operationName: nextOperationName,
-              response: nextResponse,
-            },
-            function () {
-              if (_this.state.schema === void 0) {
-                if (_this.docExplorerComponent) {
-                  _this.docExplorerComponent.reset();
-                }
-                _this.fetchSchema();
-              }
-            }
-          );
-        };
-        GraphiQL2.prototype.componentDidUpdate = function () {
-          this.codeMirrorSizer.updateSizes([
-            this.queryEditorComponent,
-            this.variableEditorComponent,
-            this.headerEditorComponent,
-            this.resultComponent,
-          ]);
-        };
-        GraphiQL2.prototype.render = function () {
-          var _this = this;
-          var _a2;
-          var children = React$1.Children.toArray(this.props.children);
-          var logo =
-            find$1(children, function (child) {
-              return isChildComponentType(child, GraphiQL2.Logo);
-            }) || React$1.createElement(GraphiQL2.Logo, null);
-          var toolbar =
-            find$1(children, function (child) {
-              return isChildComponentType(child, GraphiQL2.Toolbar);
-            }) ||
-            React$1.createElement(
-              GraphiQL2.Toolbar,
-              null,
-              React$1.createElement(ToolbarButton, {
-                onClick: this.handlePrettifyQuery,
-                title: "Prettify Query (Shift-Ctrl-P)",
-                label: "Prettify",
-              }),
-              React$1.createElement(ToolbarButton, {
-                onClick: this.handleMergeQuery,
-                title: "Merge Query (Shift-Ctrl-M)",
-                label: "Merge",
-              }),
-              React$1.createElement(ToolbarButton, {
-                onClick: this.handleCopyQuery,
-                title: "Copy Query (Shift-Ctrl-C)",
-                label: "Copy",
-              }),
-              React$1.createElement(ToolbarButton, {
-                onClick: this.handleToggleHistory,
-                title: "Show History",
-                label: "History",
-              }),
-              (
-                (_a2 = this.props.toolbar) === null || _a2 === void 0
-                  ? void 0
-                  : _a2.additionalContent
-              )
-                ? this.props.toolbar.additionalContent
-                : null
-            );
-          var footer = find$1(children, function (child) {
-            return isChildComponentType(child, GraphiQL2.Footer);
-          });
-          var queryWrapStyle = {
-            WebkitFlex: this.state.editorFlex,
-            flex: this.state.editorFlex,
-          };
-          var docWrapStyle = {
-            display: "block",
-            width: this.state.docExplorerWidth,
-          };
-          var docExplorerWrapClasses =
-            "docExplorerWrap" +
-            (this.state.docExplorerWidth < 200 ? " doc-explorer-narrow" : "");
-          var historyPaneStyle = {
-            display: this.state.historyPaneOpen ? "block" : "none",
-            width: "230px",
-            zIndex: 7,
-          };
-          var secondaryEditorOpen = this.state.secondaryEditorOpen;
-          var secondaryEditorStyle = {
-            height: secondaryEditorOpen
-              ? this.state.secondaryEditorHeight
-              : void 0,
-          };
-          var tabsState = this.state.tabs;
-          return React$1.createElement(
-            "div",
-            {
-              ref: function (n2) {
-                _this.graphiqlContainer = n2;
-              },
-              "data-testid": "graphiql-container",
-              className: "graphiql-container",
-            },
-            this.state.historyPaneOpen &&
-              React$1.createElement(
-                "div",
-                { className: "historyPaneWrap", style: historyPaneStyle },
-                React$1.createElement(
-                  QueryHistory,
-                  {
-                    ref: function (node) {
-                      _this._queryHistory = node;
-                    },
-                    operationName: this.state.operationName,
-                    query: this.state.query,
-                    variables: this.state.variables,
-                    onSelectQuery: this.handleSelectHistoryQuery,
-                    storage: this._storage,
-                    maxHistoryLength: this.state.maxHistoryLength,
-                    queryID: this._editorQueryID,
-                  },
-                  React$1.createElement(
-                    "button",
-                    {
-                      className: "docExplorerHide",
-                      onClick: this.handleToggleHistory,
-                      "aria-label": "Close History",
-                    },
-                    "\u2715"
-                  )
-                )
-              ),
-            React$1.createElement(
-              "div",
-              { className: "editorWrap" },
-              React$1.createElement(
-                "div",
-                { className: "topBarWrap" },
-                this.props.beforeTopBarContent,
-                React$1.createElement(
-                  "div",
-                  { className: "topBar" },
-                  logo,
-                  React$1.createElement(ExecuteButton, {
-                    isRunning: Boolean(this.state.subscription),
-                    onRun: this.handleRunQuery,
-                    onStop: this.handleStopQuery,
-                    operations: this.state.operations,
-                  }),
-                  toolbar
-                ),
-                !this.state.docExplorerOpen &&
-                  React$1.createElement(
-                    "button",
-                    {
-                      className: "docExplorerShow",
-                      onClick: this.handleToggleDocs,
-                      "aria-label": "Open Documentation Explorer",
-                    },
-                    "Docs"
-                  )
-              ),
-              this.props.tabs
-                ? React$1.createElement(
-                    Tabs,
-                    {
-                      tabsProps: {
-                        "aria-label": "Select active operation",
-                      },
-                    },
-                    tabsState.tabs.map(function (tab, index) {
-                      return React$1.createElement(Tab, {
-                        key: tab.id,
-                        isActive: index === tabsState.activeTabIndex,
-                        title: tab.title,
-                        isCloseable: tabsState.tabs.length > 1,
-                        onSelect: _this.makeHandleOnSelectTab(index),
-                        onClose: _this.makeHandleOnCloseTab(index),
-                        tabProps: {
-                          "aria-controls": "sessionWrap",
-                          id: "session-tab-" + index,
-                        },
-                      });
-                    }),
-                    React$1.createElement(TabAddButton, {
-                      onClick: this.handleOnAddTab,
-                    })
-                  )
-                : null,
-              React$1.createElement(
-                "div",
-                {
-                  ref: function (n2) {
-                    _this.editorBarComponent = n2;
-                  },
-                  role: "tabpanel",
-                  id: "sessionWrap",
-                  className: "editorBar",
-                  "aria-labelledby": "session-tab-" + tabsState.activeTabIndex,
-                  onDoubleClick: this.handleResetResize,
-                  onMouseDown: this.handleResizeStart,
-                },
-                React$1.createElement(
-                  "div",
-                  { className: "queryWrap", style: queryWrapStyle },
-                  React$1.createElement(QueryEditor, {
-                    ref: function (n2) {
-                      _this.queryEditorComponent = n2;
-                    },
-                    schema: this.state.schema,
-                    validationRules: this.props.validationRules,
-                    value: this.state.query,
-                    onEdit: this.handleEditQuery,
-                    onHintInformationRender: this.handleHintInformationRender,
-                    onClickReference: this.handleClickReference,
-                    onCopyQuery: this.handleCopyQuery,
-                    onPrettifyQuery: this.handlePrettifyQuery,
-                    onMergeQuery: this.handleMergeQuery,
-                    onRunQuery: this.handleEditorRunQuery,
-                    editorTheme: this.props.editorTheme,
-                    readOnly: this.props.readOnly,
-                    externalFragments: this.props.externalFragments,
-                  }),
-                  React$1.createElement(
-                    "section",
-                    {
-                      className: "variable-editor secondary-editor",
-                      style: secondaryEditorStyle,
-                      "aria-label": this.state.variableEditorActive
-                        ? "Query Variables"
-                        : "Request Headers",
-                    },
-                    React$1.createElement(
-                      "div",
-                      {
-                        className:
-                          "secondary-editor-title variable-editor-title",
-                        id: "secondary-editor-title",
-                        style: {
-                          cursor: secondaryEditorOpen
-                            ? "row-resize"
-                            : "n-resize",
-                        },
-                        onMouseDown: this.handleSecondaryEditorResizeStart,
-                      },
-                      React$1.createElement(
-                        "div",
-                        {
-                          className:
-                            "variable-editor-title-text" +
-                            (this.state.variableEditorActive ? " active" : ""),
-                          onClick: this.handleOpenVariableEditorTab,
-                          onMouseDown: this.handleTabClickPropogation,
-                        },
-                        "Query Variables"
-                      ),
-                      this.state.headerEditorEnabled &&
-                        React$1.createElement(
-                          "div",
-                          {
-                            style: {
-                              marginLeft: "20px",
-                            },
-                            className:
-                              "variable-editor-title-text" +
-                              (this.state.headerEditorActive ? " active" : ""),
-                            onClick: this.handleOpenHeaderEditorTab,
-                            onMouseDown: this.handleTabClickPropogation,
-                          },
-                          "Request Headers"
-                        )
-                    ),
-                    React$1.createElement(VariableEditor, {
-                      ref: function (n2) {
-                        _this.variableEditorComponent = n2;
-                      },
-                      value: this.state.variables,
-                      variableToType: this.state.variableToType,
-                      onEdit: this.handleEditVariables,
-                      onHintInformationRender: this.handleHintInformationRender,
-                      onPrettifyQuery: this.handlePrettifyQuery,
-                      onMergeQuery: this.handleMergeQuery,
-                      onRunQuery: this.handleEditorRunQuery,
-                      editorTheme: this.props.editorTheme,
-                      readOnly: this.props.readOnly,
-                      active: this.state.variableEditorActive,
-                    }),
-                    this.state.headerEditorEnabled &&
-                      React$1.createElement(HeaderEditor, {
-                        ref: function (n2) {
-                          _this.headerEditorComponent = n2;
-                        },
-                        value: this.state.headers,
-                        onEdit: this.handleEditHeaders,
-                        onHintInformationRender:
-                          this.handleHintInformationRender,
-                        onPrettifyQuery: this.handlePrettifyQuery,
-                        onMergeQuery: this.handleMergeQuery,
-                        onRunQuery: this.handleEditorRunQuery,
-                        editorTheme: this.props.editorTheme,
-                        readOnly: this.props.readOnly,
-                        active: this.state.headerEditorActive,
-                      })
-                  )
-                ),
-                React$1.createElement(
-                  "div",
-                  { className: "resultWrap" },
-                  this.state.isWaitingForResponse &&
-                    React$1.createElement(
-                      "div",
-                      { className: "spinner-container" },
-                      React$1.createElement("div", { className: "spinner" })
-                    ),
-                  React$1.createElement(ResultViewer, {
-                    registerRef: function (n2) {
-                      _this.resultViewerElement = n2;
-                    },
-                    ref: function (c) {
-                      _this.resultComponent = c;
-                    },
-                    value: this.state.response,
-                    editorTheme: this.props.editorTheme,
-                    ResultsTooltip: this.props.ResultsTooltip,
-                    ImagePreview,
-                  }),
-                  footer
-                )
-              )
-            ),
-            this.state.docExplorerOpen &&
-              React$1.createElement(
-                "div",
-                { className: docExplorerWrapClasses, style: docWrapStyle },
-                React$1.createElement("div", {
-                  className: "docExplorerResizer",
-                  onDoubleClick: this.handleDocsResetResize,
-                  onMouseDown: this.handleDocsResizeStart,
-                }),
-                React$1.createElement(
-                  DocExplorer,
-                  {
-                    ref: function (c) {
-                      _this.docExplorerComponent = c;
-                    },
-                    schemaErrors: this.state.schemaErrors,
-                    schema: this.state.schema,
-                  },
-                  React$1.createElement(
-                    "button",
-                    {
-                      className: "docExplorerHide",
-                      onClick: this.handleToggleDocs,
-                      "aria-label": "Close Documentation Explorer",
-                    },
-                    "\u2715"
-                  )
-                )
-              )
-          );
-        };
-        GraphiQL2.prototype.getQueryEditor = function () {
-          if (this.queryEditorComponent) {
-            return this.queryEditorComponent.getCodeMirror();
-          }
-        };
-        GraphiQL2.prototype.getVariableEditor = function () {
-          if (this.variableEditorComponent) {
-            return this.variableEditorComponent.getCodeMirror();
-          }
-          return null;
-        };
-        GraphiQL2.prototype.getHeaderEditor = function () {
-          if (this.headerEditorComponent) {
-            return this.headerEditorComponent.getCodeMirror();
-          }
-          return null;
-        };
-        GraphiQL2.prototype.refresh = function () {
-          if (this.queryEditorComponent) {
-            this.queryEditorComponent.getCodeMirror().refresh();
-          }
-          if (this.variableEditorComponent) {
-            this.variableEditorComponent.getCodeMirror().refresh();
-          }
-          if (this.headerEditorComponent) {
-            this.headerEditorComponent.getCodeMirror().refresh();
-          }
-          if (this.resultComponent) {
-            this.resultComponent.getCodeMirror().refresh();
-          }
-        };
-        GraphiQL2.prototype.autoCompleteLeafs = function () {
-          var _a2 = fillLeafs(
-              this.state.schema,
-              this.state.query,
-              this.props.getDefaultFieldNames
-            ),
-            insertions = _a2.insertions,
-            result2 = _a2.result;
-          if (insertions && insertions.length > 0) {
-            var editor_1 = this.getQueryEditor();
-            if (editor_1) {
-              editor_1.operation(function () {
-                var cursor = editor_1.getCursor();
-                var cursorIndex = editor_1.indexFromPos(cursor);
-                editor_1.setValue(result2 || "");
-                var added = 0;
-                var markers = insertions.map(function (_a3) {
-                  var index = _a3.index,
-                    string2 = _a3.string;
-                  return editor_1.markText(
-                    editor_1.posFromIndex(index + added),
-                    editor_1.posFromIndex(index + (added += string2.length)),
-                    {
-                      className: "autoInsertedLeaf",
-                      clearOnEnter: true,
-                      title: "Automatically added leaf fields",
-                    }
-                  );
-                });
-                setTimeout(function () {
-                  return markers.forEach(function (marker2) {
-                    return marker2.clear();
-                  });
-                }, 7e3);
-                var newCursorIndex = cursorIndex;
-                insertions.forEach(function (_a3) {
-                  var index = _a3.index,
-                    string2 = _a3.string;
-                  if (index < cursorIndex) {
-                    newCursorIndex += string2.length;
-                  }
-                });
-                editor_1.setCursor(editor_1.posFromIndex(newCursorIndex));
-              });
-            }
-          }
-          return result2;
-        };
-        GraphiQL2.prototype.fetchSchema = function () {
-          var _this = this;
-          var fetcher = this.props.fetcher;
-          var fetcherOpts = {
-            shouldPersistHeaders: Boolean(this.props.shouldPersistHeaders),
-            documentAST: this.state.documentAST,
-          };
-          try {
-            if (this.state.headers && this.state.headers.trim().length > 2) {
-              fetcherOpts.headers = JSON.parse(this.state.headers);
-            } else if (this.props.headers) {
-              fetcherOpts.headers = JSON.parse(this.props.headers);
-            }
-          } catch (err) {
-            this.setState({
-              response: "Introspection failed as headers are invalid.",
-            });
-            return;
-          }
-          var fetch2 = fetcherReturnToPromise(
-            fetcher(
-              {
-                query: this._introspectionQuery,
-                operationName: this._introspectionQueryName,
-              },
-              fetcherOpts
-            )
-          );
-          if (!isPromise$1(fetch2)) {
-            this.setState({
-              response: "Fetcher did not return a Promise for introspection.",
-            });
-            return;
-          }
-          fetch2
-            .then(function (result2) {
-              if (typeof result2 !== "string" && "data" in result2) {
-                return result2;
-              }
-              var fetch22 = fetcherReturnToPromise(
-                fetcher(
-                  {
-                    query: _this._introspectionQuerySansSubscriptions,
-                    operationName: _this._introspectionQueryName,
-                  },
-                  fetcherOpts
-                )
-              );
-              if (!isPromise$1(fetch2)) {
-                throw new Error(
-                  "Fetcher did not return a Promise for introspection."
-                );
-              }
-              return fetch22;
-            })
-            .then(function (result2) {
-              var _a2, _b;
-              if (_this.state.schema !== void 0) {
-                return;
-              }
-              if (
-                result2 &&
-                result2.data &&
-                "__schema" in
-                  (result2 === null || result2 === void 0
-                    ? void 0
-                    : result2.data)
-              ) {
-                var schema = buildClientSchema(result2.data);
-                if (!_this.props.dangerouslyAssumeSchemaIsValid) {
-                  var errors2 = validateSchema(schema);
-                  if (errors2 && errors2.length > 0) {
-                    schema = void 0;
-                    _this.handleSchemaErrors(errors2);
-                  }
-                }
-                if (schema) {
-                  var queryFacts = getOperationFacts(schema, _this.state.query);
-                  _this.safeSetState(
-                    __assign$2(__assign$2({ schema }, queryFacts), {
-                      schemaErrors: void 0,
-                    })
-                  );
-                  (_b = (_a2 = _this.props).onSchemaChange) === null ||
-                  _b === void 0
-                    ? void 0
-                    : _b.call(_a2, schema);
-                }
-              } else {
-                var responseString =
-                  typeof result2 === "string"
-                    ? result2
-                    : GraphiQL2.formatResult(result2);
-                _this.handleSchemaErrors([responseString]);
-              }
-            })
-            .catch(function (error2) {
-              _this.handleSchemaErrors([error2]);
-            });
-        };
-        GraphiQL2.prototype.handleSchemaErrors = function (schemaErrors) {
-          this.safeSetState({
-            response: schemaErrors
-              ? GraphiQL2.formatError(schemaErrors)
-              : void 0,
-            schema: void 0,
-            schemaErrors,
-          });
-        };
-        GraphiQL2.prototype._fetchQuery = function (
-          query,
-          variables,
-          headers,
-          operationName,
-          shouldPersistHeaders,
-          cb2
-        ) {
-          return __awaiter$1(this, void 0, void 0, function () {
-            var fetcher,
-              jsonVariables,
-              jsonHeaders,
-              externalFragments_1,
-              fragmentDependencies,
-              fetch2;
-            var _this = this;
-            return __generator$1(this, function (_a2) {
-              fetcher = this.props.fetcher;
-              jsonVariables = null;
-              jsonHeaders = null;
-              try {
-                jsonVariables =
-                  variables && variables.trim() !== ""
-                    ? JSON.parse(variables)
-                    : null;
-              } catch (error2) {
-                throw new Error(
-                  "Variables are invalid JSON: " + error2.message + "."
-                );
-              }
-              if (typeof jsonVariables !== "object") {
-                throw new Error("Variables are not a JSON object.");
-              }
-              try {
-                jsonHeaders =
-                  headers && headers.trim() !== "" ? JSON.parse(headers) : null;
-              } catch (error2) {
-                throw new Error(
-                  "Headers are invalid JSON: " + error2.message + "."
-                );
-              }
-              if (typeof jsonHeaders !== "object") {
-                throw new Error("Headers are not a JSON object.");
-              }
-              if (this.props.externalFragments) {
-                externalFragments_1 = /* @__PURE__ */ new Map();
-                if (Array.isArray(this.props.externalFragments)) {
-                  this.props.externalFragments.forEach(function (def) {
-                    externalFragments_1.set(def.name.value, def);
-                  });
-                } else {
-                  visit(parse$1(this.props.externalFragments, {}), {
-                    FragmentDefinition: function (def) {
-                      externalFragments_1.set(def.name.value, def);
-                    },
-                  });
-                }
-                fragmentDependencies = getFragmentDependenciesForAST(
-                  this.state.documentAST,
-                  externalFragments_1
-                );
-                if (fragmentDependencies.length > 0) {
-                  query +=
-                    "\n" +
-                    fragmentDependencies
-                      .map(function (node) {
-                        return print(node);
-                      })
-                      .join("\n");
-                }
-              }
-              fetch2 = fetcher(
-                {
-                  query,
-                  variables: jsonVariables,
-                  operationName,
-                },
-                {
-                  headers: jsonHeaders,
-                  shouldPersistHeaders,
-                  documentAST: this.state.documentAST,
-                }
-              );
-              return [
-                2,
-                Promise.resolve(fetch2)
-                  .then(function (value) {
-                    if (isObservable(value)) {
-                      var subscription = value.subscribe({
-                        next: cb2,
-                        error: function (error2) {
-                          _this.safeSetState({
-                            isWaitingForResponse: false,
-                            response: error2
-                              ? GraphiQL2.formatError(error2)
-                              : void 0,
-                            subscription: null,
-                          });
-                        },
-                        complete: function () {
-                          _this.safeSetState({
-                            isWaitingForResponse: false,
-                            subscription: null,
-                          });
-                        },
-                      });
-                      return subscription;
-                    } else if (isAsyncIterable$2(value)) {
-                      (function () {
-                        return __awaiter$1(_this, void 0, void 0, function () {
-                          var value_1, value_1_1, result2, e_4_1, error_2;
-                          var e_4, _a3;
-                          return __generator$1(this, function (_b) {
-                            switch (_b.label) {
-                              case 0:
-                                _b.trys.push([0, 13, , 14]);
-                                _b.label = 1;
-                              case 1:
-                                _b.trys.push([1, 6, 7, 12]);
-                                value_1 = __asyncValues$1(value);
-                                _b.label = 2;
-                              case 2:
-                                return [4, value_1.next()];
-                              case 3:
-                                if (!((value_1_1 = _b.sent()), !value_1_1.done))
-                                  return [3, 5];
-                                result2 = value_1_1.value;
-                                cb2(result2);
-                                _b.label = 4;
-                              case 4:
-                                return [3, 2];
-                              case 5:
-                                return [3, 12];
-                              case 6:
-                                e_4_1 = _b.sent();
-                                e_4 = { error: e_4_1 };
-                                return [3, 12];
-                              case 7:
-                                _b.trys.push([7, , 10, 11]);
-                                if (
-                                  !(
-                                    value_1_1 &&
-                                    !value_1_1.done &&
-                                    (_a3 = value_1.return)
-                                  )
-                                )
-                                  return [3, 9];
-                                return [4, _a3.call(value_1)];
-                              case 8:
-                                _b.sent();
-                                _b.label = 9;
-                              case 9:
-                                return [3, 11];
-                              case 10:
-                                if (e_4) throw e_4.error;
-                                return [7];
-                              case 11:
-                                return [7];
-                              case 12:
-                                this.safeSetState({
-                                  isWaitingForResponse: false,
-                                  subscription: null,
-                                });
-                                return [3, 14];
-                              case 13:
-                                error_2 = _b.sent();
-                                this.safeSetState({
-                                  isWaitingForResponse: false,
-                                  response: error_2
-                                    ? GraphiQL2.formatError(error_2)
-                                    : void 0,
-                                  subscription: null,
-                                });
-                                return [3, 14];
-                              case 14:
-                                return [2];
-                            }
-                          });
-                        });
-                      })();
-                      return {
-                        unsubscribe: function () {
-                          var _a3, _b;
-                          return (_b = (_a3 = value[Symbol.asyncIterator]())
-                            .return) === null || _b === void 0
-                            ? void 0
-                            : _b.call(_a3);
-                        },
-                      };
-                    } else {
-                      cb2(value);
-                      return null;
-                    }
-                  })
-                  .catch(function (error2) {
-                    _this.safeSetState({
-                      isWaitingForResponse: false,
-                      response: error2 ? GraphiQL2.formatError(error2) : void 0,
-                    });
-                    return null;
-                  }),
-              ];
-            });
-          });
-        };
-        GraphiQL2.prototype._runQueryAtCursor = function () {
-          if (this.state.subscription) {
-            this.handleStopQuery();
-            return;
-          }
-          var operationName;
-          var operations = this.state.operations;
-          if (operations) {
-            var editor = this.getQueryEditor();
-            if (editor && editor.hasFocus()) {
-              var cursor = editor.getCursor();
-              var cursorIndex = editor.indexFromPos(cursor);
-              for (var i = 0; i < operations.length; i++) {
-                var operation = operations[i];
-                if (
-                  operation.loc &&
-                  operation.loc.start <= cursorIndex &&
-                  operation.loc.end >= cursorIndex
-                ) {
-                  operationName = operation.name && operation.name.value;
-                  break;
-                }
-              }
-            }
-          }
-          this.handleRunQuery(operationName);
-        };
-        GraphiQL2.prototype._didClickDragBar = function (event) {
-          if (event.button !== 0 || event.ctrlKey) {
-            return false;
-          }
-          var target2 = event.target;
-          if (target2.className.indexOf("CodeMirror-gutter") !== 0) {
-            return false;
-          }
-          var resultWindow = this.resultViewerElement;
-          while (target2) {
-            if (target2 === resultWindow) {
-              return true;
-            }
-            target2 = target2.parentNode;
-          }
-          return false;
-        };
-        GraphiQL2.formatError = function (error2) {
-          if (Array.isArray(error2)) {
-            return stringify$1({
-              errors: error2.map(function (e) {
-                return handleSingleError(e);
-              }),
-            });
-          }
-          return stringify$1({ errors: handleSingleError(error2) });
-        };
-        GraphiQL2.Logo = GraphiQLLogo;
-        GraphiQL2.Toolbar = GraphiQLToolbar;
-        GraphiQL2.Footer = GraphiQLFooter;
-        GraphiQL2.QueryEditor = QueryEditor;
-        GraphiQL2.VariableEditor = VariableEditor;
-        GraphiQL2.HeaderEditor = HeaderEditor;
-        GraphiQL2.ResultViewer = ResultViewer;
-        GraphiQL2.Button = ToolbarButton;
-        GraphiQL2.ToolbarButton = ToolbarButton;
-        GraphiQL2.Group = ToolbarGroup;
-        GraphiQL2.Menu = ToolbarMenu;
-        GraphiQL2.MenuItem = ToolbarMenuItem;
-        return GraphiQL2;
-      })(React$1.Component);
-      function GraphiQLLogo(props) {
-        return React$1.createElement(
-          "div",
-          { className: "title" },
-          props.children ||
-            React$1.createElement(
-              "span",
-              null,
-              "Graph",
-              React$1.createElement("em", null, "i"),
-              "QL"
-            )
-        );
-      }
-      GraphiQLLogo.displayName = "GraphiQLLogo";
-      function GraphiQLToolbar(props) {
-        return React$1.createElement(
-          "div",
-          {
-            className: "toolbar",
-            role: "toolbar",
-            "aria-label": "Editor Commands",
-          },
-          props.children
-        );
-      }
-      GraphiQLToolbar.displayName = "GraphiQLToolbar";
-      function GraphiQLFooter(props) {
-        return React$1.createElement(
-          "div",
-          { className: "footer" },
-          props.children
-        );
-      }
-      GraphiQLFooter.displayName = "GraphiQLFooter";
-      var defaultQuery =
-        '# Welcome to GraphiQL\n#\n# GraphiQL is an in-browser tool for writing, validating, and\n# testing GraphQL queries.\n#\n# Type queries into this side of the screen, and you will see intelligent\n# typeaheads aware of the current GraphQL type schema and live syntax and\n# validation errors highlighted within the text.\n#\n# GraphQL queries typically start with a "{" character. Lines that start\n# with a # are ignored.\n#\n# An example GraphQL query might look like:\n#\n#     {\n#       field(arg: "value") {\n#         subField\n#       }\n#     }\n#\n# Keyboard shortcuts:\n#\n#  Prettify Query:  Shift-Ctrl-P (or press the prettify button above)\n#\n#     Merge Query:  Shift-Ctrl-M (or press the merge button above)\n#\n#       Run Query:  Ctrl-Enter (or press the play button above)\n#\n#   Auto Complete:  Ctrl-Space (or just start typing)\n#\n\n';
-      function isPromise$1(value) {
-        return typeof value === "object" && typeof value.then === "function";
-      }
-      function observableToPromise(observable) {
-        return new Promise(function (resolve, reject2) {
-          var subscription = observable.subscribe({
-            next: function (v2) {
-              resolve(v2);
-              subscription.unsubscribe();
-            },
-            error: reject2,
-            complete: function () {
-              reject2(new Error("no value resolved"));
-            },
-          });
-        });
-      }
-      function isObservable(value) {
-        return (
-          typeof value === "object" &&
-          "subscribe" in value &&
-          typeof value.subscribe === "function"
-        );
-      }
-      function isAsyncIterable$2(input) {
-        return (
-          typeof input === "object" &&
-          input !== null &&
-          (input[Symbol.toStringTag] === "AsyncGenerator" ||
-            Symbol.asyncIterator in input)
-        );
-      }
-      function asyncIterableToPromise(input) {
-        return new Promise(function (resolve, reject2) {
-          var _a2;
-          var iteratorReturn =
-            (_a2 = ("return" in input ? input : input[Symbol.asyncIterator]())
-              .return) === null || _a2 === void 0
-              ? void 0
-              : _a2.bind(input);
-          var iteratorNext = (
-            "next" in input ? input : input[Symbol.asyncIterator]()
-          ).next.bind(input);
-          iteratorNext()
-            .then(function (result2) {
-              resolve(result2.value);
-              iteratorReturn === null || iteratorReturn === void 0
-                ? void 0
-                : iteratorReturn();
-            })
-            .catch(function (err) {
-              reject2(err);
-            });
-        });
-      }
-      function fetcherReturnToPromise(fetcherResult) {
-        return Promise.resolve(fetcherResult).then(function (fetcherResult2) {
-          if (isAsyncIterable$2(fetcherResult2)) {
-            return asyncIterableToPromise(fetcherResult2);
-          } else if (isObservable(fetcherResult2)) {
-            return observableToPromise(fetcherResult2);
-          }
-          return fetcherResult2;
-        });
-      }
-      function isChildComponentType(child, component) {
-        var _a2;
-        if (
-          ((_a2 = child === null || child === void 0 ? void 0 : child.type) ===
-            null || _a2 === void 0
-            ? void 0
-            : _a2.displayName) &&
-          child.type.displayName === component.displayName
-        ) {
-          return true;
-        }
-        return child.type === component;
-      }
-      function tabsStateEditHeadersReducer(value, state) {
-        return __assign$2(__assign$2({}, state), {
-          tabs: state.tabs.map(function (tab, index) {
-            if (index !== state.activeTabIndex) {
-              return tab;
-            }
-            return __assign$2(__assign$2({}, tab), {
-              headers: value,
-              hash: idFromTabContents({
-                query: tab.query,
-                headers: value,
-                variables: tab.variables,
-              }),
-            });
-          }),
-        });
-      }
-      function tabsStateEditVariablesReducer(value, state) {
-        return __assign$2(__assign$2({}, state), {
-          tabs: state.tabs.map(function (tab, index) {
-            if (index !== state.activeTabIndex) {
-              return tab;
-            }
-            return __assign$2(__assign$2({}, tab), {
-              variables: value,
-              hash: idFromTabContents({
-                query: tab.query,
-                headers: tab.headers,
-                variables: value,
-              }),
-            });
-          }),
-        });
-      }
-      function tabsStateEditQueryReducer(value, state, operationName) {
-        return __assign$2(__assign$2({}, state), {
-          tabs: state.tabs.map(function (tab, index) {
-            if (index !== state.activeTabIndex) {
-              return tab;
-            }
-            return __assign$2(__assign$2({}, tab), {
-              title:
-                operationName !== null && operationName !== void 0
-                  ? operationName
-                  : fuzzyExtractOperationTitle(value),
-              query: value,
-              hash: idFromTabContents({
-                query: value,
-                headers: tab.headers,
-                variables: tab.variables,
-              }),
-            });
-          }),
-        });
-      }
-      function stateOnSelectTabReducer(index, state) {
-        var oldActiveTabIndex = state.tabs.activeTabIndex;
-        var tabs = state.tabs.tabs.map(function (currentTab, tabIndex) {
-          if (tabIndex !== oldActiveTabIndex) {
-            return currentTab;
-          }
-          return __assign$2(__assign$2({}, currentTab), {
-            query: state.query,
-            variables: state.variables,
-            operationName: state.operationName,
-            headers: state.headers,
-            response: state.response,
-            hash: idFromTabContents({
-              query: state.query,
-              variables: state.variables,
-              headers: state.headers,
-            }),
-          });
-        });
-        var newActiveTab = state.tabs.tabs[index];
-        return __assign$2(__assign$2({}, state), {
-          query: newActiveTab.query,
-          variables: newActiveTab.variables,
-          operationName: newActiveTab.operationName,
-          headers: newActiveTab.headers,
-          response: newActiveTab.response,
-          tabs: __assign$2(__assign$2({}, state.tabs), {
-            tabs,
-            activeTabIndex: index,
-          }),
-        });
-      }
-      function stateOnCloseTabReducer(index, state) {
-        var newActiveTabIndex =
-          state.tabs.activeTabIndex > 0 ? state.tabs.activeTabIndex - 1 : 0;
-        var newTabsState = __assign$2(__assign$2({}, state.tabs), {
-          activeTabIndex: newActiveTabIndex,
-          tabs: state.tabs.tabs.filter(function (_tab, i) {
-            return index !== i;
-          }),
-        });
-        var activeTab = newTabsState.tabs[newActiveTabIndex];
-        return __assign$2(__assign$2({}, state), {
-          query: activeTab.query,
-          variables: activeTab.variables,
-          operationName: activeTab.operationName,
-          headers: activeTab.headers,
-          response: activeTab.response,
-          tabs: newTabsState,
-        });
-      }
-      function stateOnTabAddReducer(state) {
-        var oldActiveTabIndex = state.tabs.activeTabIndex;
-        var newTab = {
-          id: guid(),
-          title: "<untitled>",
-          headers: "",
-          variables: "",
-          query: "",
-          operationName: "",
-          response: "",
-          hash: idFromTabContents({
-            query: "",
-            variables: "",
-            headers: "",
-          }),
-        };
-        var tabs = state.tabs.tabs.map(function (tab, index) {
-          if (index !== oldActiveTabIndex) {
-            return tab;
-          }
-          return __assign$2(__assign$2({}, tab), {
-            headers: state.headers,
-            variables: state.variables,
-            query: state.query,
-            operationName: state.operationName,
-            response: state.response,
-          });
-        });
-        return __assign$2(__assign$2({}, state), {
-          headers: newTab.headers,
-          variables: newTab.variables,
-          query: newTab.query,
-          operationName: newTab.operationName,
-          response: newTab.response,
-          tabs: __assign$2(__assign$2({}, state.tabs), {
-            activeTabIndex: state.tabs.tabs.length,
-            tabs: __spread(tabs, [newTab]),
-          }),
-        });
-      }
-      var __extends =
-        (globalThis && globalThis.__extends) ||
-        (function () {
-          var extendStatics = function (d, b) {
-            extendStatics =
-              Object.setPrototypeOf ||
-              ({ __proto__: [] } instanceof Array &&
-                function (d2, b2) {
-                  d2.__proto__ = b2;
-                }) ||
-              function (d2, b2) {
-                for (var p2 in b2)
-                  if (Object.prototype.hasOwnProperty.call(b2, p2))
-                    d2[p2] = b2[p2];
-              };
-            return extendStatics(d, b);
-          };
-          return function (d, b) {
-            extendStatics(d, b);
-            function __() {
-              this.constructor = d;
-            }
-            d.prototype =
-              b === null
-                ? Object.create(b)
-                : ((__.prototype = b.prototype), new __());
-          };
-        })();
-      var __assign$1 =
-        (globalThis && globalThis.__assign) ||
-        function () {
-          __assign$1 =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign$1.apply(this, arguments);
-        };
-      function hasProps(child) {
-        if (!child || typeof child !== "object" || !("props" in child)) {
-          return false;
-        }
-        return true;
-      }
-      (function (_super2) {
-        __extends(ToolbarSelect, _super2);
-        function ToolbarSelect(props) {
-          var _this = _super2.call(this, props) || this;
-          _this._node = null;
-          _this._listener = null;
-          _this.handleOpen = function (e) {
-            preventDefault(e);
-            _this.setState({ visible: true });
-            _this._subscribe();
-          };
-          _this.state = { visible: false };
-          return _this;
-        }
-        ToolbarSelect.prototype.componentWillUnmount = function () {
-          this._release();
-        };
-        ToolbarSelect.prototype.render = function () {
-          var _this = this;
-          var selectedChild;
-          var visible = this.state.visible;
-          var optionChildren = React$1.Children.map(
-            this.props.children,
-            function (child, i) {
-              if (!hasProps(child)) {
-                return null;
-              }
-              if (!selectedChild || child.props.selected) {
-                selectedChild = child;
-              }
-              var onChildSelect =
-                child.props.onSelect ||
-                (_this.props.onSelect &&
-                  _this.props.onSelect.bind(null, child.props.value, i));
-              return React$1.createElement(
-                ToolbarSelectOption,
-                __assign$1({}, child.props, { onSelect: onChildSelect })
-              );
-            }
-          );
-          return React$1.createElement(
-            "a",
-            {
-              className: "toolbar-select toolbar-button",
-              onClick: this.handleOpen.bind(this),
-              onMouseDown: preventDefault,
-              ref: function (node) {
-                _this._node = node;
-              },
-              title: this.props.title,
-            },
-            selectedChild === null || selectedChild === void 0
-              ? void 0
-              : selectedChild.props.label,
-            React$1.createElement(
-              "svg",
-              { width: "13", height: "10" },
-              React$1.createElement("path", {
-                fill: "#666",
-                d: "M 5 5 L 13 5 L 9 1 z",
-              }),
-              React$1.createElement("path", {
-                fill: "#666",
-                d: "M 5 6 L 13 6 L 9 10 z",
-              })
-            ),
-            React$1.createElement(
-              "ul",
-              {
-                className: "toolbar-select-options" + (visible ? " open" : ""),
-              },
-              optionChildren
-            )
-          );
-        };
-        ToolbarSelect.prototype._subscribe = function () {
-          if (!this._listener) {
-            this._listener = this.handleClick.bind(this);
-            document.addEventListener("click", this._listener);
-          }
-        };
-        ToolbarSelect.prototype._release = function () {
-          if (this._listener) {
-            document.removeEventListener("click", this._listener);
-            this._listener = null;
-          }
-        };
-        ToolbarSelect.prototype.handleClick = function (e) {
-          if (this._node !== e.target) {
-            preventDefault(e);
-            this.setState({ visible: false });
-            this._release();
-          }
-        };
-        return ToolbarSelect;
-      })(React$1.Component);
-      function ToolbarSelectOption(_a2) {
-        var onSelect = _a2.onSelect,
-          label = _a2.label,
-          selected = _a2.selected;
-        return React$1.createElement(
-          "li",
-          {
-            onMouseOver: function (e) {
-              e.currentTarget.className = "hover";
-            },
-            onMouseOut: function (e) {
-              e.currentTarget.className = "";
-            },
-            onMouseDown: preventDefault,
-            onMouseUp: onSelect,
-          },
-          label,
-          selected &&
-            React$1.createElement(
-              "svg",
-              { width: "13", height: "13" },
-              React$1.createElement("polygon", {
-                points:
-                  "4.851,10.462 0,5.611 2.314,3.297 4.851,5.835\n    10.686,0 13,2.314 4.851,10.462",
-              })
-            )
-        );
-      }
-      function preventDefault(e) {
-        e.preventDefault();
-      }
-      let AggregateErrorImpl;
-      if (typeof AggregateError === "undefined") {
-        class AggregateErrorClass extends Error {
-          constructor(errors2, message = "") {
-            super(message);
-            this.errors = errors2;
-            this.name = "AggregateError";
-            Error.captureStackTrace(this, AggregateErrorClass);
-          }
-        }
-        AggregateErrorImpl = function (errors2, message) {
-          return new AggregateErrorClass(errors2, message);
-        };
-      } else {
-        AggregateErrorImpl = AggregateError;
-      }
-      function isAggregateError(error2) {
-        return "errors" in error2 && Array.isArray(error2["errors"]);
-      }
-      const MAX_RECURSIVE_DEPTH$1 = 3;
-      function inspect$1(value) {
-        return formatValue$1(value, []);
-      }
-      function formatValue$1(value, seenValues) {
-        switch (typeof value) {
-          case "string":
-            return JSON.stringify(value);
-          case "function":
-            return value.name ? `[function ${value.name}]` : "[function]";
-          case "object":
-            return formatObjectValue$1(value, seenValues);
-          default:
-            return String(value);
-        }
-      }
-      function formatError(value) {
-        if (value instanceof GraphQLError) {
-          return value.toString();
-        }
-        return `${value.name}: ${value.message};
- ${value.stack}`;
-      }
-      function formatObjectValue$1(value, previouslySeenValues) {
-        if (value === null) {
-          return "null";
-        }
-        if (value instanceof Error) {
-          if (isAggregateError(value)) {
-            return (
-              formatError(value) +
-              "\n" +
-              formatArray$1(value.errors, previouslySeenValues)
-            );
-          }
-          return formatError(value);
-        }
-        if (previouslySeenValues.includes(value)) {
-          return "[Circular]";
-        }
-        const seenValues = [...previouslySeenValues, value];
-        if (isJSONable$1(value)) {
-          const jsonValue = value.toJSON();
-          if (jsonValue !== value) {
-            return typeof jsonValue === "string"
-              ? jsonValue
-              : formatValue$1(jsonValue, seenValues);
-          }
-        } else if (Array.isArray(value)) {
-          return formatArray$1(value, seenValues);
-        }
-        return formatObject$1(value, seenValues);
-      }
-      function isJSONable$1(value) {
-        return typeof value.toJSON === "function";
-      }
-      function formatObject$1(object, seenValues) {
-        const entries = Object.entries(object);
-        if (entries.length === 0) {
-          return "{}";
-        }
-        if (seenValues.length > MAX_RECURSIVE_DEPTH$1) {
-          return "[" + getObjectTag$1(object) + "]";
-        }
-        const properties = entries.map(
-          ([key, value]) => key + ": " + formatValue$1(value, seenValues)
-        );
-        return "{ " + properties.join(", ") + " }";
-      }
-      function formatArray$1(array, seenValues) {
-        if (array.length === 0) {
-          return "[]";
-        }
-        if (seenValues.length > MAX_RECURSIVE_DEPTH$1) {
-          return "[Array]";
-        }
-        const len = array.length;
-        const remaining = array.length;
-        const items = [];
-        for (let i = 0; i < len; ++i) {
-          items.push(formatValue$1(array[i], seenValues));
-        }
-        if (remaining === 1) {
-          items.push("... 1 more item");
-        } else if (remaining > 1) {
-          items.push(`... ${remaining} more items`);
-        }
-        return "[" + items.join(", ") + "]";
-      }
-      function getObjectTag$1(object) {
-        const tag = Object.prototype.toString
-          .call(object)
-          .replace(/^\[object /, "")
-          .replace(/]$/, "");
-        if (tag === "Object" && typeof object.constructor === "function") {
-          const name2 = object.constructor.name;
-          if (typeof name2 === "string" && name2 !== "") {
-            return name2;
-          }
-        }
-        return tag;
-      }
-      function astFromType(type2) {
-        if (isNonNullType(type2)) {
-          const innerType = astFromType(type2.ofType);
-          if (innerType.kind === Kind.NON_NULL_TYPE) {
-            throw new Error(
-              `Invalid type node ${inspect$1(
-                type2
-              )}. Inner type of non-null type cannot be a non-null type.`
-            );
-          }
-          return {
-            kind: Kind.NON_NULL_TYPE,
-            type: innerType,
-          };
-        } else if (isListType(type2)) {
-          return {
-            kind: Kind.LIST_TYPE,
-            type: astFromType(type2.ofType),
-          };
-        }
-        return {
-          kind: Kind.NAMED_TYPE,
-          name: {
-            kind: Kind.NAME,
-            value: type2.name,
-          },
-        };
-      }
-      function memoize1$1(fn) {
-        const memoize1cache = /* @__PURE__ */ new WeakMap();
-        return function memoized(a1) {
-          const cachedValue = memoize1cache.get(a1);
-          if (cachedValue === void 0) {
-            const newValue = fn(a1);
-            memoize1cache.set(a1, newValue);
-            return newValue;
-          }
-          return cachedValue;
-        };
-      }
-      function memoize2$1(fn) {
-        const memoize2cache = /* @__PURE__ */ new WeakMap();
-        return function memoized(a1, a2) {
-          let cache2 = memoize2cache.get(a1);
-          if (!cache2) {
-            cache2 = /* @__PURE__ */ new WeakMap();
-            memoize2cache.set(a1, cache2);
-            const newValue = fn(a1, a2);
-            cache2.set(a2, newValue);
-            return newValue;
-          }
-          const cachedValue = cache2.get(a2);
-          if (cachedValue === void 0) {
-            const newValue = fn(a1, a2);
-            cache2.set(a2, newValue);
-            return newValue;
-          }
-          return cachedValue;
-        };
-      }
-      const memoize2of4cache = /* @__PURE__ */ new WeakMap();
-      function memoize2of4(fn) {
-        return function memoized(a1, a2, a3, a4) {
-          let cache2 = memoize2of4cache.get(a1);
-          if (!cache2) {
-            cache2 = /* @__PURE__ */ new WeakMap();
-            memoize2of4cache.set(a1, cache2);
-            const newValue = fn(a1, a2, a3, a4);
-            cache2.set(a2, newValue);
-            return newValue;
-          }
-          const cachedValue = cache2.get(a2);
-          if (cachedValue === void 0) {
-            const newValue = fn(a1, a2, a3, a4);
-            cache2.set(a2, newValue);
-            return newValue;
-          }
-          return cachedValue;
-        };
-      }
-      function getDefinedRootType(schema, operation) {
-        const rootTypeMap = getRootTypeMap(schema);
-        const rootType = rootTypeMap.get(operation);
-        if (rootType == null) {
-          throw new Error(
-            `Root type for operation "${operation}" not defined by the given schema.`
-          );
-        }
-        return rootType;
-      }
-      const getRootTypeNames = memoize1$1(function getRootTypeNames2(schema) {
-        const rootTypes = getRootTypes(schema);
-        return new Set([...rootTypes].map((type2) => type2.name));
-      });
-      const getRootTypes = memoize1$1(function getRootTypes2(schema) {
-        const rootTypeMap = getRootTypeMap(schema);
-        return new Set(rootTypeMap.values());
-      });
-      const getRootTypeMap = memoize1$1(function getRootTypeMap2(schema) {
-        const rootTypeMap = /* @__PURE__ */ new Map();
-        const queryType = schema.getQueryType();
-        if (queryType) {
-          rootTypeMap.set("query", queryType);
-        }
-        const mutationType = schema.getMutationType();
-        if (mutationType) {
-          rootTypeMap.set("mutation", mutationType);
-        }
-        const subscriptionType = schema.getSubscriptionType();
-        if (subscriptionType) {
-          rootTypeMap.set("subscription", subscriptionType);
-        }
-        return rootTypeMap;
-      });
-      const MAX_LINE_LENGTH = 80;
-      let commentsRegistry = {};
-      function printComment(comment2) {
-        return "\n# " + comment2.replace(/\n/g, "\n# ");
-      }
-      function join(maybeArray, separator2) {
-        return maybeArray
-          ? maybeArray.filter((x2) => x2).join(separator2 || "")
-          : "";
-      }
-      function hasMultilineItems(maybeArray) {
-        var _a2;
-        return (_a2 =
-          maybeArray === null || maybeArray === void 0
-            ? void 0
-            : maybeArray.some((str) => str.includes("\n"))) !== null &&
-          _a2 !== void 0
-          ? _a2
-          : false;
-      }
-      function addDescription(cb2) {
-        return (node, _key, _parent, path, ancestors) => {
-          var _a2;
-          const keys = [];
-          const parent = path.reduce((prev, key2) => {
-            if (["fields", "arguments", "values"].includes(key2) && prev.name) {
-              keys.push(prev.name.value);
-            }
-            return prev[key2];
-          }, ancestors[0]);
-          const key = [
-            ...keys,
-            (_a2 =
-              parent === null || parent === void 0 ? void 0 : parent.name) ===
-              null || _a2 === void 0
-              ? void 0
-              : _a2.value,
-          ]
-            .filter(Boolean)
-            .join(".");
-          const items = [];
-          if (node.kind.includes("Definition") && commentsRegistry[key]) {
-            items.push(...commentsRegistry[key]);
-          }
-          return join(
-            [
-              ...items.map(printComment),
-              node.description,
-              cb2(node, _key, _parent, path, ancestors),
-            ],
-            "\n"
-          );
-        };
-      }
-      function indent$3(maybeString) {
-        return maybeString && `  ${maybeString.replace(/\n/g, "\n  ")}`;
-      }
-      function block2(array) {
-        return array && array.length !== 0
-          ? `{
-${indent$3(join(array, "\n"))}
-}`
-          : "";
-      }
-      function wrap(start2, maybeString, end2) {
-        return maybeString ? start2 + maybeString + (end2 || "") : "";
-      }
-      function printBlockString(value, isDescription = false) {
-        const escaped = value.replace(/"""/g, '\\"""');
-        return (value[0] === " " || value[0] === "	") &&
-          value.indexOf("\n") === -1
-          ? `"""${escaped.replace(/"$/, '"\n')}"""`
-          : `"""
-${isDescription ? escaped : indent$3(escaped)}
-"""`;
-      }
-      const printDocASTReducer = {
-        Name: { leave: (node) => node.value },
-        Variable: { leave: (node) => "$" + node.name },
-        Document: {
-          leave: (node) => join(node.definitions, "\n\n"),
-        },
-        OperationDefinition: {
-          leave: (node) => {
-            const varDefs = wrap(
-              "(",
-              join(node.variableDefinitions, ", "),
-              ")"
-            );
-            const prefix = join(
-              [
-                node.operation,
-                join([node.name, varDefs]),
-                join(node.directives, " "),
-              ],
-              " "
-            );
-            return prefix + " " + node.selectionSet;
-          },
-        },
-        VariableDefinition: {
-          leave: ({
-            variable,
-            type: type2,
-            defaultValue: defaultValue2,
-            directives,
-          }) =>
-            variable +
-            ": " +
-            type2 +
-            wrap(" = ", defaultValue2) +
-            wrap(" ", join(directives, " ")),
-        },
-        SelectionSet: { leave: ({ selections }) => block2(selections) },
-        Field: {
-          leave({
-            alias,
-            name: name2,
-            arguments: args,
-            directives,
-            selectionSet,
-          }) {
-            const prefix = wrap("", alias, ": ") + name2;
-            let argsLine = prefix + wrap("(", join(args, ", "), ")");
-            if (argsLine.length > MAX_LINE_LENGTH) {
-              argsLine =
-                prefix + wrap("(\n", indent$3(join(args, "\n")), "\n)");
-            }
-            return join([argsLine, join(directives, " "), selectionSet], " ");
-          },
-        },
-        Argument: { leave: ({ name: name2, value }) => name2 + ": " + value },
-        FragmentSpread: {
-          leave: ({ name: name2, directives }) =>
-            "..." + name2 + wrap(" ", join(directives, " ")),
-        },
-        InlineFragment: {
-          leave: ({ typeCondition, directives, selectionSet }) =>
-            join(
-              [
-                "...",
-                wrap("on ", typeCondition),
-                join(directives, " "),
-                selectionSet,
-              ],
-              " "
-            ),
-        },
-        FragmentDefinition: {
-          leave: ({
-            name: name2,
-            typeCondition,
-            variableDefinitions,
-            directives,
-            selectionSet,
-          }) =>
-            `fragment ${name2}${wrap(
-              "(",
-              join(variableDefinitions, ", "),
-              ")"
-            )} on ${typeCondition} ${wrap("", join(directives, " "), " ")}` +
-            selectionSet,
-        },
-        IntValue: { leave: ({ value }) => value },
-        FloatValue: { leave: ({ value }) => value },
-        StringValue: {
-          leave: ({ value, block: isBlockString }) => {
-            if (isBlockString) {
-              return printBlockString(value);
-            }
-            return JSON.stringify(value);
-          },
-        },
-        BooleanValue: { leave: ({ value }) => (value ? "true" : "false") },
-        NullValue: { leave: () => "null" },
-        EnumValue: { leave: ({ value }) => value },
-        ListValue: { leave: ({ values }) => "[" + join(values, ", ") + "]" },
-        ObjectValue: { leave: ({ fields }) => "{" + join(fields, ", ") + "}" },
-        ObjectField: {
-          leave: ({ name: name2, value }) => name2 + ": " + value,
-        },
-        Directive: {
-          leave: ({ name: name2, arguments: args }) =>
-            "@" + name2 + wrap("(", join(args, ", "), ")"),
-        },
-        NamedType: { leave: ({ name: name2 }) => name2 },
-        ListType: { leave: ({ type: type2 }) => "[" + type2 + "]" },
-        NonNullType: { leave: ({ type: type2 }) => type2 + "!" },
-        SchemaDefinition: {
-          leave: ({ directives, operationTypes }) =>
-            join(
-              ["schema", join(directives, " "), block2(operationTypes)],
-              " "
-            ),
-        },
-        OperationTypeDefinition: {
-          leave: ({ operation, type: type2 }) => operation + ": " + type2,
-        },
-        ScalarTypeDefinition: {
-          leave: ({ name: name2, directives }) =>
-            join(["scalar", name2, join(directives, " ")], " "),
-        },
-        ObjectTypeDefinition: {
-          leave: ({ name: name2, interfaces, directives, fields }) =>
-            join(
-              [
-                "type",
-                name2,
-                wrap("implements ", join(interfaces, " & ")),
-                join(directives, " "),
-                block2(fields),
-              ],
-              " "
-            ),
-        },
-        FieldDefinition: {
-          leave: ({ name: name2, arguments: args, type: type2, directives }) =>
-            name2 +
-            (hasMultilineItems(args)
-              ? wrap("(\n", indent$3(join(args, "\n")), "\n)")
-              : wrap("(", join(args, ", "), ")")) +
-            ": " +
-            type2 +
-            wrap(" ", join(directives, " ")),
-        },
-        InputValueDefinition: {
-          leave: ({
-            name: name2,
-            type: type2,
-            defaultValue: defaultValue2,
-            directives,
-          }) =>
-            join(
-              [
-                name2 + ": " + type2,
-                wrap("= ", defaultValue2),
-                join(directives, " "),
-              ],
-              " "
-            ),
-        },
-        InterfaceTypeDefinition: {
-          leave: ({ name: name2, interfaces, directives, fields }) =>
-            join(
-              [
-                "interface",
-                name2,
-                wrap("implements ", join(interfaces, " & ")),
-                join(directives, " "),
-                block2(fields),
-              ],
-              " "
-            ),
-        },
-        UnionTypeDefinition: {
-          leave: ({ name: name2, directives, types }) =>
-            join(
-              [
-                "union",
-                name2,
-                join(directives, " "),
-                wrap("= ", join(types, " | ")),
-              ],
-              " "
-            ),
-        },
-        EnumTypeDefinition: {
-          leave: ({ name: name2, directives, values }) =>
-            join(["enum", name2, join(directives, " "), block2(values)], " "),
-        },
-        EnumValueDefinition: {
-          leave: ({ name: name2, directives }) =>
-            join([name2, join(directives, " ")], " "),
-        },
-        InputObjectTypeDefinition: {
-          leave: ({ name: name2, directives, fields }) =>
-            join(["input", name2, join(directives, " "), block2(fields)], " "),
-        },
-        DirectiveDefinition: {
-          leave: ({ name: name2, arguments: args, repeatable, locations }) =>
-            "directive @" +
-            name2 +
-            (hasMultilineItems(args)
-              ? wrap("(\n", indent$3(join(args, "\n")), "\n)")
-              : wrap("(", join(args, ", "), ")")) +
-            (repeatable ? " repeatable" : "") +
-            " on " +
-            join(locations, " | "),
-        },
-        SchemaExtension: {
-          leave: ({ directives, operationTypes }) =>
-            join(
-              ["extend schema", join(directives, " "), block2(operationTypes)],
-              " "
-            ),
-        },
-        ScalarTypeExtension: {
-          leave: ({ name: name2, directives }) =>
-            join(["extend scalar", name2, join(directives, " ")], " "),
-        },
-        ObjectTypeExtension: {
-          leave: ({ name: name2, interfaces, directives, fields }) =>
-            join(
-              [
-                "extend type",
-                name2,
-                wrap("implements ", join(interfaces, " & ")),
-                join(directives, " "),
-                block2(fields),
-              ],
-              " "
-            ),
-        },
-        InterfaceTypeExtension: {
-          leave: ({ name: name2, interfaces, directives, fields }) =>
-            join(
-              [
-                "extend interface",
-                name2,
-                wrap("implements ", join(interfaces, " & ")),
-                join(directives, " "),
-                block2(fields),
-              ],
-              " "
-            ),
-        },
-        UnionTypeExtension: {
-          leave: ({ name: name2, directives, types }) =>
-            join(
-              [
-                "extend union",
-                name2,
-                join(directives, " "),
-                wrap("= ", join(types, " | ")),
-              ],
-              " "
-            ),
-        },
-        EnumTypeExtension: {
-          leave: ({ name: name2, directives, values }) =>
-            join(
-              ["extend enum", name2, join(directives, " "), block2(values)],
-              " "
-            ),
-        },
-        InputObjectTypeExtension: {
-          leave: ({ name: name2, directives, fields }) =>
-            join(
-              ["extend input", name2, join(directives, " "), block2(fields)],
-              " "
-            ),
-        },
-      };
-      Object.keys(printDocASTReducer).reduce(
-        (prev, key) =>
-          __spreadProps(__spreadValues({}, prev), {
-            [key]: {
-              leave: addDescription(printDocASTReducer[key].leave),
-            },
-          }),
-        {}
-      );
-      function getLeadingCommentBlock(node) {
-        const loc = node.loc;
-        if (!loc) {
-          return;
-        }
-        const comments = [];
-        let token2 = loc.startToken.prev;
-        while (
-          token2 != null &&
-          token2.kind === TokenKind.COMMENT &&
-          token2.next != null &&
-          token2.prev != null &&
-          token2.line + 1 === token2.next.line &&
-          token2.line !== token2.prev.line
-        ) {
-          const value = String(token2.value);
-          comments.push(value);
-          token2 = token2.prev;
-        }
-        return comments.length > 0 ? comments.reverse().join("\n") : void 0;
-      }
-      function dedentBlockStringValue(rawString) {
-        const lines = rawString.split(/\r\n|[\n\r]/g);
-        const commonIndent = getBlockStringIndentation(lines);
-        if (commonIndent !== 0) {
-          for (let i = 1; i < lines.length; i++) {
-            lines[i] = lines[i].slice(commonIndent);
-          }
-        }
-        while (lines.length > 0 && isBlank(lines[0])) {
-          lines.shift();
-        }
-        while (lines.length > 0 && isBlank(lines[lines.length - 1])) {
-          lines.pop();
-        }
-        return lines.join("\n");
-      }
-      function getBlockStringIndentation(lines) {
-        let commonIndent = null;
-        for (let i = 1; i < lines.length; i++) {
-          const line = lines[i];
-          const indent2 = leadingWhitespace(line);
-          if (indent2 === line.length) {
-            continue;
-          }
-          if (commonIndent === null || indent2 < commonIndent) {
-            commonIndent = indent2;
-            if (commonIndent === 0) {
-              break;
-            }
-          }
-        }
-        return commonIndent === null ? 0 : commonIndent;
-      }
-      function leadingWhitespace(str) {
-        let i = 0;
-        while (i < str.length && (str[i] === " " || str[i] === "	")) {
-          i++;
-        }
-        return i;
-      }
-      function isBlank(str) {
-        return leadingWhitespace(str) === str.length;
-      }
-      function parseGraphQLSDL(location2, rawSDL, options = {}) {
-        let document2;
-        try {
-          if (options.commentDescriptions && rawSDL.includes("#")) {
-            document2 = transformCommentsToDescriptions(rawSDL, options);
-            if (options.noLocation) {
-              document2 = parse$1(print(document2), options);
-            }
-          } else {
-            document2 = parse$1(new Source(rawSDL, location2), options);
-          }
-        } catch (e) {
-          if (
-            e.message.includes("EOF") &&
-            rawSDL.replace(/(\#[^*]*)/g, "").trim() === ""
-          ) {
-            document2 = {
-              kind: Kind.DOCUMENT,
-              definitions: [],
-            };
-          } else {
-            throw e;
-          }
-        }
-        return {
-          location: location2,
-          document: document2,
-        };
-      }
-      function transformCommentsToDescriptions(sourceSdl, options = {}) {
-        const parsedDoc = parse$1(
-          sourceSdl,
-          __spreadProps(__spreadValues({}, options), {
-            noLocation: false,
-          })
-        );
-        const modifiedDoc = visit(parsedDoc, {
-          leave: (node) => {
-            if (isDescribable(node)) {
-              const rawValue = getLeadingCommentBlock(node);
-              if (rawValue !== void 0) {
-                const commentsBlock = dedentBlockStringValue("\n" + rawValue);
-                const isBlock = commentsBlock.includes("\n");
-                if (!node.description) {
-                  return __spreadProps(__spreadValues({}, node), {
-                    description: {
-                      kind: Kind.STRING,
-                      value: commentsBlock,
-                      block: isBlock,
-                    },
-                  });
-                } else {
-                  return __spreadProps(__spreadValues({}, node), {
-                    description: __spreadProps(
-                      __spreadValues({}, node.description),
-                      {
-                        value: node.description.value + "\n" + commentsBlock,
-                        block: true,
-                      }
-                    ),
-                  });
-                }
-              }
-            }
-          },
-        });
-        return modifiedDoc;
-      }
-      function isDescribable(node) {
-        return (
-          isTypeSystemDefinitionNode(node) ||
-          node.kind === Kind.FIELD_DEFINITION ||
-          node.kind === Kind.INPUT_VALUE_DEFINITION ||
-          node.kind === Kind.ENUM_VALUE_DEFINITION
-        );
-      }
-      var MapperKind;
-      (function (MapperKind2) {
-        MapperKind2["TYPE"] = "MapperKind.TYPE";
-        MapperKind2["SCALAR_TYPE"] = "MapperKind.SCALAR_TYPE";
-        MapperKind2["ENUM_TYPE"] = "MapperKind.ENUM_TYPE";
-        MapperKind2["COMPOSITE_TYPE"] = "MapperKind.COMPOSITE_TYPE";
-        MapperKind2["OBJECT_TYPE"] = "MapperKind.OBJECT_TYPE";
-        MapperKind2["INPUT_OBJECT_TYPE"] = "MapperKind.INPUT_OBJECT_TYPE";
-        MapperKind2["ABSTRACT_TYPE"] = "MapperKind.ABSTRACT_TYPE";
-        MapperKind2["UNION_TYPE"] = "MapperKind.UNION_TYPE";
-        MapperKind2["INTERFACE_TYPE"] = "MapperKind.INTERFACE_TYPE";
-        MapperKind2["ROOT_OBJECT"] = "MapperKind.ROOT_OBJECT";
-        MapperKind2["QUERY"] = "MapperKind.QUERY";
-        MapperKind2["MUTATION"] = "MapperKind.MUTATION";
-        MapperKind2["SUBSCRIPTION"] = "MapperKind.SUBSCRIPTION";
-        MapperKind2["DIRECTIVE"] = "MapperKind.DIRECTIVE";
-        MapperKind2["FIELD"] = "MapperKind.FIELD";
-        MapperKind2["COMPOSITE_FIELD"] = "MapperKind.COMPOSITE_FIELD";
-        MapperKind2["OBJECT_FIELD"] = "MapperKind.OBJECT_FIELD";
-        MapperKind2["ROOT_FIELD"] = "MapperKind.ROOT_FIELD";
-        MapperKind2["QUERY_ROOT_FIELD"] = "MapperKind.QUERY_ROOT_FIELD";
-        MapperKind2["MUTATION_ROOT_FIELD"] = "MapperKind.MUTATION_ROOT_FIELD";
-        MapperKind2["SUBSCRIPTION_ROOT_FIELD"] =
-          "MapperKind.SUBSCRIPTION_ROOT_FIELD";
-        MapperKind2["INTERFACE_FIELD"] = "MapperKind.INTERFACE_FIELD";
-        MapperKind2["INPUT_OBJECT_FIELD"] = "MapperKind.INPUT_OBJECT_FIELD";
-        MapperKind2["ARGUMENT"] = "MapperKind.ARGUMENT";
-        MapperKind2["ENUM_VALUE"] = "MapperKind.ENUM_VALUE";
-      })(MapperKind || (MapperKind = {}));
-      function getObjectTypeFromTypeMap(typeMap, type2) {
-        if (type2) {
-          const maybeObjectType = typeMap[type2.name];
-          if (isObjectType(maybeObjectType)) {
-            return maybeObjectType;
-          }
-        }
-      }
-      function isNamedStub(type2) {
-        if ("getFields" in type2) {
-          const fields = type2.getFields();
-          for (const fieldName in fields) {
-            const field = fields[fieldName];
-            return field.name === "_fake";
-          }
-        }
-        return false;
-      }
-      function getBuiltInForStub(type2) {
-        switch (type2.name) {
-          case GraphQLInt.name:
-            return GraphQLInt;
-          case GraphQLFloat.name:
-            return GraphQLFloat;
-          case GraphQLString.name:
-            return GraphQLString;
-          case GraphQLBoolean.name:
-            return GraphQLBoolean;
-          case GraphQLID.name:
-            return GraphQLID;
-          default:
-            return type2;
-        }
-      }
-      function rewireTypes(originalTypeMap, directives) {
-        const referenceTypeMap = /* @__PURE__ */ Object.create(null);
-        for (const typeName in originalTypeMap) {
-          referenceTypeMap[typeName] = originalTypeMap[typeName];
-        }
-        const newTypeMap = /* @__PURE__ */ Object.create(null);
-        for (const typeName in referenceTypeMap) {
-          const namedType = referenceTypeMap[typeName];
-          if (namedType == null || typeName.startsWith("__")) {
-            continue;
-          }
-          const newName = namedType.name;
-          if (newName.startsWith("__")) {
-            continue;
-          }
-          if (newTypeMap[newName] != null) {
-            throw new Error(`Duplicate schema type name ${newName}`);
-          }
-          newTypeMap[newName] = namedType;
-        }
-        for (const typeName in newTypeMap) {
-          newTypeMap[typeName] = rewireNamedType(newTypeMap[typeName]);
-        }
-        const newDirectives = directives.map((directive) =>
-          rewireDirective(directive)
-        );
-        return {
-          typeMap: newTypeMap,
-          directives: newDirectives,
-        };
-        function rewireDirective(directive) {
-          if (isSpecifiedDirective(directive)) {
-            return directive;
-          }
-          const directiveConfig = directive.toConfig();
-          directiveConfig.args = rewireArgs(directiveConfig.args);
-          return new GraphQLDirective(directiveConfig);
-        }
-        function rewireArgs(args) {
-          const rewiredArgs = {};
-          for (const argName in args) {
-            const arg = args[argName];
-            const rewiredArgType = rewireType(arg.type);
-            if (rewiredArgType != null) {
-              arg.type = rewiredArgType;
-              rewiredArgs[argName] = arg;
-            }
-          }
-          return rewiredArgs;
-        }
-        function rewireNamedType(type2) {
-          if (isObjectType(type2)) {
-            const config2 = type2.toConfig();
-            const newConfig = __spreadProps(__spreadValues({}, config2), {
-              fields: () => rewireFields(config2.fields),
-              interfaces: () => rewireNamedTypes(config2.interfaces),
-            });
-            return new GraphQLObjectType(newConfig);
-          } else if (isInterfaceType(type2)) {
-            const config2 = type2.toConfig();
-            const newConfig = __spreadProps(__spreadValues({}, config2), {
-              fields: () => rewireFields(config2.fields),
-            });
-            if ("interfaces" in newConfig) {
-              newConfig.interfaces = () => rewireNamedTypes(config2.interfaces);
-            }
-            return new GraphQLInterfaceType(newConfig);
-          } else if (isUnionType(type2)) {
-            const config2 = type2.toConfig();
-            const newConfig = __spreadProps(__spreadValues({}, config2), {
-              types: () => rewireNamedTypes(config2.types),
-            });
-            return new GraphQLUnionType(newConfig);
-          } else if (isInputObjectType(type2)) {
-            const config2 = type2.toConfig();
-            const newConfig = __spreadProps(__spreadValues({}, config2), {
-              fields: () => rewireInputFields(config2.fields),
-            });
-            return new GraphQLInputObjectType(newConfig);
-          } else if (isEnumType(type2)) {
-            const enumConfig = type2.toConfig();
-            return new GraphQLEnumType(enumConfig);
-          } else if (isScalarType(type2)) {
-            if (isSpecifiedScalarType(type2)) {
-              return type2;
-            }
-            const scalarConfig = type2.toConfig();
-            return new GraphQLScalarType(scalarConfig);
-          }
-          throw new Error(`Unexpected schema type: ${type2}`);
-        }
-        function rewireFields(fields) {
-          const rewiredFields = {};
-          for (const fieldName in fields) {
-            const field = fields[fieldName];
-            const rewiredFieldType = rewireType(field.type);
-            if (rewiredFieldType != null && field.args) {
-              field.type = rewiredFieldType;
-              field.args = rewireArgs(field.args);
-              rewiredFields[fieldName] = field;
-            }
-          }
-          return rewiredFields;
-        }
-        function rewireInputFields(fields) {
-          const rewiredFields = {};
-          for (const fieldName in fields) {
-            const field = fields[fieldName];
-            const rewiredFieldType = rewireType(field.type);
-            if (rewiredFieldType != null) {
-              field.type = rewiredFieldType;
-              rewiredFields[fieldName] = field;
-            }
-          }
-          return rewiredFields;
-        }
-        function rewireNamedTypes(namedTypes) {
-          const rewiredTypes = [];
-          for (const namedType of namedTypes) {
-            const rewiredType = rewireType(namedType);
-            if (rewiredType != null) {
-              rewiredTypes.push(rewiredType);
-            }
-          }
-          return rewiredTypes;
-        }
-        function rewireType(type2) {
-          if (isListType(type2)) {
-            const rewiredType = rewireType(type2.ofType);
-            return rewiredType != null ? new GraphQLList(rewiredType) : null;
-          } else if (isNonNullType(type2)) {
-            const rewiredType = rewireType(type2.ofType);
-            return rewiredType != null ? new GraphQLNonNull(rewiredType) : null;
-          } else if (isNamedType(type2)) {
-            let rewiredType = referenceTypeMap[type2.name];
-            if (rewiredType === void 0) {
-              rewiredType = isNamedStub(type2)
-                ? getBuiltInForStub(type2)
-                : rewireNamedType(type2);
-              newTypeMap[rewiredType.name] = referenceTypeMap[type2.name] =
-                rewiredType;
-            }
-            return rewiredType != null ? newTypeMap[rewiredType.name] : null;
-          }
-          return null;
-        }
-      }
-      function transformInputValue(
-        type2,
-        value,
-        inputLeafValueTransformer = null,
-        inputObjectValueTransformer = null
-      ) {
-        if (value == null) {
-          return value;
-        }
-        const nullableType = getNullableType(type2);
-        if (isLeafType(nullableType)) {
-          return inputLeafValueTransformer != null
-            ? inputLeafValueTransformer(nullableType, value)
-            : value;
-        } else if (isListType(nullableType)) {
-          return value.map((listMember) =>
-            transformInputValue(
-              nullableType.ofType,
-              listMember,
-              inputLeafValueTransformer,
-              inputObjectValueTransformer
-            )
-          );
-        } else if (isInputObjectType(nullableType)) {
-          const fields = nullableType.getFields();
-          const newValue = {};
-          for (const key in value) {
-            const field = fields[key];
-            if (field != null) {
-              newValue[key] = transformInputValue(
-                field.type,
-                value[key],
-                inputLeafValueTransformer,
-                inputObjectValueTransformer
-              );
-            }
-          }
-          return inputObjectValueTransformer != null
-            ? inputObjectValueTransformer(nullableType, newValue)
-            : newValue;
-        }
-      }
-      function serializeInputValue(type2, value) {
-        return transformInputValue(type2, value, (t2, v2) => {
-          try {
-            return t2.serialize(v2);
-          } catch (_a2) {
-            return v2;
-          }
-        });
-      }
-      function parseInputValue(type2, value) {
-        return transformInputValue(type2, value, (t2, v2) => {
-          try {
-            return t2.parseValue(v2);
-          } catch (_a2) {
-            return v2;
-          }
-        });
-      }
-      function mapSchema(schema, schemaMapper = {}) {
-        const newTypeMap = mapArguments(
-          mapFields(
-            mapTypes(
-              mapDefaultValues(
-                mapEnumValues(
-                  mapTypes(
-                    mapDefaultValues(
-                      schema.getTypeMap(),
-                      schema,
-                      serializeInputValue
-                    ),
-                    schema,
-                    schemaMapper,
-                    (type2) => isLeafType(type2)
-                  ),
-                  schema,
-                  schemaMapper
-                ),
-                schema,
-                parseInputValue
-              ),
-              schema,
-              schemaMapper,
-              (type2) => !isLeafType(type2)
-            ),
-            schema,
-            schemaMapper
-          ),
-          schema,
-          schemaMapper
-        );
-        const originalDirectives = schema.getDirectives();
-        const newDirectives = mapDirectives(
-          originalDirectives,
-          schema,
-          schemaMapper
-        );
-        const { typeMap, directives } = rewireTypes(newTypeMap, newDirectives);
-        return new GraphQLSchema(
-          __spreadProps(__spreadValues({}, schema.toConfig()), {
-            query: getObjectTypeFromTypeMap(
-              typeMap,
-              getObjectTypeFromTypeMap(newTypeMap, schema.getQueryType())
-            ),
-            mutation: getObjectTypeFromTypeMap(
-              typeMap,
-              getObjectTypeFromTypeMap(newTypeMap, schema.getMutationType())
-            ),
-            subscription: getObjectTypeFromTypeMap(
-              typeMap,
-              getObjectTypeFromTypeMap(newTypeMap, schema.getSubscriptionType())
-            ),
-            types: Object.values(typeMap),
-            directives,
-          })
-        );
-      }
-      function mapTypes(
-        originalTypeMap,
-        schema,
-        schemaMapper,
-        testFn = () => true
-      ) {
-        const newTypeMap = {};
-        for (const typeName in originalTypeMap) {
-          if (!typeName.startsWith("__")) {
-            const originalType = originalTypeMap[typeName];
-            if (originalType == null || !testFn(originalType)) {
-              newTypeMap[typeName] = originalType;
-              continue;
-            }
-            const typeMapper = getTypeMapper(schema, schemaMapper, typeName);
-            if (typeMapper == null) {
-              newTypeMap[typeName] = originalType;
-              continue;
-            }
-            const maybeNewType = typeMapper(originalType, schema);
-            if (maybeNewType === void 0) {
-              newTypeMap[typeName] = originalType;
-              continue;
-            }
-            newTypeMap[typeName] = maybeNewType;
-          }
-        }
-        return newTypeMap;
-      }
-      function mapEnumValues(originalTypeMap, schema, schemaMapper) {
-        const enumValueMapper = getEnumValueMapper(schemaMapper);
-        if (!enumValueMapper) {
-          return originalTypeMap;
-        }
-        return mapTypes(
-          originalTypeMap,
-          schema,
-          {
-            [MapperKind.ENUM_TYPE]: (type2) => {
-              const config2 = type2.toConfig();
-              const originalEnumValueConfigMap = config2.values;
-              const newEnumValueConfigMap = {};
-              for (const externalValue in originalEnumValueConfigMap) {
-                const originalEnumValueConfig =
-                  originalEnumValueConfigMap[externalValue];
-                const mappedEnumValue = enumValueMapper(
-                  originalEnumValueConfig,
-                  type2.name,
-                  schema,
-                  externalValue
-                );
-                if (mappedEnumValue === void 0) {
-                  newEnumValueConfigMap[externalValue] =
-                    originalEnumValueConfig;
-                } else if (Array.isArray(mappedEnumValue)) {
-                  const [newExternalValue, newEnumValueConfig] =
-                    mappedEnumValue;
-                  newEnumValueConfigMap[newExternalValue] =
-                    newEnumValueConfig === void 0
-                      ? originalEnumValueConfig
-                      : newEnumValueConfig;
-                } else if (mappedEnumValue !== null) {
-                  newEnumValueConfigMap[externalValue] = mappedEnumValue;
-                }
-              }
-              return correctASTNodes(
-                new GraphQLEnumType(
-                  __spreadProps(__spreadValues({}, config2), {
-                    values: newEnumValueConfigMap,
-                  })
-                )
-              );
-            },
-          },
-          (type2) => isEnumType(type2)
-        );
-      }
-      function mapDefaultValues(originalTypeMap, schema, fn) {
-        const newTypeMap = mapArguments(originalTypeMap, schema, {
-          [MapperKind.ARGUMENT]: (argumentConfig) => {
-            if (argumentConfig.defaultValue === void 0) {
-              return argumentConfig;
-            }
-            const maybeNewType = getNewType(
-              originalTypeMap,
-              argumentConfig.type
-            );
-            if (maybeNewType != null) {
-              return __spreadProps(__spreadValues({}, argumentConfig), {
-                defaultValue: fn(maybeNewType, argumentConfig.defaultValue),
-              });
-            }
-          },
-        });
-        return mapFields(newTypeMap, schema, {
-          [MapperKind.INPUT_OBJECT_FIELD]: (inputFieldConfig) => {
-            if (inputFieldConfig.defaultValue === void 0) {
-              return inputFieldConfig;
-            }
-            const maybeNewType = getNewType(newTypeMap, inputFieldConfig.type);
-            if (maybeNewType != null) {
-              return __spreadProps(__spreadValues({}, inputFieldConfig), {
-                defaultValue: fn(maybeNewType, inputFieldConfig.defaultValue),
-              });
-            }
-          },
-        });
-      }
-      function getNewType(newTypeMap, type2) {
-        if (isListType(type2)) {
-          const newType = getNewType(newTypeMap, type2.ofType);
-          return newType != null ? new GraphQLList(newType) : null;
-        } else if (isNonNullType(type2)) {
-          const newType = getNewType(newTypeMap, type2.ofType);
-          return newType != null ? new GraphQLNonNull(newType) : null;
-        } else if (isNamedType(type2)) {
-          const newType = newTypeMap[type2.name];
-          return newType != null ? newType : null;
-        }
-        return null;
-      }
-      function mapFields(originalTypeMap, schema, schemaMapper) {
-        const newTypeMap = {};
-        for (const typeName in originalTypeMap) {
-          if (!typeName.startsWith("__")) {
-            const originalType = originalTypeMap[typeName];
-            if (
-              !isObjectType(originalType) &&
-              !isInterfaceType(originalType) &&
-              !isInputObjectType(originalType)
-            ) {
-              newTypeMap[typeName] = originalType;
-              continue;
-            }
-            const fieldMapper = getFieldMapper(schema, schemaMapper, typeName);
-            if (fieldMapper == null) {
-              newTypeMap[typeName] = originalType;
-              continue;
-            }
-            const config2 = originalType.toConfig();
-            const originalFieldConfigMap = config2.fields;
-            const newFieldConfigMap = {};
-            for (const fieldName in originalFieldConfigMap) {
-              const originalFieldConfig = originalFieldConfigMap[fieldName];
-              const mappedField = fieldMapper(
-                originalFieldConfig,
-                fieldName,
-                typeName,
-                schema
-              );
-              if (mappedField === void 0) {
-                newFieldConfigMap[fieldName] = originalFieldConfig;
-              } else if (Array.isArray(mappedField)) {
-                const [newFieldName, newFieldConfig] = mappedField;
-                if (newFieldConfig.astNode != null) {
-                  newFieldConfig.astNode = __spreadProps(
-                    __spreadValues({}, newFieldConfig.astNode),
-                    {
-                      name: __spreadProps(
-                        __spreadValues({}, newFieldConfig.astNode.name),
-                        {
-                          value: newFieldName,
-                        }
-                      ),
-                    }
-                  );
-                }
-                newFieldConfigMap[newFieldName] =
-                  newFieldConfig === void 0
-                    ? originalFieldConfig
-                    : newFieldConfig;
-              } else if (mappedField !== null) {
-                newFieldConfigMap[fieldName] = mappedField;
-              }
-            }
-            if (isObjectType(originalType)) {
-              newTypeMap[typeName] = correctASTNodes(
-                new GraphQLObjectType(
-                  __spreadProps(__spreadValues({}, config2), {
-                    fields: newFieldConfigMap,
-                  })
-                )
-              );
-            } else if (isInterfaceType(originalType)) {
-              newTypeMap[typeName] = correctASTNodes(
-                new GraphQLInterfaceType(
-                  __spreadProps(__spreadValues({}, config2), {
-                    fields: newFieldConfigMap,
-                  })
-                )
-              );
-            } else {
-              newTypeMap[typeName] = correctASTNodes(
-                new GraphQLInputObjectType(
-                  __spreadProps(__spreadValues({}, config2), {
-                    fields: newFieldConfigMap,
-                  })
-                )
-              );
-            }
-          }
-        }
-        return newTypeMap;
-      }
-      function mapArguments(originalTypeMap, schema, schemaMapper) {
-        const newTypeMap = {};
-        for (const typeName in originalTypeMap) {
-          if (!typeName.startsWith("__")) {
-            const originalType = originalTypeMap[typeName];
-            if (!isObjectType(originalType) && !isInterfaceType(originalType)) {
-              newTypeMap[typeName] = originalType;
-              continue;
-            }
-            const argumentMapper = getArgumentMapper(schemaMapper);
-            if (argumentMapper == null) {
-              newTypeMap[typeName] = originalType;
-              continue;
-            }
-            const config2 = originalType.toConfig();
-            const originalFieldConfigMap = config2.fields;
-            const newFieldConfigMap = {};
-            for (const fieldName in originalFieldConfigMap) {
-              const originalFieldConfig = originalFieldConfigMap[fieldName];
-              const originalArgumentConfigMap = originalFieldConfig.args;
-              if (originalArgumentConfigMap == null) {
-                newFieldConfigMap[fieldName] = originalFieldConfig;
-                continue;
-              }
-              const argumentNames = Object.keys(originalArgumentConfigMap);
-              if (!argumentNames.length) {
-                newFieldConfigMap[fieldName] = originalFieldConfig;
-                continue;
-              }
-              const newArgumentConfigMap = {};
-              for (const argumentName of argumentNames) {
-                const originalArgumentConfig =
-                  originalArgumentConfigMap[argumentName];
-                const mappedArgument = argumentMapper(
-                  originalArgumentConfig,
-                  fieldName,
-                  typeName,
-                  schema
-                );
-                if (mappedArgument === void 0) {
-                  newArgumentConfigMap[argumentName] = originalArgumentConfig;
-                } else if (Array.isArray(mappedArgument)) {
-                  const [newArgumentName, newArgumentConfig] = mappedArgument;
-                  newArgumentConfigMap[newArgumentName] = newArgumentConfig;
-                } else if (mappedArgument !== null) {
-                  newArgumentConfigMap[argumentName] = mappedArgument;
-                }
-              }
-              newFieldConfigMap[fieldName] = __spreadProps(
-                __spreadValues({}, originalFieldConfig),
-                {
-                  args: newArgumentConfigMap,
-                }
-              );
-            }
-            if (isObjectType(originalType)) {
-              newTypeMap[typeName] = new GraphQLObjectType(
-                __spreadProps(__spreadValues({}, config2), {
-                  fields: newFieldConfigMap,
-                })
-              );
-            } else if (isInterfaceType(originalType)) {
-              newTypeMap[typeName] = new GraphQLInterfaceType(
-                __spreadProps(__spreadValues({}, config2), {
-                  fields: newFieldConfigMap,
-                })
-              );
-            } else {
-              newTypeMap[typeName] = new GraphQLInputObjectType(
-                __spreadProps(__spreadValues({}, config2), {
-                  fields: newFieldConfigMap,
-                })
-              );
-            }
-          }
-        }
-        return newTypeMap;
-      }
-      function mapDirectives(originalDirectives, schema, schemaMapper) {
-        const directiveMapper = getDirectiveMapper(schemaMapper);
-        if (directiveMapper == null) {
-          return originalDirectives.slice();
-        }
-        const newDirectives = [];
-        for (const directive of originalDirectives) {
-          const mappedDirective = directiveMapper(directive, schema);
-          if (mappedDirective === void 0) {
-            newDirectives.push(directive);
-          } else if (mappedDirective !== null) {
-            newDirectives.push(mappedDirective);
-          }
-        }
-        return newDirectives;
-      }
-      function getTypeSpecifiers(schema, typeName) {
-        var _a2, _b, _c;
-        const type2 = schema.getType(typeName);
-        const specifiers = [MapperKind.TYPE];
-        if (isObjectType(type2)) {
-          specifiers.push(MapperKind.COMPOSITE_TYPE, MapperKind.OBJECT_TYPE);
-          if (
-            typeName ===
-            ((_a2 = schema.getQueryType()) === null || _a2 === void 0
-              ? void 0
-              : _a2.name)
-          ) {
-            specifiers.push(MapperKind.ROOT_OBJECT, MapperKind.QUERY);
-          } else if (
-            typeName ===
-            ((_b = schema.getMutationType()) === null || _b === void 0
-              ? void 0
-              : _b.name)
-          ) {
-            specifiers.push(MapperKind.ROOT_OBJECT, MapperKind.MUTATION);
-          } else if (
-            typeName ===
-            ((_c = schema.getSubscriptionType()) === null || _c === void 0
-              ? void 0
-              : _c.name)
-          ) {
-            specifiers.push(MapperKind.ROOT_OBJECT, MapperKind.SUBSCRIPTION);
-          }
-        } else if (isInputObjectType(type2)) {
-          specifiers.push(MapperKind.INPUT_OBJECT_TYPE);
-        } else if (isInterfaceType(type2)) {
-          specifiers.push(
-            MapperKind.COMPOSITE_TYPE,
-            MapperKind.ABSTRACT_TYPE,
-            MapperKind.INTERFACE_TYPE
-          );
-        } else if (isUnionType(type2)) {
-          specifiers.push(
-            MapperKind.COMPOSITE_TYPE,
-            MapperKind.ABSTRACT_TYPE,
-            MapperKind.UNION_TYPE
-          );
-        } else if (isEnumType(type2)) {
-          specifiers.push(MapperKind.ENUM_TYPE);
-        } else if (isScalarType(type2)) {
-          specifiers.push(MapperKind.SCALAR_TYPE);
-        }
-        return specifiers;
-      }
-      function getTypeMapper(schema, schemaMapper, typeName) {
-        const specifiers = getTypeSpecifiers(schema, typeName);
-        let typeMapper;
-        const stack = [...specifiers];
-        while (!typeMapper && stack.length > 0) {
-          const next = stack.pop();
-          typeMapper = schemaMapper[next];
-        }
-        return typeMapper != null ? typeMapper : null;
-      }
-      function getFieldSpecifiers(schema, typeName) {
-        var _a2, _b, _c;
-        const type2 = schema.getType(typeName);
-        const specifiers = [MapperKind.FIELD];
-        if (isObjectType(type2)) {
-          specifiers.push(MapperKind.COMPOSITE_FIELD, MapperKind.OBJECT_FIELD);
-          if (
-            typeName ===
-            ((_a2 = schema.getQueryType()) === null || _a2 === void 0
-              ? void 0
-              : _a2.name)
-          ) {
-            specifiers.push(MapperKind.ROOT_FIELD, MapperKind.QUERY_ROOT_FIELD);
-          } else if (
-            typeName ===
-            ((_b = schema.getMutationType()) === null || _b === void 0
-              ? void 0
-              : _b.name)
-          ) {
-            specifiers.push(
-              MapperKind.ROOT_FIELD,
-              MapperKind.MUTATION_ROOT_FIELD
-            );
-          } else if (
-            typeName ===
-            ((_c = schema.getSubscriptionType()) === null || _c === void 0
-              ? void 0
-              : _c.name)
-          ) {
-            specifiers.push(
-              MapperKind.ROOT_FIELD,
-              MapperKind.SUBSCRIPTION_ROOT_FIELD
-            );
-          }
-        } else if (isInterfaceType(type2)) {
-          specifiers.push(
-            MapperKind.COMPOSITE_FIELD,
-            MapperKind.INTERFACE_FIELD
-          );
-        } else if (isInputObjectType(type2)) {
-          specifiers.push(MapperKind.INPUT_OBJECT_FIELD);
-        }
-        return specifiers;
-      }
-      function getFieldMapper(schema, schemaMapper, typeName) {
-        const specifiers = getFieldSpecifiers(schema, typeName);
-        let fieldMapper;
-        const stack = [...specifiers];
-        while (!fieldMapper && stack.length > 0) {
-          const next = stack.pop();
-          fieldMapper = schemaMapper[next];
-        }
-        return fieldMapper !== null && fieldMapper !== void 0
-          ? fieldMapper
-          : null;
-      }
-      function getArgumentMapper(schemaMapper) {
-        const argumentMapper = schemaMapper[MapperKind.ARGUMENT];
-        return argumentMapper != null ? argumentMapper : null;
-      }
-      function getDirectiveMapper(schemaMapper) {
-        const directiveMapper = schemaMapper[MapperKind.DIRECTIVE];
-        return directiveMapper != null ? directiveMapper : null;
-      }
-      function getEnumValueMapper(schemaMapper) {
-        const enumValueMapper = schemaMapper[MapperKind.ENUM_VALUE];
-        return enumValueMapper != null ? enumValueMapper : null;
-      }
-      function correctASTNodes(type2) {
-        if (isObjectType(type2)) {
-          const config2 = type2.toConfig();
-          if (config2.astNode != null) {
-            const fields = [];
-            for (const fieldName in config2.fields) {
-              const fieldConfig = config2.fields[fieldName];
-              if (fieldConfig.astNode != null) {
-                fields.push(fieldConfig.astNode);
-              }
-            }
-            config2.astNode = __spreadProps(
-              __spreadValues({}, config2.astNode),
-              {
-                kind: Kind.OBJECT_TYPE_DEFINITION,
-                fields,
-              }
-            );
-          }
-          if (config2.extensionASTNodes != null) {
-            config2.extensionASTNodes = config2.extensionASTNodes.map((node) =>
-              __spreadProps(__spreadValues({}, node), {
-                kind: Kind.OBJECT_TYPE_EXTENSION,
-                fields: void 0,
-              })
-            );
-          }
-          return new GraphQLObjectType(config2);
-        } else if (isInterfaceType(type2)) {
-          const config2 = type2.toConfig();
-          if (config2.astNode != null) {
-            const fields = [];
-            for (const fieldName in config2.fields) {
-              const fieldConfig = config2.fields[fieldName];
-              if (fieldConfig.astNode != null) {
-                fields.push(fieldConfig.astNode);
-              }
-            }
-            config2.astNode = __spreadProps(
-              __spreadValues({}, config2.astNode),
-              {
-                kind: Kind.INTERFACE_TYPE_DEFINITION,
-                fields,
-              }
-            );
-          }
-          if (config2.extensionASTNodes != null) {
-            config2.extensionASTNodes = config2.extensionASTNodes.map((node) =>
-              __spreadProps(__spreadValues({}, node), {
-                kind: Kind.INTERFACE_TYPE_EXTENSION,
-                fields: void 0,
-              })
-            );
-          }
-          return new GraphQLInterfaceType(config2);
-        } else if (isInputObjectType(type2)) {
-          const config2 = type2.toConfig();
-          if (config2.astNode != null) {
-            const fields = [];
-            for (const fieldName in config2.fields) {
-              const fieldConfig = config2.fields[fieldName];
-              if (fieldConfig.astNode != null) {
-                fields.push(fieldConfig.astNode);
-              }
-            }
-            config2.astNode = __spreadProps(
-              __spreadValues({}, config2.astNode),
-              {
-                kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,
-                fields,
-              }
-            );
-          }
-          if (config2.extensionASTNodes != null) {
-            config2.extensionASTNodes = config2.extensionASTNodes.map((node) =>
-              __spreadProps(__spreadValues({}, node), {
-                kind: Kind.INPUT_OBJECT_TYPE_EXTENSION,
-                fields: void 0,
-              })
-            );
-          }
-          return new GraphQLInputObjectType(config2);
-        } else if (isEnumType(type2)) {
-          const config2 = type2.toConfig();
-          if (config2.astNode != null) {
-            const values = [];
-            for (const enumKey in config2.values) {
-              const enumValueConfig = config2.values[enumKey];
-              if (enumValueConfig.astNode != null) {
-                values.push(enumValueConfig.astNode);
-              }
-            }
-            config2.astNode = __spreadProps(
-              __spreadValues({}, config2.astNode),
-              {
-                values,
-              }
-            );
-          }
-          if (config2.extensionASTNodes != null) {
-            config2.extensionASTNodes = config2.extensionASTNodes.map((node) =>
-              __spreadProps(__spreadValues({}, node), {
-                values: void 0,
-              })
-            );
-          }
-          return new GraphQLEnumType(config2);
-        } else {
-          return type2;
-        }
-      }
-      function getResponseKeyFromInfo(info2) {
-        return info2.fieldNodes[0].alias != null
-          ? info2.fieldNodes[0].alias.value
-          : info2.fieldName;
-      }
-      function mapAsyncIterator(iterator, callback, rejectCallback) {
-        let $return;
-        let abruptClose;
-        if (typeof iterator.return === "function") {
-          $return = iterator.return;
-          abruptClose = (error2) => {
-            const rethrow = () => Promise.reject(error2);
-            return $return.call(iterator).then(rethrow, rethrow);
-          };
-        }
-        function mapResult(result2) {
-          return result2.done
-            ? result2
-            : asyncMapValue(result2.value, callback).then(
-                iteratorResult,
-                abruptClose
-              );
-        }
-        let mapReject;
-        if (rejectCallback) {
-          const reject2 = rejectCallback;
-          mapReject = (error2) =>
-            asyncMapValue(error2, reject2).then(iteratorResult, abruptClose);
-        }
-        return {
-          next() {
-            return iterator.next().then(mapResult, mapReject);
-          },
-          return() {
-            return $return
-              ? $return.call(iterator).then(mapResult, mapReject)
-              : Promise.resolve({ value: void 0, done: true });
-          },
-          throw(error2) {
-            if (typeof iterator.throw === "function") {
-              return iterator.throw(error2).then(mapResult, mapReject);
-            }
-            return Promise.reject(error2).catch(abruptClose);
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          },
-        };
-      }
-      function asyncMapValue(value, callback) {
-        return new Promise((resolve) => resolve(callback(value)));
-      }
-      function iteratorResult(value) {
-        return { value, done: false };
-      }
-      function updateArgument(
-        argumentNodes,
-        variableDefinitionsMap,
-        variableValues,
-        argName,
-        varName,
-        type2,
-        value
-      ) {
-        argumentNodes[argName] = {
-          kind: Kind.ARGUMENT,
-          name: {
-            kind: Kind.NAME,
-            value: argName,
-          },
-          value: {
-            kind: Kind.VARIABLE,
-            name: {
-              kind: Kind.NAME,
-              value: varName,
-            },
-          },
-        };
-        variableDefinitionsMap[varName] = {
-          kind: Kind.VARIABLE_DEFINITION,
-          variable: {
-            kind: Kind.VARIABLE,
-            name: {
-              kind: Kind.NAME,
-              value: varName,
-            },
-          },
-          type: astFromType(type2),
-        };
-        if (value !== void 0) {
-          variableValues[varName] = value;
-          return;
-        }
-        if (varName in variableValues) {
-          delete variableValues[varName];
-        }
-      }
-      function createVariableNameGenerator(variableDefinitionMap) {
-        let varCounter = 0;
-        return (argName) => {
-          let varName;
-          do {
-            varName = `_v${(varCounter++).toString()}_${argName}`;
-          } while (varName in variableDefinitionMap);
-          return varName;
-        };
-      }
-      function implementsAbstractType(schema, typeA, typeB) {
-        if (typeB == null || typeA == null) {
-          return false;
-        } else if (typeA === typeB) {
-          return true;
-        } else if (isCompositeType(typeA) && isCompositeType(typeB)) {
-          return doTypesOverlap(schema, typeA, typeB);
-        }
-        return false;
-      }
-      function relocatedError(originalError, path) {
-        return new GraphQLError(
-          originalError.message,
-          originalError.nodes,
-          originalError.source,
-          originalError.positions,
-          path === null ? void 0 : path === void 0 ? originalError.path : path,
-          originalError.originalError,
-          originalError.extensions
-        );
-      }
-      function observableToAsyncIterable(observable) {
-        const pullQueue = [];
-        const pushQueue = [];
-        let listening = true;
-        const pushValue = (value) => {
-          if (pullQueue.length !== 0) {
-            pullQueue.shift()({ value, done: false });
-          } else {
-            pushQueue.push({ value, done: false });
-          }
-        };
-        const pushError = (error2) => {
-          if (pullQueue.length !== 0) {
-            pullQueue.shift()({ value: { errors: [error2] }, done: false });
-          } else {
-            pushQueue.push({ value: { errors: [error2] }, done: false });
-          }
-        };
-        const pushDone = () => {
-          if (pullQueue.length !== 0) {
-            pullQueue.shift()({ done: true });
-          } else {
-            pushQueue.push({ done: true });
-          }
-        };
-        const pullValue = () =>
-          new Promise((resolve) => {
-            if (pushQueue.length !== 0) {
-              const element = pushQueue.shift();
-              resolve(element);
-            } else {
-              pullQueue.push(resolve);
-            }
-          });
-        const subscription = observable.subscribe({
-          next(value) {
-            pushValue(value);
-          },
-          error(err) {
-            pushError(err);
-          },
-          complete() {
-            pushDone();
-          },
-        });
-        const emptyQueue = () => {
-          if (listening) {
-            listening = false;
-            subscription.unsubscribe();
-            for (const resolve of pullQueue) {
-              resolve({ value: void 0, done: true });
-            }
-            pullQueue.length = 0;
-            pushQueue.length = 0;
-          }
-        };
-        return {
-          next() {
-            return listening ? pullValue() : this.return();
-          },
-          return() {
-            emptyQueue();
-            return Promise.resolve({ value: void 0, done: true });
-          },
-          throw(error2) {
-            emptyQueue();
-            return Promise.reject(error2);
-          },
-          [Symbol.asyncIterator]() {
-            return this;
-          },
-        };
-      }
-      function getOperationASTFromDocument(documentNode, operationName) {
-        const doc = getOperationAST(documentNode, operationName);
-        if (!doc) {
-          throw new Error(`Cannot infer operation ${operationName || ""}`);
-        }
-        return doc;
-      }
-      const getOperationASTFromRequest = memoize1$1(
-        function getOperationASTFromRequest2(request) {
-          return getOperationASTFromDocument(
-            request.document,
-            request.operationName
-          );
-        }
-      );
-      function collectFields(
-        schema,
-        fragments,
-        variableValues,
-        runtimeType,
-        selectionSet,
-        fields,
-        visitedFragmentNames
-      ) {
-        for (const selection of selectionSet.selections) {
-          switch (selection.kind) {
-            case Kind.FIELD: {
-              if (!shouldIncludeNode(variableValues, selection)) {
-                continue;
-              }
-              const name2 = getFieldEntryKey(selection);
-              const fieldList = fields.get(name2);
-              if (fieldList !== void 0) {
-                fieldList.push(selection);
-              } else {
-                fields.set(name2, [selection]);
-              }
-              break;
-            }
-            case Kind.INLINE_FRAGMENT: {
-              if (
-                !shouldIncludeNode(variableValues, selection) ||
-                !doesFragmentConditionMatch(schema, selection, runtimeType)
-              ) {
-                continue;
-              }
-              collectFields(
-                schema,
-                fragments,
-                variableValues,
-                runtimeType,
-                selection.selectionSet,
-                fields,
-                visitedFragmentNames
-              );
-              break;
-            }
-            case Kind.FRAGMENT_SPREAD: {
-              const fragName = selection.name.value;
-              if (
-                visitedFragmentNames.has(fragName) ||
-                !shouldIncludeNode(variableValues, selection)
-              ) {
-                continue;
-              }
-              visitedFragmentNames.add(fragName);
-              const fragment = fragments[fragName];
-              if (
-                !fragment ||
-                !doesFragmentConditionMatch(schema, fragment, runtimeType)
-              ) {
-                continue;
-              }
-              collectFields(
-                schema,
-                fragments,
-                variableValues,
-                runtimeType,
-                fragment.selectionSet,
-                fields,
-                visitedFragmentNames
-              );
-              break;
-            }
-          }
-        }
-        return fields;
-      }
-      function shouldIncludeNode(variableValues, node) {
-        const skip2 = getDirectiveValues$1(
-          GraphQLSkipDirective,
-          node,
-          variableValues
-        );
-        if (
-          (skip2 === null || skip2 === void 0 ? void 0 : skip2["if"]) === true
-        ) {
-          return false;
-        }
-        const include = getDirectiveValues$1(
-          GraphQLIncludeDirective,
-          node,
-          variableValues
-        );
-        if (
-          (include === null || include === void 0 ? void 0 : include["if"]) ===
-          false
-        ) {
-          return false;
-        }
-        return true;
-      }
-      function doesFragmentConditionMatch(schema, fragment, type2) {
-        const typeConditionNode = fragment.typeCondition;
-        if (!typeConditionNode) {
-          return true;
-        }
-        const conditionalType = typeFromAST(schema, typeConditionNode);
-        if (conditionalType === type2) {
-          return true;
-        }
-        if (isAbstractType(conditionalType)) {
-          const possibleTypes = schema.getPossibleTypes(conditionalType);
-          return possibleTypes.includes(type2);
-        }
-        return false;
-      }
-      function getFieldEntryKey(node) {
-        return node.alias ? node.alias.value : node.name.value;
-      }
-      function isAsyncIterable$1(value) {
-        return (
-          typeof value === "object" &&
-          value != null &&
-          Symbol.asyncIterator in value &&
-          typeof value[Symbol.asyncIterator] === "function"
-        );
-      }
-      async function defaultAsyncIteratorReturn(value) {
-        return { value, done: true };
-      }
-      const proxyMethodFactory = memoize2$1(function proxyMethodFactory2(
-        target2,
-        targetMethod
-      ) {
-        return function proxyMethod(...args) {
-          return Reflect.apply(targetMethod, target2, args);
-        };
-      });
-      function getAsyncIteratorWithCancel(asyncIterator, onCancel) {
-        return new Proxy(asyncIterator, {
-          has(asyncIterator2, prop2) {
-            if (prop2 === "return") {
-              return true;
-            }
-            return Reflect.has(asyncIterator2, prop2);
-          },
-          get(asyncIterator2, prop2, receiver) {
-            const existingPropValue = Reflect.get(
-              asyncIterator2,
-              prop2,
-              receiver
-            );
-            if (prop2 === "return") {
-              const existingReturn =
-                existingPropValue || defaultAsyncIteratorReturn;
-              return async function returnWithCancel(value) {
-                const returnValue = await onCancel(value);
-                return Reflect.apply(existingReturn, asyncIterator2, [
-                  returnValue,
-                ]);
-              };
-            } else if (typeof existingPropValue === "function") {
-              return proxyMethodFactory(asyncIterator2, existingPropValue);
-            }
-            return existingPropValue;
-          },
-        });
-      }
-      function getAsyncIterableWithCancel(asyncIterable, onCancel) {
-        return new Proxy(asyncIterable, {
-          get(asyncIterable2, prop2, receiver) {
-            const existingPropValue = Reflect.get(
-              asyncIterable2,
-              prop2,
-              receiver
-            );
-            if (Symbol.asyncIterator === prop2) {
-              return function asyncIteratorFactory() {
-                const asyncIterator = Reflect.apply(
-                  existingPropValue,
-                  asyncIterable2,
-                  []
-                );
-                return getAsyncIteratorWithCancel(asyncIterator, onCancel);
-              };
-            } else if (typeof existingPropValue === "function") {
-              return proxyMethodFactory(asyncIterable2, existingPropValue);
-            }
-            return existingPropValue;
-          },
-        });
-      }
-      const GraphQLDeferDirective = new GraphQLDirective({
-        name: "defer",
-        description:
-          "Directs the executor to defer this fragment when the `if` argument is true or undefined.",
-        locations: [
-          DirectiveLocation.FRAGMENT_SPREAD,
-          DirectiveLocation.INLINE_FRAGMENT,
-        ],
-        args: {
-          if: {
-            type: GraphQLBoolean,
-            description: "Deferred when true or undefined.",
-          },
-          label: {
-            type: GraphQLString,
-            description: "Unique name",
-          },
-        },
-      });
-      const GraphQLStreamDirective = new GraphQLDirective({
-        name: "stream",
-        description:
-          "Directs the executor to stream plural fields when the `if` argument is true or undefined.",
-        locations: [DirectiveLocation.FIELD],
-        args: {
-          if: {
-            type: GraphQLBoolean,
-            description: "Stream when true or undefined.",
-          },
-          label: {
-            type: GraphQLString,
-            description: "Unique name",
-          },
-          initialCount: {
-            defaultValue: 0,
-            type: GraphQLInt,
-            description: "Number of items to return immediately",
-          },
-          maxChunkSize: {
-            defaultValue: 1,
-            type: GraphQLInt,
-            description:
-              "Maximum number of items to return within each payload",
-          },
-          maxInterval: {
-            type: GraphQLInt,
-            description:
-              "Maximum time in ms to wait to collect items for each payload, will wait indefinitely if undefined",
-          },
-          inParallel: {
-            defaultValue: false,
-            type: GraphQLBoolean,
-            description: "Stream items non-sequentially on completion if true",
-          },
-        },
-      });
-      const MAX_ARRAY_LENGTH = 10;
-      const MAX_RECURSIVE_DEPTH = 2;
-      function inspect(value) {
-        return formatValue(value, []);
-      }
-      function formatValue(value, seenValues) {
-        switch (typeof value) {
-          case "string":
-            return JSON.stringify(value);
-          case "function":
-            return value.name ? `[function ${value.name}]` : "[function]";
-          case "object":
-            return formatObjectValue(value, seenValues);
-          default:
-            return String(value);
-        }
-      }
-      function formatObjectValue(value, previouslySeenValues) {
-        if (value === null) {
-          return "null";
-        }
-        if (previouslySeenValues.includes(value)) {
-          return "[Circular]";
-        }
-        const seenValues = [...previouslySeenValues, value];
-        if (isJSONable(value)) {
-          const jsonValue = value.toJSON();
-          if (jsonValue !== value) {
-            return typeof jsonValue === "string"
-              ? jsonValue
-              : formatValue(jsonValue, seenValues);
-          }
-        } else if (Array.isArray(value)) {
-          return formatArray(value, seenValues);
-        }
-        return formatObject(value, seenValues);
-      }
-      function isJSONable(value) {
-        return typeof value.toJSON === "function";
-      }
-      function formatObject(object, seenValues) {
-        const entries = Object.entries(object);
-        if (entries.length === 0) {
-          return "{}";
-        }
-        if (seenValues.length > MAX_RECURSIVE_DEPTH) {
-          return "[" + getObjectTag(object) + "]";
-        }
-        const properties = entries.map(
-          ([key, value]) => key + ": " + formatValue(value, seenValues)
-        );
-        return "{ " + properties.join(", ") + " }";
-      }
-      function formatArray(array, seenValues) {
-        if (array.length === 0) {
-          return "[]";
-        }
-        if (seenValues.length > MAX_RECURSIVE_DEPTH) {
-          return "[Array]";
-        }
-        const len = Math.min(MAX_ARRAY_LENGTH, array.length);
-        const remaining = array.length - len;
-        const items = [];
-        for (let i = 0; i < len; ++i) {
-          items.push(formatValue(array[i], seenValues));
-        }
-        if (remaining === 1) {
-          items.push("... 1 more item");
-        } else if (remaining > 1) {
-          items.push(`... ${remaining} more items`);
-        }
-        return "[" + items.join(", ") + "]";
-      }
-      function getObjectTag(object) {
-        const tag = Object.prototype.toString
-          .call(object)
-          .replace(/^\[object /, "")
-          .replace(/]$/, "");
-        if (tag === "Object" && typeof object.constructor === "function") {
-          const name2 = object.constructor.name;
-          if (typeof name2 === "string" && name2 !== "") {
-            return name2;
-          }
-        }
-        return tag;
-      }
-      function invariant(condition, message) {
-        const booleanCondition = Boolean(condition);
-        if (!booleanCondition) {
-          throw new Error(
-            message != null ? message : "Unexpected invariant triggered."
-          );
-        }
-      }
-      function memoize1(fn) {
-        let cache0;
-        return function memoized(a1) {
-          if (cache0 === void 0) {
-            cache0 = /* @__PURE__ */ new WeakMap();
-          }
-          let fnResult = cache0.get(a1);
-          if (fnResult === void 0) {
-            fnResult = fn(a1);
-            cache0.set(a1, fnResult);
-          }
-          return fnResult;
-        };
-      }
-      const __Schema = new GraphQLObjectType({
-        name: "__Schema",
-        description:
-          "A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations.",
-        fields: () => ({
-          description: {
-            type: GraphQLString,
-            resolve: (executorSchema) => executorSchema.description,
-          },
-          types: {
-            description: "A list of all types supported by this server.",
-            type: new GraphQLNonNull(
-              new GraphQLList(new GraphQLNonNull(__Type))
-            ),
-            resolve: (executorSchema) => executorSchema.getNamedTypes(),
-          },
-          queryType: {
-            description: "The type that query operations will be rooted at.",
-            type: new GraphQLNonNull(__Type),
-            resolve: (executorSchema) => executorSchema.getRootType("query"),
-          },
-          mutationType: {
-            description:
-              "If this server supports mutation, the type that mutation operations will be rooted at.",
-            type: __Type,
-            resolve: (executorSchema) => executorSchema.getRootType("mutation"),
-          },
-          subscriptionType: {
-            description:
-              "If this server support subscription, the type that subscription operations will be rooted at.",
-            type: __Type,
-            resolve: (executorSchema) =>
-              executorSchema.getRootType("subscription"),
-          },
-          directives: {
-            description: "A list of all directives supported by this server.",
-            type: new GraphQLNonNull(
-              new GraphQLList(new GraphQLNonNull(__Directive))
-            ),
-            resolve: (executorSchema) => executorSchema.getDirectives(),
-          },
-        }),
-      });
-      const __Directive = new GraphQLObjectType({
-        name: "__Directive",
-        description:
-          "A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.\n\nIn some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor.",
-        fields: () => ({
-          name: {
-            type: new GraphQLNonNull(GraphQLString),
-            resolve: (directive) => directive.name,
-          },
-          description: {
-            type: GraphQLString,
-            resolve: (directive) => directive.description,
-          },
-          isRepeatable: {
-            type: new GraphQLNonNull(GraphQLBoolean),
-            resolve: (directive) => directive.isRepeatable,
-          },
-          locations: {
-            type: new GraphQLNonNull(
-              new GraphQLList(new GraphQLNonNull(__DirectiveLocation))
-            ),
-            resolve: (directive) => directive.locations,
-          },
-          args: {
-            type: new GraphQLNonNull(
-              new GraphQLList(new GraphQLNonNull(__InputValue))
-            ),
-            args: {
-              includeDeprecated: {
-                type: GraphQLBoolean,
-                defaultValue: false,
-              },
-            },
-            resolve(field, { includeDeprecated }) {
-              return includeDeprecated
-                ? field.args
-                : field.args.filter((arg) => arg.deprecationReason == null);
-            },
-          },
-        }),
-      });
-      const __Type = new GraphQLObjectType({
-        name: "__Type",
-        description:
-          "The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum.\n\nDepending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name, description and optional `specifiedByURL`, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types.",
-        fields: () => ({
-          kind: {
-            type: new GraphQLNonNull(__TypeKind),
-            resolve(type2, _args, _context, { executorSchema }) {
-              if (executorSchema.isScalarType(type2)) {
-                return TypeKind.SCALAR;
-              }
-              if (executorSchema.isObjectType(type2)) {
-                return TypeKind.OBJECT;
-              }
-              if (executorSchema.isInterfaceType(type2)) {
-                return TypeKind.INTERFACE;
-              }
-              if (executorSchema.isUnionType(type2)) {
-                return TypeKind.UNION;
-              }
-              if (executorSchema.isEnumType(type2)) {
-                return TypeKind.ENUM;
-              }
-              if (executorSchema.isInputObjectType(type2)) {
-                return TypeKind.INPUT_OBJECT;
-              }
-              if (executorSchema.isListType(type2)) {
-                return TypeKind.LIST;
-              }
-              if (executorSchema.isNonNullType(type2)) {
-                return TypeKind.NON_NULL;
-              }
-              invariant(false, `Unexpected type: "${inspect(type2)}".`);
-            },
-          },
-          name: {
-            type: GraphQLString,
-            resolve: (type2) => ("name" in type2 ? type2.name : void 0),
-          },
-          description: {
-            type: GraphQLString,
-            resolve: (type2) =>
-              "description" in type2 ? type2.description : void 0,
-          },
-          specifiedByURL: {
-            type: GraphQLString,
-            resolve: (obj) =>
-              "specifiedByURL" in obj ? obj.specifiedByURL : void 0,
-          },
-          fields: {
-            type: new GraphQLList(new GraphQLNonNull(__Field)),
-            args: {
-              includeDeprecated: {
-                type: GraphQLBoolean,
-                defaultValue: false,
-              },
-            },
-            resolve(
-              type2,
-              { includeDeprecated },
-              _context,
-              { executorSchema }
-            ) {
-              if (
-                executorSchema.isObjectType(type2) ||
-                executorSchema.isInterfaceType(type2)
-              ) {
-                const fields = Object.values(type2.getFields());
-                return includeDeprecated
-                  ? fields
-                  : fields.filter((field) => field.deprecationReason == null);
-              }
-            },
-          },
-          interfaces: {
-            type: new GraphQLList(new GraphQLNonNull(__Type)),
-            resolve(type2) {
-              if ("getInterfaces" in type2) {
-                return type2.getInterfaces();
-              }
-            },
-          },
-          possibleTypes: {
-            type: new GraphQLList(new GraphQLNonNull(__Type)),
-            resolve(type2, _args, _context, { executorSchema }) {
-              if (executorSchema.isAbstractType(type2)) {
-                return executorSchema.getPossibleTypes(type2);
-              }
-            },
-          },
-          enumValues: {
-            type: new GraphQLList(new GraphQLNonNull(__EnumValue)),
-            args: {
-              includeDeprecated: {
-                type: GraphQLBoolean,
-                defaultValue: false,
-              },
-            },
-            resolve(
-              type2,
-              { includeDeprecated },
-              _context,
-              { executorSchema }
-            ) {
-              if (executorSchema.isEnumType(type2)) {
-                const values = type2.getValues();
-                return includeDeprecated
-                  ? values
-                  : values.filter((field) => field.deprecationReason == null);
-              }
-            },
-          },
-          inputFields: {
-            type: new GraphQLList(new GraphQLNonNull(__InputValue)),
-            args: {
-              includeDeprecated: {
-                type: GraphQLBoolean,
-                defaultValue: false,
-              },
-            },
-            resolve(
-              type2,
-              { includeDeprecated },
-              _context,
-              { executorSchema }
-            ) {
-              if (executorSchema.isInputObjectType(type2)) {
-                const values = Object.values(type2.getFields());
-                return includeDeprecated
-                  ? values
-                  : values.filter((field) => field.deprecationReason == null);
-              }
-            },
-          },
-          ofType: {
-            type: __Type,
-            resolve: (type2) => ("ofType" in type2 ? type2.ofType : void 0),
-          },
-        }),
-      });
-      const __Field = new GraphQLObjectType({
-        name: "__Field",
-        description:
-          "Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type.",
-        fields: () => ({
-          name: {
-            type: new GraphQLNonNull(GraphQLString),
-            resolve: (field) => field.name,
-          },
-          description: {
-            type: GraphQLString,
-            resolve: (field) => field.description,
-          },
-          args: {
-            type: new GraphQLNonNull(
-              new GraphQLList(new GraphQLNonNull(__InputValue))
-            ),
-            args: {
-              includeDeprecated: {
-                type: GraphQLBoolean,
-                defaultValue: false,
-              },
-            },
-            resolve(field, { includeDeprecated }) {
-              return includeDeprecated
-                ? field.args
-                : field.args.filter((arg) => arg.deprecationReason == null);
-            },
-          },
-          type: {
-            type: new GraphQLNonNull(__Type),
-            resolve: (field) => field.type,
-          },
-          isDeprecated: {
-            type: new GraphQLNonNull(GraphQLBoolean),
-            resolve: (field) => field.deprecationReason != null,
-          },
-          deprecationReason: {
-            type: GraphQLString,
-            resolve: (field) => field.deprecationReason,
-          },
-        }),
-      });
-      const __InputValue = new GraphQLObjectType({
-        name: "__InputValue",
-        description:
-          "Arguments provided to Fields or Directives and the input fields of an InputObject are represented as Input Values which describe their type and optionally a default value.",
-        fields: () => ({
-          name: {
-            type: new GraphQLNonNull(GraphQLString),
-            resolve: (inputValue) => inputValue.name,
-          },
-          description: {
-            type: GraphQLString,
-            resolve: (inputValue) => inputValue.description,
-          },
-          type: {
-            type: new GraphQLNonNull(__Type),
-            resolve: (inputValue) => inputValue.type,
-          },
-          defaultValue: {
-            type: GraphQLString,
-            description:
-              "A GraphQL-formatted string representing the default value for this input value.",
-            resolve(inputValue) {
-              const { type: type2, defaultValue: defaultValue2 } = inputValue;
-              const valueAST = astFromValue(defaultValue2, type2);
-              return valueAST ? print(valueAST) : null;
-            },
-          },
-          isDeprecated: {
-            type: new GraphQLNonNull(GraphQLBoolean),
-            resolve: (field) => field.deprecationReason != null,
-          },
-          deprecationReason: {
-            type: GraphQLString,
-            resolve: (obj) => obj.deprecationReason,
-          },
-        }),
-      });
-      const SchemaMetaFieldDef = {
-        name: "__schema",
-        type: new GraphQLNonNull(__Schema),
-        description: "Access the current type schema of this server.",
-        args: [],
-        resolve: (_source, _args, _context, { executorSchema }) =>
-          executorSchema,
-        isDeprecated: false,
-        deprecationReason: void 0,
-        extensions: /* @__PURE__ */ Object.create(null),
-        astNode: void 0,
-      };
-      const nameArgument = {
-        name: "name",
-        description: void 0,
-        type: new GraphQLNonNull(GraphQLString),
-        defaultValue: void 0,
-        deprecationReason: void 0,
-        extensions: /* @__PURE__ */ Object.create(null),
-        astNode: void 0,
-      };
-      const TypeMetaFieldDef = {
-        name: "__type",
-        type: __Type,
-        description: "Request the type information of a single type.",
-        args: [nameArgument],
-        resolve: (_source, { name: name2 }, _context, { executorSchema }) =>
-          executorSchema.getNamedType(name2),
-        isDeprecated: false,
-        deprecationReason: void 0,
-        extensions: /* @__PURE__ */ Object.create(null),
-        astNode: void 0,
-      };
-      const DirectiveMetaFieldDef = {
-        name: "__directive",
-        type: __Directive,
-        description: "Request the directive information of a single directive.",
-        args: [nameArgument],
-        resolve: (_source, { name: name2 }, _context, { executorSchema }) =>
-          executorSchema.getDirective(name2),
-        isDeprecated: false,
-        deprecationReason: void 0,
-        extensions: /* @__PURE__ */ Object.create(null),
-        astNode: void 0,
-      };
-      const introspectionTypes = Object.freeze([
-        __Schema,
-        __Directive,
-        __DirectiveLocation,
-        __Type,
-        __Field,
-        __InputValue,
-        __EnumValue,
-        __TypeKind,
-      ]);
-      function getInputTypeInfo(isListType2, isNonNullType2, type2, wrapper) {
-        if (!isListType2(type2) && !isNonNullType2(type2)) {
-          return {
-            nonNullListWrappers: [],
-            nonNull: isNonNullType2(wrapper),
-            namedType: type2,
-          };
-        }
-        const inputTypeInfo = getInputTypeInfo(
-          isListType2,
-          isNonNullType2,
-          type2.ofType,
-          type2
-        );
-        if (isNonNullType2(type2)) {
-          return inputTypeInfo;
-        }
-        inputTypeInfo.nonNullListWrappers.push(isNonNullType2(wrapper));
-        return inputTypeInfo;
-      }
-      function getPossibleSequences(nonNullListWrappers) {
-        if (!nonNullListWrappers.length) {
-          return [[]];
-        }
-        const nonNull = nonNullListWrappers.pop();
-        if (nonNull) {
-          return getPossibleSequences(nonNullListWrappers).map((sequence) => [
-            true,
-            ...sequence,
-          ]);
-        }
-        return [
-          ...getPossibleSequences(nonNullListWrappers).map((sequence) => [
-            true,
-            ...sequence,
-          ]),
-          ...getPossibleSequences(nonNullListWrappers).map((sequence) => [
-            false,
-            ...sequence,
-          ]),
-        ];
-      }
-      function inputTypesFromSequences(sequences, inputType) {
-        return sequences.map((sequence) =>
-          sequence.reduce((acc, nonNull) => {
-            let wrapped = new GraphQLList(acc);
-            if (nonNull) {
-              wrapped = new GraphQLNonNull(wrapped);
-            }
-            return wrapped;
-          }, inputType)
-        );
-      }
-      function getPossibleInputTypes(isListType2, isNonNullType2, type2) {
-        const nullableOuterType = isNonNullType2(type2) ? type2.ofType : type2;
-        const { nonNullListWrappers, nonNull, namedType } = getInputTypeInfo(
-          isListType2,
-          isNonNullType2,
-          nullableOuterType
-        );
-        const sequences = getPossibleSequences(nonNullListWrappers);
-        const wrapped = new GraphQLNonNull(namedType);
-        if (nonNull) {
-          return inputTypesFromSequences(sequences, wrapped);
-        }
-        return [
-          ...inputTypesFromSequences(sequences, namedType),
-          ...inputTypesFromSequences(sequences, wrapped),
-        ];
-      }
-      class TypeTree {
-        constructor(isListType2, isNonNullType2) {
-          this._isListType = isListType2;
-          this._isNonNullType = isNonNullType2;
-          this._rootNode = {
-            [Kind.NAMED_TYPE]: /* @__PURE__ */ new Map(),
-          };
-          this._typeStrings = /* @__PURE__ */ new Set();
-        }
-        add(type2) {
-          this._add(type2, this._rootNode);
-          this._typeStrings.add(type2.toString());
-        }
-        get(typeNode) {
-          return this._get(typeNode, this._rootNode);
-        }
-        has(typeString) {
-          return this._typeStrings.has(typeString);
-        }
-        _get(typeNode, node) {
-          switch (typeNode.kind) {
-            case Kind.LIST_TYPE: {
-              const listNode = node[Kind.LIST_TYPE];
-              if (!listNode) {
-                return;
-              }
-              return this._get(typeNode.type, listNode);
-            }
-            case Kind.NON_NULL_TYPE: {
-              const nonNullNode = node[Kind.NON_NULL_TYPE];
-              if (!nonNullNode) {
-                return;
-              }
-              return this._get(typeNode.type, nonNullNode);
-            }
-            case Kind.NAMED_TYPE:
-              return node[Kind.NAMED_TYPE].get(typeNode.name.value);
-          }
-        }
-        _add(originalType, node, type2 = originalType) {
-          if (this._isListType(type2)) {
-            let listTypeNode = node[Kind.LIST_TYPE];
-            if (!listTypeNode) {
-              listTypeNode = node[Kind.LIST_TYPE] = {
-                [Kind.NAMED_TYPE]: /* @__PURE__ */ new Map(),
-              };
-            }
-            this._add(originalType, listTypeNode, type2.ofType);
-          } else if (this._isNonNullType(type2)) {
-            let nonNullTypeNode = node[Kind.NON_NULL_TYPE];
-            if (!nonNullTypeNode) {
-              nonNullTypeNode = node[Kind.NON_NULL_TYPE] = {
-                [Kind.NAMED_TYPE]: /* @__PURE__ */ new Map(),
-              };
-            }
-            this._add(originalType, nonNullTypeNode, type2.ofType);
-          } else {
-            node[Kind.NAMED_TYPE].set(type2.name, originalType);
-          }
-        }
-      }
-      function is(x2, type2) {
-        if (Object.prototype.toString.call(x2) === `[object ${type2}]`) {
-          return true;
-        }
-        const prototype = Object.getPrototypeOf(x2);
-        if (prototype == null) {
-          return false;
-        }
-        return is(prototype, type2);
-      }
-      function _isScalarType(type2) {
-        return is(type2, "GraphQLScalarType");
-      }
-      function _isObjectType(type2) {
-        return is(type2, "GraphQLObjectType");
-      }
-      function _isInterfaceType(type2) {
-        return is(type2, "GraphQLInterfaceType");
-      }
-      function _isUnionType(type2) {
-        return is(type2, "GraphQLUnionType");
-      }
-      function _isEnumType(type2) {
-        return is(type2, "GraphQLEnumType");
-      }
-      function _isInputObjectType(type2) {
-        return is(type2, "GraphQLInputObjectType");
-      }
-      function _isListType(type2) {
-        return Object.prototype.toString.call(type2) === "[object GraphQLList]";
-      }
-      function _isNonNullType(type2) {
-        return (
-          Object.prototype.toString.call(type2) === "[object GraphQLNonNull]"
-        );
-      }
-      function _toExecutorSchema(schema) {
-        const listTypes = /* @__PURE__ */ new Set();
-        const nonNullTypes = /* @__PURE__ */ new Set();
-        const namedTypes = /* @__PURE__ */ new Map();
-        const inputTypes = /* @__PURE__ */ new Set();
-        const leafTypes = /* @__PURE__ */ new Set();
-        const scalarTypes = /* @__PURE__ */ new Set();
-        const enumTypes = /* @__PURE__ */ new Set();
-        const abstractTypes = /* @__PURE__ */ new Set();
-        const interfaceTypes = /* @__PURE__ */ new Set();
-        const unionTypes = /* @__PURE__ */ new Set();
-        const objectTypes = /* @__PURE__ */ new Set();
-        const inputObjectTypes = /* @__PURE__ */ new Set();
-        const typeTree = new TypeTree(_isListType, _isNonNullType);
-        const subTypesMap = /* @__PURE__ */ new Map();
-        const possibleTypesMap = /* @__PURE__ */ new Map();
-        function addOutputType(type2) {
-          typeTree.add(type2);
-        }
-        function addInputType(type2) {
-          inputTypes.add(type2);
-          typeTree.add(type2);
-        }
-        function processType(type2) {
-          if (_isListType(type2) && !listTypes.has(type2)) {
-            listTypes.add(type2);
-            processType(type2.ofType);
-          } else if (_isNonNullType(type2) && !nonNullTypes.has(type2)) {
-            nonNullTypes.add(type2);
-            processType(type2.ofType);
-          } else if (_isScalarType(type2) && !namedTypes.get(type2.name)) {
-            namedTypes.set(type2.name, type2);
-            leafTypes.add(type2);
-            scalarTypes.add(type2);
-          } else if (_isObjectType(type2) && !namedTypes.get(type2.name)) {
-            namedTypes.set(type2.name, type2);
-            objectTypes.add(type2);
-            addOutputType(type2);
-            for (const iface of Object.values(type2.getInterfaces())) {
-              processType(iface);
-              let subTypes = subTypesMap.get(iface);
-              if (!subTypes) {
-                subTypes = /* @__PURE__ */ new Set();
-                subTypesMap.set(iface, subTypes);
-              }
-              subTypes.add(type2);
-              let possibleTypes = possibleTypesMap.get(iface);
-              if (!possibleTypes) {
-                possibleTypes = [];
-                possibleTypesMap.set(iface, possibleTypes);
-              }
-              possibleTypes.push(type2);
-            }
-            for (const field of Object.values(type2.getFields())) {
-              processType(field.type);
-              for (const arg of field.args) {
-                addInputType(arg.type);
-                processType(arg.type);
-              }
-            }
-          } else if (_isInterfaceType(type2) && !namedTypes.get(type2.name)) {
-            namedTypes.set(type2.name, type2);
-            abstractTypes.add(type2);
-            interfaceTypes.add(type2);
-            addOutputType(type2);
-            if ("getInterfaces" in type2) {
-              for (const iface of Object.values(type2.getInterfaces())) {
-                processType(iface);
-                let subTypes = subTypesMap.get(iface);
-                if (!subTypes) {
-                  subTypes = /* @__PURE__ */ new Set();
-                  subTypesMap.set(iface, subTypes);
-                }
-                subTypes.add(type2);
-              }
-            }
-            for (const field of Object.values(type2.getFields())) {
-              processType(field.type);
-              for (const arg of field.args) {
-                addInputType(arg.type);
-                processType(arg.type);
-              }
-            }
-          } else if (_isUnionType(type2) && !namedTypes.get(type2.name)) {
-            namedTypes.set(type2.name, type2);
-            abstractTypes.add(type2);
-            unionTypes.add(type2);
-            addOutputType(type2);
-            let subTypes = subTypesMap.get(type2);
-            if (!subTypes) {
-              subTypes = /* @__PURE__ */ new Set();
-              subTypesMap.set(type2, subTypes);
-            }
-            let possibleTypes = possibleTypesMap.get(type2);
-            if (!possibleTypes) {
-              possibleTypes = [];
-              possibleTypesMap.set(type2, possibleTypes);
-            }
-            for (const possibleType of type2.getTypes()) {
-              processType(possibleType);
-              subTypes.add(possibleType);
-              possibleTypes.push(possibleType);
-            }
-          } else if (_isEnumType(type2) && !namedTypes.get(type2.name)) {
-            namedTypes.set(type2.name, type2);
-            leafTypes.add(type2);
-            enumTypes.add(type2);
-          } else if (_isInputObjectType(type2) && !namedTypes.get(type2.name)) {
-            namedTypes.set(type2.name, type2);
-            inputObjectTypes.add(type2);
-            for (const field of Object.values(type2.getFields())) {
-              addInputType(field.type);
-              processType(field.type);
-            }
-          }
-        }
-        for (const type2 of Object.values(schema.getTypeMap())) {
-          if (!type2.name.startsWith("__")) {
-            processType(type2);
-          }
-        }
-        for (const directive of schema.getDirectives()) {
-          for (const arg of directive.args) {
-            addInputType(arg.type);
-            processType(arg.type);
-          }
-        }
-        for (const inputType of inputTypes.values()) {
-          const possibleInputTypes = getPossibleInputTypes(
-            _isListType,
-            _isNonNullType,
-            inputType
-          );
-          for (const possibleInputType of possibleInputTypes) {
-            const typeString = possibleInputType.toString();
-            if (!typeTree.has(typeString)) {
-              addInputType(possibleInputType);
-              processType(possibleInputType);
-            }
-          }
-        }
-        for (const type2 of introspectionTypes) {
-          processType(type2);
-        }
-        for (const fieldDef of [
-          SchemaMetaFieldDef,
-          TypeMetaFieldDef,
-          TypeNameMetaFieldDef,
-        ]) {
-          processType(fieldDef.type);
-          for (const arg of fieldDef.args) {
-            addInputType(arg.type);
-            processType(arg.type);
-          }
-        }
-        const queryType = schema.getQueryType();
-        const mutationType = schema.getMutationType();
-        const subscriptionType = schema.getSubscriptionType();
-        function isListType2(type2) {
-          return listTypes.has(type2);
-        }
-        function isNonNullType2(type2) {
-          return nonNullTypes.has(type2);
-        }
-        function isNamedType2(type2) {
-          return namedTypes.get(type2.name) !== void 0;
-        }
-        function isInputType2(type2) {
-          return inputTypes.has(type2);
-        }
-        function isLeafType2(type2) {
-          return leafTypes.has(type2);
-        }
-        function isScalarType2(type2) {
-          return scalarTypes.has(type2);
-        }
-        function isEnumType2(type2) {
-          return enumTypes.has(type2);
-        }
-        function isAbstractType2(type2) {
-          return abstractTypes.has(type2);
-        }
-        function isInterfaceType2(type2) {
-          return interfaceTypes.has(type2);
-        }
-        function isUnionType2(type2) {
-          return unionTypes.has(type2);
-        }
-        function isObjectType2(type2) {
-          return objectTypes.has(type2);
-        }
-        function isInputObjectType2(type2) {
-          return inputObjectTypes.has(type2);
-        }
-        function getDirectives() {
-          return schema.getDirectives();
-        }
-        function getDirective(directiveName) {
-          var _schema$getDirective;
-          return (_schema$getDirective = schema.getDirective(directiveName)) !==
-            null && _schema$getDirective !== void 0
-            ? _schema$getDirective
-            : void 0;
-        }
-        function getNamedTypes() {
-          return Array.from(namedTypes.values());
-        }
-        function getNamedType2(typeName) {
-          return namedTypes.get(typeName);
-        }
-        function getType(typeNode) {
-          return typeTree.get(typeNode);
-        }
-        function getRootType(operation) {
-          if (operation === "query") {
-            return queryType !== null && queryType !== void 0
-              ? queryType
-              : void 0;
-          } else if (operation === "mutation") {
-            return mutationType !== null && mutationType !== void 0
-              ? mutationType
-              : void 0;
-          } else if (operation === "subscription") {
-            return subscriptionType !== null && subscriptionType !== void 0
-              ? subscriptionType
-              : void 0;
-          }
-          invariant(false, "Unexpected operation type: " + inspect(operation));
-        }
-        function getPossibleTypes(abstractType) {
-          var _possibleTypesMap$get;
-          return (_possibleTypesMap$get =
-            possibleTypesMap.get(abstractType)) !== null &&
-            _possibleTypesMap$get !== void 0
-            ? _possibleTypesMap$get
-            : [];
-        }
-        function isSubType(abstractType, maybeSubType) {
-          var _subTypesMap$get$has, _subTypesMap$get;
-          return (_subTypesMap$get$has =
-            (_subTypesMap$get = subTypesMap.get(abstractType)) === null ||
-            _subTypesMap$get === void 0
-              ? void 0
-              : _subTypesMap$get.has(maybeSubType)) !== null &&
-            _subTypesMap$get$has !== void 0
-            ? _subTypesMap$get$has
-            : false;
-        }
-        return {
-          description: schema.description,
-          isListType: isListType2,
-          isNonNullType: isNonNullType2,
-          isNamedType: isNamedType2,
-          isInputType: isInputType2,
-          isLeafType: isLeafType2,
-          isScalarType: isScalarType2,
-          isEnumType: isEnumType2,
-          isAbstractType: isAbstractType2,
-          isInterfaceType: isInterfaceType2,
-          isUnionType: isUnionType2,
-          isObjectType: isObjectType2,
-          isInputObjectType: isInputObjectType2,
-          getDirectives,
-          getDirective,
-          getNamedTypes,
-          getNamedType: getNamedType2,
-          getType,
-          getRootType,
-          getPossibleTypes,
-          isSubType,
-        };
-      }
-      const toExecutorSchema = memoize1(_toExecutorSchema);
-      function addPath(prev, key, typename) {
-        return {
-          prev,
-          key,
-          typename,
-        };
-      }
-      function pathToArray(path) {
-        const flattened = [];
-        let curr = path;
-        while (curr) {
-          flattened.push(curr.key);
-          curr = curr.prev;
-        }
-        return flattened.reverse();
-      }
-      function memoize1and1(fn) {
-        let cache0;
-        return function memoized(a1, a2) {
-          if (cache0 === void 0) {
-            cache0 = /* @__PURE__ */ new WeakMap();
-          }
-          let cache1 = cache0.get(a1);
-          if (cache1 === void 0) {
-            cache1 = /* @__PURE__ */ new Map();
-            cache0.set(a1, cache1);
-          }
-          let fnResult = cache1.get(a2);
-          if (fnResult === void 0) {
-            fnResult = fn(a1, a2);
-            cache1.set(a2, fnResult);
-          }
-          return fnResult;
-        };
-      }
-      function memoize2(fn) {
-        let cache0;
-        return function memoized(a1, a2) {
-          if (cache0 === void 0) {
-            cache0 = /* @__PURE__ */ new WeakMap();
-          }
-          let cache1 = cache0.get(a1);
-          if (cache1 === void 0) {
-            cache1 = /* @__PURE__ */ new WeakMap();
-            cache0.set(a1, cache1);
-          }
-          let fnResult = cache1.get(a2);
-          if (fnResult === void 0) {
-            fnResult = fn(a1, a2);
-            cache1.set(a2, fnResult);
-          }
-          return fnResult;
-        };
-      }
-      function devAssert(condition, message) {
-        const booleanCondition = Boolean(condition);
-        if (!booleanCondition) {
-          throw new Error(message);
-        }
-      }
-      function isPromise(value) {
-        return (
-          typeof (value === null || value === void 0 ? void 0 : value.then) ===
-          "function"
-        );
-      }
-      function isObjectLike(value) {
-        return typeof value == "object" && value !== null;
-      }
-      function promiseReduce(values, callbackFn, initialValue) {
-        let accumulator = initialValue;
-        for (const value of values) {
-          accumulator = isPromise(accumulator)
-            ? accumulator.then((resolved) => callbackFn(resolved, value))
-            : callbackFn(accumulator, value);
-        }
-        return accumulator;
-      }
-      function isAsyncIterable(maybeAsyncIterable) {
-        return (
-          typeof (maybeAsyncIterable === null || maybeAsyncIterable === void 0
-            ? void 0
-            : maybeAsyncIterable[Symbol.asyncIterator]) === "function"
-        );
-      }
-      function isIterableObject(maybeIterable) {
-        return (
-          typeof maybeIterable === "object" &&
-          typeof (maybeIterable === null || maybeIterable === void 0
-            ? void 0
-            : maybeIterable[Symbol.iterator]) === "function"
-        );
-      }
-      function resolveAfterAll(result2, promises) {
-        return new Promise((resolve, reject2) => {
-          let rejected = false;
-          let reason;
-          let numPromises = promises.length;
-          const onFulfilled = () => {
-            numPromises--;
-            if (!numPromises) {
-              if (rejected) {
-                reject2(reason);
-              }
-              resolve(result2);
-            }
-          };
-          const onRejected = (_reason) => {
-            if (!rejected) {
-              rejected = true;
-              reason = _reason;
-            }
-            numPromises--;
-            if (!numPromises) {
-              reject2(reason);
-            }
-          };
-          for (const promise of promises) {
-            promise.then(onFulfilled, onRejected);
-          }
-        });
-      }
-      function toError(thrownValue) {
-        return thrownValue instanceof Error
-          ? thrownValue
-          : new NonErrorThrown(thrownValue);
-      }
-      class NonErrorThrown extends Error {
-        constructor(thrownValue) {
-          super("Unexpected error value: " + inspect(thrownValue));
-          this.name = "NonErrorThrown";
-          this.thrownValue = thrownValue;
-        }
-      }
-      function keyMap(list3, keyFn) {
-        const result2 = /* @__PURE__ */ Object.create(null);
-        for (const item of list3) {
-          result2[keyFn(item)] = item;
-        }
-        return result2;
-      }
-      function printPathArray(path) {
-        return path
-          .map((key) =>
-            typeof key === "number" ? "[" + key.toString() + "]" : "." + key
-          )
-          .join("");
-      }
-      const MAX_SUGGESTIONS = 5;
-      function didYouMean(firstArg, secondArg) {
-        const [subMessage, suggestionsArg] = secondArg
-          ? [firstArg, secondArg]
-          : [void 0, firstArg];
-        let message = " Did you mean ";
-        if (subMessage) {
-          message += subMessage + " ";
-        }
-        const suggestions = suggestionsArg.map((x2) => `"${x2}"`);
-        switch (suggestions.length) {
-          case 0:
-            return "";
-          case 1:
-            return message + suggestions[0] + "?";
-          case 2:
-            return message + suggestions[0] + " or " + suggestions[1] + "?";
-        }
-        const selected = suggestions.slice(0, MAX_SUGGESTIONS);
-        const lastItem = selected.pop();
-        return message + selected.join(", ") + ", or " + lastItem + "?";
-      }
-      function naturalCompare(aStr, bStr) {
-        let aIndex = 0;
-        let bIndex = 0;
-        while (aIndex < aStr.length && bIndex < bStr.length) {
-          let aChar = aStr.charCodeAt(aIndex);
-          let bChar = bStr.charCodeAt(bIndex);
-          if (isDigit(aChar) && isDigit(bChar)) {
-            let aNum = 0;
-            do {
-              ++aIndex;
-              aNum = aNum * 10 + aChar - DIGIT_0;
-              aChar = aStr.charCodeAt(aIndex);
-            } while (isDigit(aChar) && aNum > 0);
-            let bNum = 0;
-            do {
-              ++bIndex;
-              bNum = bNum * 10 + bChar - DIGIT_0;
-              bChar = bStr.charCodeAt(bIndex);
-            } while (isDigit(bChar) && bNum > 0);
-            if (aNum < bNum) {
-              return -1;
-            }
-            if (aNum > bNum) {
-              return 1;
-            }
-          } else {
-            if (aChar < bChar) {
-              return -1;
-            }
-            if (aChar > bChar) {
-              return 1;
-            }
-            ++aIndex;
-            ++bIndex;
-          }
-        }
-        return aStr.length - bStr.length;
-      }
-      const DIGIT_0 = 48;
-      const DIGIT_9 = 57;
-      function isDigit(code3) {
-        return !isNaN(code3) && DIGIT_0 <= code3 && code3 <= DIGIT_9;
-      }
-      function suggestionList(input, options) {
-        const optionsByDistance = /* @__PURE__ */ Object.create(null);
-        const lexicalDistance2 = new LexicalDistance(input);
-        const threshold = Math.floor(input.length * 0.4) + 1;
-        for (const option of options) {
-          const distance = lexicalDistance2.measure(option, threshold);
-          if (distance !== void 0) {
-            optionsByDistance[option] = distance;
-          }
-        }
-        return Object.keys(optionsByDistance).sort((a, b) => {
-          const distanceDiff = optionsByDistance[a] - optionsByDistance[b];
-          return distanceDiff !== 0 ? distanceDiff : naturalCompare(a, b);
-        });
-      }
-      class LexicalDistance {
-        constructor(input) {
-          this._input = input;
-          this._inputLowerCase = input.toLowerCase();
-          this._inputArray = stringToArray(this._inputLowerCase);
-          this._rows = [
-            new Array(input.length + 1).fill(0),
-            new Array(input.length + 1).fill(0),
-            new Array(input.length + 1).fill(0),
-          ];
-        }
-        measure(option, threshold) {
-          if (this._input === option) {
-            return 0;
-          }
-          const optionLowerCase = option.toLowerCase();
-          if (this._inputLowerCase === optionLowerCase) {
-            return 1;
-          }
-          let a = stringToArray(optionLowerCase);
-          let b = this._inputArray;
-          if (a.length < b.length) {
-            const tmp = a;
-            a = b;
-            b = tmp;
-          }
-          const aLength = a.length;
-          const bLength = b.length;
-          if (aLength - bLength > threshold) {
-            return void 0;
-          }
-          const rows = this._rows;
-          for (let j = 0; j <= bLength; j++) {
-            rows[0][j] = j;
-          }
-          for (let i = 1; i <= aLength; i++) {
-            const upRow = rows[(i - 1) % 3];
-            const currentRow = rows[i % 3];
-            let smallestCell = (currentRow[0] = i);
-            for (let j = 1; j <= bLength; j++) {
-              const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-              let currentCell = Math.min(
-                upRow[j] + 1,
-                currentRow[j - 1] + 1,
-                upRow[j - 1] + cost
-              );
-              if (
-                i > 1 &&
-                j > 1 &&
-                a[i - 1] === b[j - 2] &&
-                a[i - 2] === b[j - 1]
-              ) {
-                const doubleDiagonalCell = rows[(i - 2) % 3][j - 2];
-                currentCell = Math.min(currentCell, doubleDiagonalCell + 1);
-              }
-              if (currentCell < smallestCell) {
-                smallestCell = currentCell;
-              }
-              currentRow[j] = currentCell;
-            }
-            if (smallestCell > threshold) {
-              return void 0;
-            }
-          }
-          const distance = rows[aLength % 3][bLength];
-          return distance <= threshold ? distance : void 0;
-        }
-      }
-      function stringToArray(str) {
-        const strLength = str.length;
-        const array = new Array(strLength);
-        for (let i = 0; i < strLength; ++i) {
-          array[i] = str.charCodeAt(i);
-        }
-        return array;
-      }
-      function isGraphQLError(error2) {
-        return error2.name === "GraphQLError";
-      }
-      function coerceInputValue(
-        executorSchema,
-        inputValue,
-        type2,
-        onError = defaultOnError
-      ) {
-        return coerceInputValueImpl(
-          executorSchema,
-          inputValue,
-          type2,
-          onError,
-          void 0
-        );
-      }
-      function defaultOnError(path, invalidValue, error2) {
-        let errorPrefix = "Invalid value " + inspect(invalidValue);
-        if (path.length > 0) {
-          errorPrefix += ` at "value${printPathArray(path)}"`;
-        }
-        error2.message = errorPrefix + ": " + error2.message;
-        throw error2;
-      }
-      function coerceInputValueImpl(
-        executorSchema,
-        inputValue,
-        type2,
-        onError,
-        path
-      ) {
-        if (executorSchema.isNonNullType(type2)) {
-          if (inputValue != null) {
-            return coerceInputValueImpl(
-              executorSchema,
-              inputValue,
-              type2.ofType,
-              onError,
-              path
-            );
-          }
-          onError(
-            pathToArray(path),
-            inputValue,
-            new GraphQLError(
-              `Expected non-nullable type "${inspect(type2)}" not to be null.`
-            )
-          );
-          return;
-        }
-        if (inputValue == null) {
-          return null;
-        }
-        if (executorSchema.isListType(type2)) {
-          const itemType = type2.ofType;
-          if (isIterableObject(inputValue)) {
-            return Array.from(inputValue, (itemValue, index) => {
-              const itemPath = addPath(path, index, void 0);
-              return coerceInputValueImpl(
-                executorSchema,
-                itemValue,
-                itemType,
-                onError,
-                itemPath
-              );
-            });
-          }
-          return [
-            coerceInputValueImpl(
-              executorSchema,
-              inputValue,
-              itemType,
-              onError,
-              path
-            ),
-          ];
-        }
-        if (executorSchema.isInputObjectType(type2)) {
-          if (!isObjectLike(inputValue)) {
-            onError(
-              pathToArray(path),
-              inputValue,
-              new GraphQLError(`Expected type "${type2.name}" to be an object.`)
-            );
-            return;
-          }
-          const coercedValue = {};
-          const fieldDefs = type2.getFields();
-          for (const field of Object.values(fieldDefs)) {
-            const fieldValue = inputValue[field.name];
-            if (fieldValue === void 0) {
-              if (field.defaultValue !== void 0) {
-                coercedValue[field.name] = field.defaultValue;
-              } else if (executorSchema.isNonNullType(field.type)) {
-                const typeStr = inspect(field.type);
-                onError(
-                  pathToArray(path),
-                  inputValue,
-                  new GraphQLError(
-                    `Field "${field.name}" of required type "${typeStr}" was not provided.`
-                  )
-                );
-              }
-              continue;
-            }
-            coercedValue[field.name] = coerceInputValueImpl(
-              executorSchema,
-              fieldValue,
-              field.type,
-              onError,
-              addPath(path, field.name, type2.name)
-            );
-          }
-          for (const fieldName of Object.keys(inputValue)) {
-            if (!fieldDefs[fieldName]) {
-              const suggestions = suggestionList(
-                fieldName,
-                Object.keys(type2.getFields())
-              );
-              onError(
-                pathToArray(path),
-                inputValue,
-                new GraphQLError(
-                  `Field "${fieldName}" is not defined by type "${type2.name}".` +
-                    didYouMean(suggestions)
-                )
-              );
-            }
-          }
-          return coercedValue;
-        }
-        if (executorSchema.isLeafType(type2)) {
-          let parseResult;
-          try {
-            parseResult = type2.parseValue(inputValue);
-          } catch (error2) {
-            if (isGraphQLError(error2)) {
-              onError(pathToArray(path), inputValue, error2);
-            } else {
-              onError(
-                pathToArray(path),
-                inputValue,
-                new GraphQLError(
-                  `Expected type "${type2.name}". ` + error2.message,
-                  void 0,
-                  void 0,
-                  void 0,
-                  void 0,
-                  error2
-                )
-              );
-            }
-            return;
-          }
-          if (parseResult === void 0) {
-            onError(
-              pathToArray(path),
-              inputValue,
-              new GraphQLError(`Expected type "${type2.name}".`)
-            );
-          }
-          return parseResult;
-        }
-        invariant(false, "Unexpected input type: " + inspect(type2));
-      }
-      function valueFromAST(executorSchema, valueNode, type2, variables) {
-        if (!valueNode) {
-          return;
-        }
-        if (valueNode.kind === Kind.VARIABLE) {
-          const variableName = valueNode.name.value;
-          if (variables == null || variables[variableName] === void 0) {
-            return;
-          }
-          const variableValue = variables[variableName];
-          if (variableValue === null && executorSchema.isNonNullType(type2)) {
-            return;
-          }
-          return variableValue;
-        }
-        if (executorSchema.isNonNullType(type2)) {
-          if (valueNode.kind === Kind.NULL) {
-            return;
-          }
-          return valueFromAST(
-            executorSchema,
-            valueNode,
-            type2.ofType,
-            variables
-          );
-        }
-        if (valueNode.kind === Kind.NULL) {
-          return null;
-        }
-        if (executorSchema.isListType(type2)) {
-          const itemType = type2.ofType;
-          if (valueNode.kind === Kind.LIST) {
-            const coercedValues = [];
-            for (const itemNode of valueNode.values) {
-              if (isMissingVariable(itemNode, variables)) {
-                if (executorSchema.isNonNullType(itemType)) {
-                  return;
-                }
-                coercedValues.push(null);
-              } else {
-                const itemValue = valueFromAST(
-                  executorSchema,
-                  itemNode,
-                  itemType,
-                  variables
-                );
-                if (itemValue === void 0) {
-                  return;
-                }
-                coercedValues.push(itemValue);
-              }
-            }
-            return coercedValues;
-          }
-          const coercedValue = valueFromAST(
-            executorSchema,
-            valueNode,
-            itemType,
-            variables
-          );
-          if (coercedValue === void 0) {
-            return;
-          }
-          return [coercedValue];
-        }
-        if (executorSchema.isInputObjectType(type2)) {
-          if (valueNode.kind !== Kind.OBJECT) {
-            return;
-          }
-          const coercedObj = /* @__PURE__ */ Object.create(null);
-          const fieldNodes = keyMap(
-            valueNode.fields,
-            (field) => field.name.value
-          );
-          for (const field of Object.values(type2.getFields())) {
-            const fieldNode = fieldNodes[field.name];
-            if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
-              if (field.defaultValue !== void 0) {
-                coercedObj[field.name] = field.defaultValue;
-              } else if (executorSchema.isNonNullType(field.type)) {
-                return;
-              }
-              continue;
-            }
-            const fieldValue = valueFromAST(
-              executorSchema,
-              fieldNode.value,
-              field.type,
-              variables
-            );
-            if (fieldValue === void 0) {
-              return;
-            }
-            coercedObj[field.name] = fieldValue;
-          }
-          return coercedObj;
-        }
-        if (executorSchema.isLeafType(type2)) {
-          let result2;
-          try {
-            result2 = type2.parseLiteral(valueNode, variables);
-          } catch (_error) {
-            return;
-          }
-          if (result2 === void 0) {
-            return;
-          }
-          return result2;
-        }
-        invariant(false, "Unexpected input type: " + inspect(type2));
-      }
-      function isMissingVariable(valueNode, variables) {
-        return (
-          valueNode.kind === Kind.VARIABLE &&
-          (variables == null || variables[valueNode.name.value] === void 0)
-        );
-      }
-      function getVariableValues(executorSchema, varDefNodes, inputs, options) {
-        const errors2 = [];
-        const maxErrors =
-          options === null || options === void 0 ? void 0 : options.maxErrors;
-        try {
-          const coerced = coerceVariableValues(
-            executorSchema,
-            varDefNodes,
-            inputs,
-            (error2) => {
-              if (maxErrors != null && errors2.length >= maxErrors) {
-                throw new GraphQLError(
-                  "Too many errors processing variables, error limit reached. Execution aborted."
-                );
-              }
-              errors2.push(error2);
-            }
-          );
-          if (errors2.length === 0) {
-            return {
-              coerced,
-            };
-          }
-        } catch (error2) {
-          errors2.push(error2);
-        }
-        return {
-          errors: errors2,
-        };
-      }
-      function coerceVariableValues(
-        executorSchema,
-        varDefNodes,
-        inputs,
-        onError
-      ) {
-        const coercedValues = {};
-        for (const varDefNode of varDefNodes) {
-          const varName = varDefNode.variable.name.value;
-          const varType = executorSchema.getType(varDefNode.type);
-          if (!varType || !executorSchema.isInputType(varType)) {
-            const varTypeStr = print(varDefNode.type);
-            onError(
-              new GraphQLError(
-                `Variable "$${varName}" expected value of type "${varTypeStr}" which cannot be used as an input type.`,
-                varDefNode.type
-              )
-            );
-            continue;
-          }
-          if (!hasOwnProperty$1(inputs, varName)) {
-            if (varDefNode.defaultValue) {
-              coercedValues[varName] = valueFromAST(
-                executorSchema,
-                varDefNode.defaultValue,
-                varType
-              );
-            } else if (executorSchema.isNonNullType(varType)) {
-              const varTypeStr = inspect(varType);
-              onError(
-                new GraphQLError(
-                  `Variable "$${varName}" of required type "${varTypeStr}" was not provided.`,
-                  varDefNode
-                )
-              );
-            }
-            continue;
-          }
-          const value = inputs[varName];
-          if (value === null && executorSchema.isNonNullType(varType)) {
-            const varTypeStr = inspect(varType);
-            onError(
-              new GraphQLError(
-                `Variable "$${varName}" of non-null type "${varTypeStr}" must not be null.`,
-                varDefNode
-              )
-            );
-            continue;
-          }
-          coercedValues[varName] = coerceInputValue(
-            executorSchema,
-            value,
-            varType,
-            (path, invalidValue, error2) => {
-              let prefix =
-                `Variable "$${varName}" got invalid value ` +
-                inspect(invalidValue);
-              if (path.length > 0) {
-                prefix += ` at "${varName}${printPathArray(path)}"`;
-              }
-              onError(
-                new GraphQLError(
-                  prefix + "; " + error2.message,
-                  varDefNode,
-                  void 0,
-                  void 0,
-                  void 0,
-                  error2.originalError
-                )
-              );
-            }
-          );
-        }
-        return coercedValues;
-      }
-      function getArgumentValues(executorSchema, def, node, variableValues) {
-        var _node$arguments;
-        const coercedValues = {};
-        const argumentNodes =
-          (_node$arguments = node.arguments) !== null &&
-          _node$arguments !== void 0
-            ? _node$arguments
-            : [];
-        const argNodeMap = keyMap(argumentNodes, (arg) => arg.name.value);
-        for (const argDef of def.args) {
-          const name2 = argDef.name;
-          const argType = argDef.type;
-          const argumentNode = argNodeMap[name2];
-          if (!argumentNode) {
-            if (argDef.defaultValue !== void 0) {
-              coercedValues[name2] = argDef.defaultValue;
-            } else if (executorSchema.isNonNullType(argType)) {
-              throw new GraphQLError(
-                `Argument "${name2}" of required type "${inspect(
-                  argType
-                )}" was not provided.`,
-                node
-              );
-            }
-            continue;
-          }
-          const valueNode = argumentNode.value;
-          let isNull = valueNode.kind === Kind.NULL;
-          if (valueNode.kind === Kind.VARIABLE) {
-            const variableName = valueNode.name.value;
-            if (
-              variableValues == null ||
-              !hasOwnProperty$1(variableValues, variableName)
-            ) {
-              if (argDef.defaultValue !== void 0) {
-                coercedValues[name2] = argDef.defaultValue;
-              } else if (executorSchema.isNonNullType(argType)) {
-                throw new GraphQLError(
-                  `Argument "${name2}" of required type "${inspect(
-                    argType
-                  )}" was provided the variable "$${variableName}" which was not provided a runtime value.`,
-                  valueNode
-                );
-              }
-              continue;
-            }
-            isNull = variableValues[variableName] == null;
-          }
-          if (isNull && executorSchema.isNonNullType(argType)) {
-            throw new GraphQLError(
-              `Argument "${name2}" of non-null type "${inspect(
-                argType
-              )}" must not be null.`,
-              valueNode
-            );
-          }
-          const coercedValue = valueFromAST(
-            executorSchema,
-            valueNode,
-            argType,
-            variableValues
-          );
-          if (coercedValue === void 0) {
-            throw new GraphQLError(
-              `Argument "${name2}" has invalid value ${print(valueNode)}.`,
-              valueNode
-            );
-          }
-          coercedValues[name2] = coercedValue;
-        }
-        return coercedValues;
-      }
-      function getDirectiveValues(
-        executorSchema,
-        directiveDef,
-        node,
-        variableValues
-      ) {
-        var _node$directives;
-        const directiveNode =
-          (_node$directives = node.directives) === null ||
-          _node$directives === void 0
-            ? void 0
-            : _node$directives.find(
-                (directive) => directive.name.value === directiveDef.name
-              );
-        if (directiveNode) {
-          return getArgumentValues(
-            executorSchema,
-            directiveDef,
-            directiveNode,
-            variableValues
-          );
-        }
-      }
-      function hasOwnProperty$1(obj, prop2) {
-        return Object.prototype.hasOwnProperty.call(obj, prop2);
-      }
-      class RepeaterOverflowError extends Error {
-        constructor(message) {
-          super(message);
-          Object.defineProperty(this, "name", {
-            value: "RepeaterOverflowError",
-            enumerable: false,
-          });
-          Object.setPrototypeOf(this, this.constructor.prototype);
-          if (typeof Error.captureStackTrace === "function") {
-            Error.captureStackTrace(this, this.constructor);
-          }
-        }
-      }
-      function swallow(value) {
-        if (value != null && typeof value.then === "function") {
-          value.then(NOOP, NOOP);
-        }
-      }
-      const Initial = 0;
-      const Started = 1;
-      const Stopped = 2;
-      const Done = 3;
-      const Rejected = 4;
-      const MAX_QUEUE_LENGTH = 1024;
-      const NOOP = () => void 0;
-      function consumeExecution(r2) {
-        const err = r2.err;
-        const execution = Promise.resolve(r2.execution).then((value) => {
-          if (err != null) {
-            throw err;
-          }
-          return value;
-        });
-        r2.err = void 0;
-        r2.execution = execution.then(
-          () => void 0,
-          () => void 0
-        );
-        return r2.pending === void 0
-          ? execution
-          : r2.pending.then(() => execution);
-      }
-      function createIteration(r2, value) {
-        const done = r2.state >= Done;
-        return Promise.resolve(value).then((resolvedValue) => {
-          if (!done && r2.state >= Rejected) {
-            return consumeExecution(r2).then((finalValue) => ({
-              value: finalValue,
-              done: true,
-            }));
-          }
-          return {
-            value: resolvedValue,
-            done,
-          };
-        });
-      }
-      function stop(r2, err) {
-        if (r2.state >= Stopped) {
-          return;
-        }
-        r2.state = Stopped;
-        r2.onnext();
-        r2.onstop();
-        if (r2.err == null) {
-          r2.err = err;
-        }
-        if (
-          r2.pushes.length === 0 &&
-          (typeof r2.buffer === "undefined" || r2.buffer.empty)
-        ) {
-          finish(r2);
-        } else {
-          for (const p2 of r2.pushes) {
-            p2.resolve();
-          }
-        }
-      }
-      function finish(r2) {
-        if (r2.state >= Done) {
-          return;
-        }
-        if (r2.state < Stopped) {
-          stop(r2);
-        }
-        r2.state = Done;
-        r2.buffer = void 0;
-        for (const next of r2.nexts) {
-          const execution =
-            r2.pending === void 0
-              ? consumeExecution(r2)
-              : r2.pending.then(() => consumeExecution(r2));
-          next.resolve(createIteration(r2, execution));
-        }
-        r2.pushes = [];
-        r2.nexts = [];
-      }
-      function reject(r2) {
-        if (r2.state >= Rejected) {
-          return;
-        }
-        if (r2.state < Done) {
-          finish(r2);
-        }
-        r2.state = Rejected;
-      }
-      function push(r2, value) {
-        swallow(value);
-        if (r2.pushes.length >= MAX_QUEUE_LENGTH) {
-          throw new RepeaterOverflowError(
-            `No more than ${MAX_QUEUE_LENGTH} pending calls to push are allowed on a single repeater.`
-          );
-        } else if (r2.state >= Stopped) {
-          return Promise.resolve(void 0);
-        }
-        let valueP =
-          r2.pending === void 0
-            ? Promise.resolve(value)
-            : r2.pending.then(() => value);
-        valueP = valueP.catch((err) => {
-          if (r2.state < Stopped) {
-            r2.err = err;
-          }
-          reject(r2);
-          return void 0;
-        });
-        let nextP;
-        if (r2.nexts.length) {
-          const next2 = r2.nexts.shift();
-          next2.resolve(createIteration(r2, valueP));
-          if (r2.nexts.length) {
-            nextP = Promise.resolve(r2.nexts[0].value);
-          } else {
-            nextP = new Promise((resolve) => (r2.onnext = resolve));
-          }
-        } else if (typeof r2.buffer !== "undefined" && !r2.buffer.full) {
-          r2.buffer.add(valueP);
-          nextP = Promise.resolve(void 0);
-        } else {
-          nextP = new Promise((resolve) =>
-            r2.pushes.push({
-              resolve,
-              value: valueP,
-            })
-          );
-        }
-        let floating = true;
-        const next = {};
-        const unhandled = nextP.catch((err) => {
-          if (floating) {
-            throw err;
-          }
-          return void 0;
-        });
-        next.then = (onfulfilled, onrejected) => {
-          floating = false;
-          return Promise.prototype.then.call(nextP, onfulfilled, onrejected);
-        };
-        next.catch = (onrejected) => {
-          floating = false;
-          return Promise.prototype.catch.call(nextP, onrejected);
-        };
-        next.finally = nextP.finally.bind(nextP);
-        r2.pending = valueP
-          .then(() => unhandled)
-          .catch((err) => {
-            r2.err = err;
-            reject(r2);
-          });
-        return next;
-      }
-      function createStop(r2) {
-        const stop1 = stop.bind(null, r2);
-        const stopP = new Promise((resolve) => (r2.onstop = resolve));
-        stop1.then = stopP.then.bind(stopP);
-        stop1.catch = stopP.catch.bind(stopP);
-        stop1.finally = stopP.finally.bind(stopP);
-        return stop1;
-      }
-      function execute(r2) {
-        r2.state = Started;
-        const push1 = push.bind(null, r2);
-        const stop1 = createStop(r2);
-        r2.execution = new Promise((resolve) =>
-          resolve(r2.executor(push1, stop1))
-        );
-        r2.execution.catch(() => stop(r2));
-      }
-      const records = /* @__PURE__ */ new WeakMap();
-      class Repeater {
-        constructor(executor, buffer2) {
-          records.set(this, {
-            executor,
-            buffer: buffer2,
-            err: void 0,
-            state: Initial,
-            pushes: [],
-            nexts: [],
-            pending: void 0,
-            execution: void 0,
-            onnext: NOOP,
-            onstop: NOOP,
-          });
-        }
-        next(value) {
-          swallow(value);
-          const r2 = records.get(this);
-          if (r2 === void 0) {
-            throw new Error("WeakMap error");
-          }
-          if (r2.nexts.length >= MAX_QUEUE_LENGTH) {
-            throw new RepeaterOverflowError(
-              `No more than ${MAX_QUEUE_LENGTH} pending calls to next are allowed on a single repeater.`
-            );
-          }
-          if (r2.state <= Initial) {
-            execute(r2);
-          }
-          r2.onnext(value);
-          if (typeof r2.buffer !== "undefined" && !r2.buffer.empty) {
-            const result2 = createIteration(r2, r2.buffer.remove());
-            if (r2.pushes.length) {
-              const p2 = r2.pushes.shift();
-              r2.buffer.add(p2.value);
-              r2.onnext = p2.resolve;
-            }
-            return result2;
-          } else if (r2.pushes.length) {
-            const p2 = r2.pushes.shift();
-            r2.onnext = p2.resolve;
-            return createIteration(r2, p2.value);
-          } else if (r2.state >= Stopped) {
-            finish(r2);
-            return createIteration(r2, consumeExecution(r2));
-          }
-          return new Promise((resolve) =>
-            r2.nexts.push({
-              resolve,
-              value,
-            })
-          );
-        }
-        return(value) {
-          swallow(value);
-          const r2 = records.get(this);
-          if (r2 === void 0) {
-            throw new Error("WeakMap error");
-          }
-          finish(r2);
-          r2.execution = Promise.resolve(r2.execution).then(() => value);
-          return createIteration(r2, consumeExecution(r2));
-        }
-        throw(err) {
-          const r2 = records.get(this);
-          if (r2 === void 0) {
-            throw new Error("WeakMap error");
-          }
-          if (
-            r2.state <= Initial ||
-            r2.state >= Stopped ||
-            (typeof r2.buffer !== "undefined" && !r2.buffer.empty)
-          ) {
-            finish(r2);
-            if (r2.err == null) {
-              r2.err = err;
-            }
-            return createIteration(r2, consumeExecution(r2));
-          }
-          return this.next(Promise.reject(err));
-        }
-        [Symbol.asyncIterator]() {
-          return this;
-        }
-      }
-      class Publisher {
-        constructor({
-          payloadFromSource = (source) => source,
-          onReady,
-          hasNext = () => true,
-          onStop,
-        } = {}) {
-          this._payloadFromSource = payloadFromSource;
-          this._onReady = onReady;
-          this._hasNext = hasNext;
-          this._buffer = [];
-          this._stopped = false;
-          this._trigger = new Promise((resolve) => {
-            this._resolve = resolve;
-          });
-          this._pushed = /* @__PURE__ */ new WeakMap();
-          this._pending = /* @__PURE__ */ new WeakMap();
-          this._repeater = new Repeater(async (push2, stop2) => {
-            if (onStop) {
-              stop2.then(onStop);
-            }
-            while (true) {
-              await this._trigger;
-              while (this._buffer.length) {
-                const payload = this._buffer.shift();
-                await push2(payload);
-              }
-              if (this._stopped) {
-                stop2();
-                break;
-              }
-              this._trigger = new Promise((resolve) => {
-                this._resolve = resolve;
-              });
-            }
-          });
-        }
-        emit(keys, payload) {
-          for (const key of keys) {
-            this._pushed.set(key, true);
-          }
-          this._buffer.push(payload);
-          for (const key of keys) {
-            const dependents = this._pending.get(key);
-            if (dependents) {
-              this._pushMany(dependents);
-            }
-            this._pending.delete(key);
-          }
-          this._resolve();
-        }
-        stop(finalPayload) {
-          if (finalPayload !== void 0) {
-            this._buffer.push(finalPayload);
-          }
-          this._stopped = true;
-          this._resolve();
-        }
-        queue(keys, source, parentKey) {
-          if (this._pushed.get(parentKey)) {
-            this._pushOne({
-              keys,
-              source,
-            });
-            return;
-          }
-          const dependents = this._pending.get(parentKey);
-          if (dependents) {
-            dependents.push({
-              keys,
-              source,
-            });
-            return;
-          }
-          this._pending.set(parentKey, [
-            {
-              keys,
-              source,
-            },
-          ]);
-        }
-        _pushOne(context) {
-          const hasNext = this._pushOneImpl(context);
-          if (!hasNext) {
-            this.stop();
-          }
-        }
-        _pushOneImpl({ keys, source }) {
-          var _this$_onReady;
-          (_this$_onReady = this._onReady) === null || _this$_onReady === void 0
-            ? void 0
-            : _this$_onReady.call(this);
-          const hasNext = this._hasNext();
-          const payload = this._payloadFromSource(source, hasNext);
-          this.emit(keys, payload);
-          return hasNext;
-        }
-        _pushMany(contexts) {
-          let hasNext = false;
-          for (const context of contexts) {
-            hasNext = this._pushOneImpl(context);
-          }
-          if (!hasNext) {
-            this.stop();
-          }
-        }
-        subscribe() {
-          return this._repeater;
-        }
-      }
-      class Bundler {
-        constructor({
-          initialIndex,
-          maxBundleSize,
-          maxInterval,
-          createDataBundleContext,
-          createErrorBundleContext,
-          onSubsequentData,
-          onSubsequentError,
-          onDataBundle,
-          onErrorBundle,
-        }) {
-          this._maxBundleSize = maxBundleSize;
-          this._createDataBundleContext = createDataBundleContext;
-          this._createErrorBundleContext = createErrorBundleContext;
-          this._onSubsequentData = onSubsequentData;
-          this._onSubsequentError = onSubsequentError;
-          this._onDataBundle = onDataBundle;
-          this._onErrorBundle = onErrorBundle;
-          if (maxInterval != null) {
-            this._timingContext = {
-              maxInterval,
-              timeout: void 0,
-              lastTime: Date.now(),
-            };
-          }
-          this._currentBundleSize = 0;
-          this._count = initialIndex;
-        }
-        queueData(index, result2) {
-          const context = this._updateDataContext(index, result2);
-          this._currentBundleSize++;
-          this._count++;
-          if (this._count === this._total) {
-            this._onDataBundle(context);
-            if (this._timingContext) {
-              this._clearCurrentTimer(this._timingContext);
-            }
-            return;
-          }
-          if (this._currentBundleSize === this._maxBundleSize) {
-            this._onDataBundle(context);
-            this._currentContext = void 0;
-            if (this._timingContext) {
-              this._restartTimer(this._timingContext);
-            }
-            return;
-          }
-          if (
-            this._timingContext &&
-            Date.now() - this._timingContext.lastTime >
-              this._timingContext.maxInterval
-          ) {
-            this._onDataBundle(context);
-            this._currentContext = void 0;
-            this._startNewTimer(this._timingContext);
-          }
-        }
-        queueError(index, result2) {
-          const context = this._updateErrorContext(index, result2);
-          this._currentBundleSize++;
-          this._count++;
-          if (this._count === this._total) {
-            this._onErrorBundle(context);
-            if (this._timingContext) {
-              this._clearCurrentTimer(this._timingContext);
-            }
-            return;
-          }
-          if (this._currentBundleSize === this._maxBundleSize) {
-            this._onErrorBundle(context);
-            this._currentContext = void 0;
-            if (this._timingContext) {
-              this._restartTimer(this._timingContext);
-            }
-          }
-          if (
-            this._timingContext &&
-            Date.now() - this._timingContext.lastTime >
-              this._timingContext.maxInterval
-          ) {
-            this._onErrorBundle(context);
-            this._currentContext = void 0;
-            this._startNewTimer(this._timingContext);
-          }
-        }
-        setTotal(total) {
-          if (this._count < total) {
-            this._total = total;
-            return;
-          }
-          if (this._currentContext) {
-            this._onBundle(this._currentContext);
-            if (this._timingContext) {
-              this._clearCurrentTimer(this._timingContext);
-            }
-          }
-        }
-        _clearCurrentTimer(timingContext) {
-          const timeout = timingContext.timeout;
-          if (timeout) {
-            clearTimeout(timeout);
-          }
-        }
-        _startNewTimer(timingContext) {
-          timingContext.timeout = setTimeout(
-            () => this._flushCurrentBundle(timingContext),
-            timingContext.maxInterval
-          );
-          timingContext.lastTime = Date.now();
-        }
-        _flushCurrentBundle(timingContext) {
-          if (this._currentContext) {
-            this._onBundle(this._currentContext);
-            this._currentContext = void 0;
-            this._restartTimer(timingContext);
-            this._startNewTimer(timingContext);
-          }
-        }
-        _restartTimer(timingContext) {
-          this._clearCurrentTimer(timingContext);
-          this._startNewTimer(timingContext);
-        }
-        _updateDataContext(index, result2) {
-          if (this._currentContext === void 0) {
-            return this._getNewDataContext(index, result2);
-          } else if (!this._currentContext.isData) {
-            this._onErrorBundle(this._currentContext.context);
-            return this._getNewDataContext(index, result2);
-          }
-          this._onSubsequentData(index, result2, this._currentContext.context);
-          return this._currentContext.context;
-        }
-        _getNewDataContext(index, result2) {
-          this._currentBundleSize = 0;
-          const context = this._createDataBundleContext(index, result2);
-          this._currentContext = {
-            isData: true,
-            context,
-          };
-          if (this._timingContext) {
-            const timingContext = this._timingContext;
-            timingContext.timeout = setTimeout(
-              () => this._flushCurrentBundle(timingContext),
-              timingContext.maxInterval
-            );
-          }
-          return context;
-        }
-        _updateErrorContext(index, result2) {
-          if (this._currentContext === void 0) {
-            return this._getNewErrorContext(index, result2);
-          } else if (this._currentContext.isData) {
-            this._onDataBundle(this._currentContext.context);
-            return this._getNewErrorContext(index, result2);
-          }
-          this._onSubsequentError(index, result2, this._currentContext.context);
-          return this._currentContext.context;
-        }
-        _getNewErrorContext(index, result2) {
-          this._currentBundleSize = 0;
-          const context = this._createErrorBundleContext(index, result2);
-          this._currentContext = {
-            isData: false,
-            context,
-          };
-          if (this._timingContext) {
-            const timingContext = this._timingContext;
-            timingContext.timeout = setTimeout(
-              () => this._flushCurrentBundle(timingContext),
-              timingContext.maxInterval
-            );
-          }
-          return context;
-        }
-        _onBundle(bundleContext) {
-          if (bundleContext.isData) {
-            this._onDataBundle(bundleContext.context);
-            return;
-          }
-          this._onErrorBundle(bundleContext.context);
-        }
-      }
-      function getSequentialBundler(initialIndex, bundler) {
-        const dataResultMap = /* @__PURE__ */ new Map();
-        const errorResultMap = /* @__PURE__ */ new Map();
-        let count = initialIndex;
-        return {
-          queueData: (index, result2) => {
-            if (count !== index) {
-              dataResultMap.set(index, result2);
-              return;
-            }
-            bundler.queueData(index, result2);
-            count++;
-            processPending();
-          },
-          queueError: (index, result2) => {
-            if (count !== index) {
-              errorResultMap.set(index, result2);
-              return;
-            }
-            bundler.queueError(index, result2);
-            count++;
-            processPending();
-          },
-          setTotal: (total) => bundler.setTotal(total),
-        };
-        function processPending() {
-          while (true) {
-            const dataResult = dataResultMap.get(count);
-            if (dataResult !== void 0) {
-              dataResultMap.delete(count);
-              bundler.queueData(count, dataResult);
-              count++;
-              continue;
-            }
-            const errorResult = errorResultMap.get(count);
-            if (errorResult !== void 0) {
-              errorResultMap.delete(count);
-              bundler.queueError(count, errorResult);
-              count++;
-              continue;
-            }
-            break;
-          }
-        }
-      }
-      function mapAsyncIterable(iterable, fn) {
-        return new Repeater(async (push2, stop2) => {
-          const iter = iterable[Symbol.asyncIterator]();
-          let finalIteration;
-          stop2.then(() => {
-            finalIteration =
-              typeof iter.return === "function" ? iter.return() : true;
-          });
-          while (!finalIteration) {
-            const iteration = await iter.next();
-            if (iteration.done) {
-              stop2();
-              break;
-            }
-            await push2(fn(iteration.value));
-          }
-          if (isPromise(finalIteration)) {
-            await finalIteration;
-          }
-        });
-      }
-      function flattenAsyncIterable(iterable) {
-        return new Repeater(async (push2, stop2) => {
-          const iter = iterable[Symbol.asyncIterator]();
-          let childIterator;
-          let finalIteration;
-          stop2.then(() => {
-            const childReturned =
-              childIterator &&
-              typeof childIterator.return === "function" &&
-              childIterator.return();
-            const returned = typeof iter.return === "function" && iter.return();
-            if (isPromise(childReturned)) {
-              finalIteration = isPromise(returned)
-                ? Promise.all([childReturned, returned])
-                : true;
-            } else if (isPromise(returned)) {
-              finalIteration = returned;
-            } else {
-              finalIteration = true;
-            }
-          });
-          while (!finalIteration) {
-            const iteration = await iter.next();
-            if (iteration.done) {
-              stop2();
-              break;
-            }
-            const value = iteration.value;
-            if (isAsyncIterable(value)) {
-              childIterator = value[Symbol.asyncIterator]();
-              await pushChildIterations(childIterator, push2, finalIteration);
-              childIterator = void 0;
-              continue;
-            }
-            await push2(value);
-          }
-          if (isPromise(finalIteration)) {
-            await finalIteration;
-          }
-        });
-      }
-      async function pushChildIterations(iter, push2, finalIteration) {
-        while (!finalIteration) {
-          const iteration = await iter.next();
-          if (iteration.done) {
-            return;
-          }
-          await push2(iteration.value);
-        }
-      }
-      function _defineProperty$1(obj, key, value) {
-        if (key in obj) {
-          Object.defineProperty(obj, key, {
-            value,
-            enumerable: true,
-            configurable: true,
-            writable: true,
-          });
-        } else {
-          obj[key] = value;
-        }
-        return obj;
-      }
-      class Executor {
-        constructor(executorArgs) {
-          _defineProperty$1(
-            this,
-            "splitDefinitions",
-            memoize1((document2) => this._splitDefinitions(document2))
-          );
-          _defineProperty$1(
-            this,
-            "selectOperation",
-            memoize1and1((operations, operationName) =>
-              this._selectOperation(operations, operationName)
-            )
-          );
-          _defineProperty$1(
-            this,
-            "getFieldContext",
-            memoize2((parentType, fieldNodes) =>
-              this._getFieldContext(parentType, fieldNodes)
-            )
-          );
-          _defineProperty$1(
-            this,
-            "getValueCompleter",
-            memoize1((returnType) => this._getValueCompleter(returnType))
-          );
-          _defineProperty$1(
-            this,
-            "createFieldList",
-            memoize1((node) => [node])
-          );
-          _defineProperty$1(
-            this,
-            "updateFieldList",
-            memoize2((fieldList, node) => [...fieldList, node])
-          );
-          _defineProperty$1(
-            this,
-            "buildFieldResolver",
-            (resolverKey, defaultResolver) =>
-              (exeContext, fieldContext, source, info2) => {
-                var _fieldDef$resolverKey;
-                const { fieldDef, initialFieldNode } = fieldContext;
-                const resolveFn =
-                  (_fieldDef$resolverKey = fieldDef[resolverKey]) !== null &&
-                  _fieldDef$resolverKey !== void 0
-                    ? _fieldDef$resolverKey
-                    : defaultResolver;
-                const { contextValue, variableValues } = exeContext;
-                const args = exeContext.getArgumentValues(
-                  fieldDef,
-                  initialFieldNode,
-                  variableValues
-                );
-                return resolveFn(source, args, contextValue, info2);
-              }
-          );
-          _defineProperty$1(
-            this,
-            "buildRootFieldCollector",
-            (fragments, variableValues, getDeferValues) =>
-              (runtimeType, operation) => {
-                const fields = /* @__PURE__ */ new Map();
-                const patches = [];
-                this.collectFieldsImpl(
-                  fragments,
-                  variableValues,
-                  getDeferValues,
-                  runtimeType,
-                  operation.selectionSet,
-                  fields,
-                  patches,
-                  /* @__PURE__ */ new Set()
-                );
-                return {
-                  fields,
-                  patches,
-                };
-              }
-          );
-          _defineProperty$1(
-            this,
-            "buildSubFieldCollector",
-            (fragments, variableValues, getDeferValues) =>
-              memoize2((returnType, fieldNodes) => {
-                const subFieldNodes = /* @__PURE__ */ new Map();
-                const visitedFragmentNames = /* @__PURE__ */ new Set();
-                const subPatches = [];
-                const subFieldsAndPatches = {
-                  fields: subFieldNodes,
-                  patches: subPatches,
-                };
-                for (const node of fieldNodes) {
-                  if (node.selectionSet) {
-                    this.collectFieldsImpl(
-                      fragments,
-                      variableValues,
-                      getDeferValues,
-                      returnType,
-                      node.selectionSet,
-                      subFieldNodes,
-                      subPatches,
-                      visitedFragmentNames
-                    );
-                  }
-                }
-                return subFieldsAndPatches;
-              })
-          );
-          const { schema, executorSchema } = executorArgs;
-          schema || devAssert(false, "Must provide schema.");
-          this._schema = schema;
-          this._executorSchema =
-            executorSchema !== null && executorSchema !== void 0
-              ? executorSchema
-              : toExecutorSchema(schema);
-        }
-        execute(args) {
-          const exeContext = this.buildExecutionContext(args);
-          if (!("fragments" in exeContext)) {
-            return {
-              errors: exeContext,
-            };
-          }
-          const { operation, forceQueryAlgorithm } = exeContext;
-          if (forceQueryAlgorithm) {
-            return this.executeQueryImpl(exeContext);
-          }
-          switch (operation.operation) {
-            case "query":
-              return this.executeQueryImpl(exeContext);
-            case "mutation":
-              return this.executeMutationImpl(exeContext);
-            default:
-              return this.executeSubscriptionImpl(exeContext);
-          }
-        }
-        async createSourceEventStream(args) {
-          const exeContext = this.buildExecutionContext(args);
-          if (!("fragments" in exeContext)) {
-            return {
-              errors: exeContext,
-            };
-          }
-          return this.createSourceEventStreamImpl(exeContext);
-        }
-        executeQueryImpl(exeContext) {
-          return this.executeOperationImpl(
-            exeContext,
-            this.executeFields.bind(this),
-            this.buildResponse.bind(this)
-          );
-        }
-        executeMutationImpl(exeContext) {
-          return this.executeOperationImpl(
-            exeContext,
-            this.executeFieldsSerially.bind(this),
-            this.buildResponse.bind(this)
-          );
-        }
-        executeOperationImpl(exeContext, rootFieldsExecutor, responseBuilder) {
-          let data;
-          try {
-            const { rootValue, rootResponseNode } = exeContext;
-            const {
-              rootType,
-              fieldsAndPatches: { fields, patches },
-            } = this.getRootContext(exeContext);
-            const path = void 0;
-            data = rootFieldsExecutor(
-              exeContext,
-              rootType,
-              rootValue,
-              path,
-              fields,
-              rootResponseNode
-            );
-            this.addPatches(
-              exeContext,
-              patches,
-              rootType,
-              rootValue,
-              path,
-              rootResponseNode
-            );
-          } catch (error2) {
-            exeContext.rootResponseNode.errors.push(error2);
-            data = null;
-          }
-          if (isPromise(data)) {
-            return data.then(
-              (resolvedData) => responseBuilder(exeContext, resolvedData),
-              (error2) => {
-                exeContext.rootResponseNode.errors.push(error2);
-                return responseBuilder(exeContext, null);
-              }
-            );
-          }
-          return responseBuilder(exeContext, data);
-        }
-        buildResponse(exeContext, data) {
-          const rootResponseNode = exeContext.rootResponseNode;
-          const errors2 = rootResponseNode.errors;
-          const initialResult =
-            errors2.length === 0
-              ? {
-                  data,
-                }
-              : {
-                  errors: errors2,
-                  data,
-                };
-          if (this.hasNext(exeContext.state)) {
-            const publisher = exeContext.publisher;
-            publisher.emit(
-              [rootResponseNode],
-              __spreadProps(__spreadValues({}, initialResult), {
-                hasNext: true,
-              })
-            );
-            return publisher.subscribe();
-          }
-          return initialResult;
-        }
-        assertValidExecutionArguments(document2, rawVariableValues) {
-          document2 || devAssert(false, "Must provide document.");
-          rawVariableValues == null ||
-            isObjectLike(rawVariableValues) ||
-            devAssert(
-              false,
-              "Variables must be provided as an Object where each property is a variable value. Perhaps look to see if an unparsed JSON string was provided."
-            );
-        }
-        _splitDefinitions(document2) {
-          const operations = [];
-          const fragments = /* @__PURE__ */ Object.create(null);
-          for (const definition of document2.definitions) {
-            switch (definition.kind) {
-              case Kind.OPERATION_DEFINITION:
-                operations.push(definition);
-                break;
-              case Kind.FRAGMENT_DEFINITION:
-                fragments[definition.name.value] = definition;
-                break;
-            }
-          }
-          return {
-            operations,
-            fragments,
-          };
-        }
-        _selectOperation(operations, operationName) {
-          let operation;
-          for (const possibleOperation of operations) {
-            var _possibleOperation$na;
-            if (operationName == null) {
-              if (operation !== void 0) {
-                return [
-                  new GraphQLError(
-                    "Must provide operation name if query contains multiple operations."
-                  ),
-                ];
-              }
-              operation = possibleOperation;
-            } else if (
-              ((_possibleOperation$na = possibleOperation.name) === null ||
-              _possibleOperation$na === void 0
-                ? void 0
-                : _possibleOperation$na.value) === operationName
-            ) {
-              operation = possibleOperation;
-            }
-          }
-          if (!operation) {
-            if (operationName != null) {
-              return [
-                new GraphQLError(`Unknown operation named "${operationName}".`),
-              ];
-            }
-            return [new GraphQLError("Must provide an operation.")];
-          }
-          return operation;
-        }
-        createPublisher(state) {
-          return new Publisher({
-            payloadFromSource: (result2, hasNext) => {
-              const { responseContext, data, path, atIndex, atIndices, label } =
-                result2;
-              const errors2 = [];
-              for (const responseNode of responseContext.responseNodes) {
-                errors2.push(...responseNode.errors);
-              }
-              const value = {
-                data,
-                path: path ? pathToArray(path) : [],
-                hasNext,
-              };
-              if (atIndex != null) {
-                value.atIndex = atIndex;
-              } else if (atIndices != null) {
-                value.atIndices = atIndices;
-              }
-              if (label != null) {
-                value.label = label;
-              }
-              if (errors2.length > 0) {
-                value.errors = errors2;
-              }
-              return value;
-            },
-            onReady: () => state.pendingPushes--,
-            hasNext: () => this.hasNext(state),
-            onStop: () =>
-              Promise.all(
-                Array.from(state.iterators.values()).map((iterator) => {
-                  var _iterator$return;
-                  return (_iterator$return = iterator.return) === null ||
-                    _iterator$return === void 0
-                    ? void 0
-                    : _iterator$return.call(iterator);
-                })
-              ),
-          });
-        }
-        buildExecutionContext(args) {
-          var _operation$variableDe;
-          const {
-            document: document2,
-            rootValue,
-            contextValue,
-            variableValues: rawVariableValues,
-            operationName,
-            fieldResolver,
-            typeResolver,
-            subscribeFieldResolver,
-            forceQueryAlgorithm,
-            enableIncremental,
-          } = args;
-          this.assertValidExecutionArguments(document2, rawVariableValues);
-          const { operations, fragments } = this.splitDefinitions(document2);
-          const operation = this.selectOperation(operations, operationName);
-          if ("length" in operation) {
-            return operation;
-          }
-          const variableDefinitions =
-            (_operation$variableDe = operation.variableDefinitions) !== null &&
-            _operation$variableDe !== void 0
-              ? _operation$variableDe
-              : [];
-          const coercedVariableValues = getVariableValues(
-            this._executorSchema,
-            variableDefinitions,
-            rawVariableValues !== null && rawVariableValues !== void 0
-              ? rawVariableValues
-              : {},
-            {
-              maxErrors: 50,
-            }
-          );
-          if (coercedVariableValues.errors) {
-            return coercedVariableValues.errors;
-          }
-          const enableIncrementalFlagValue =
-            enableIncremental !== null && enableIncremental !== void 0
-              ? enableIncremental
-              : true;
-          const defaultResolveFieldValueFn =
-            fieldResolver !== null && fieldResolver !== void 0
-              ? fieldResolver
-              : defaultFieldResolver;
-          const getDeferValues = enableIncrementalFlagValue
-            ? this.getDeferValues.bind(this)
-            : () => void 0;
-          const coercedVariableValuesValues = coercedVariableValues.coerced;
-          const state = {
-            pendingPushes: 0,
-            pendingStreamResults: 0,
-            iterators: /* @__PURE__ */ new Set(),
-          };
-          return {
-            fragments,
-            rootValue,
-            contextValue,
-            operation,
-            variableValues: coercedVariableValues.coerced,
-            fieldResolver: defaultResolveFieldValueFn,
-            typeResolver:
-              typeResolver !== null && typeResolver !== void 0
-                ? typeResolver
-                : defaultTypeResolver,
-            forceQueryAlgorithm:
-              forceQueryAlgorithm !== null && forceQueryAlgorithm !== void 0
-                ? forceQueryAlgorithm
-                : false,
-            enableIncremental: enableIncrementalFlagValue,
-            getArgumentValues: memoize2((def, node) =>
-              getArgumentValues(
-                this._executorSchema,
-                def,
-                node,
-                coercedVariableValuesValues
-              )
-            ),
-            getDeferValues,
-            getStreamValues: enableIncrementalFlagValue
-              ? this.getStreamValues.bind(this)
-              : () => void 0,
-            rootFieldCollector: this.buildRootFieldCollector(
-              fragments,
-              coercedVariableValuesValues,
-              getDeferValues
-            ),
-            subFieldCollector: this.buildSubFieldCollector(
-              fragments,
-              coercedVariableValuesValues,
-              getDeferValues
-            ),
-            resolveField:
-              operation.operation === "subscription" && !forceQueryAlgorithm
-                ? this.buildFieldResolver(
-                    "subscribe",
-                    subscribeFieldResolver !== null &&
-                      subscribeFieldResolver !== void 0
-                      ? subscribeFieldResolver
-                      : defaultFieldResolver
-                  )
-                : this.buildFieldResolver(
-                    "resolve",
-                    defaultResolveFieldValueFn
-                  ),
-            rootResponseNode: {
-              errors: [],
-            },
-            state,
-            publisher: this.createPublisher(state),
-          };
-        }
-        buildPerPayloadExecutionContext(exeContext, payload) {
-          const state = {
-            pendingPushes: 0,
-            pendingStreamResults: 0,
-            iterators: /* @__PURE__ */ new Set(),
-          };
-          return __spreadProps(__spreadValues({}, exeContext), {
-            rootValue: payload,
-            forceQueryAlgorithm: true,
-            resolveField: this.buildFieldResolver(
-              "resolve",
-              exeContext.fieldResolver
-            ),
-            rootResponseNode: {
-              errors: [],
-            },
-            state,
-            publisher: this.createPublisher(state),
-          });
-        }
-        getRootContext(exeContext) {
-          const { operation, rootFieldCollector } = exeContext;
-          const rootType = this._executorSchema.getRootType(
-            operation.operation
-          );
-          if (rootType == null) {
-            throw new GraphQLError(
-              `Schema is not configured to execute ${operation.operation} operation.`,
-              operation
-            );
-          }
-          const fieldsAndPatches = rootFieldCollector(rootType, operation);
-          return {
-            rootType,
-            fieldsAndPatches,
-          };
-        }
-        executeFieldsSerially(
-          exeContext,
-          parentType,
-          sourceValue,
-          path,
-          fields
-        ) {
-          const parentTypeName = parentType.name;
-          return promiseReduce(
-            fields.entries(),
-            (results, [responseName, fieldNodes]) => {
-              const fieldPath = addPath(path, responseName, parentTypeName);
-              const result2 = this.executeField(
-                exeContext,
-                parentType,
-                sourceValue,
-                fieldNodes,
-                fieldPath,
-                exeContext.rootResponseNode
-              );
-              if (result2 === void 0) {
-                return results;
-              }
-              if (isPromise(result2)) {
-                return result2.then((resolvedResult) => {
-                  results[responseName] = resolvedResult;
-                  return results;
-                });
-              }
-              results[responseName] = result2;
-              return results;
-            },
-            /* @__PURE__ */ Object.create(null)
-          );
-        }
-        executeFields(
-          exeContext,
-          parentType,
-          sourceValue,
-          path,
-          fields,
-          responseNode
-        ) {
-          const results = /* @__PURE__ */ Object.create(null);
-          const promises = [];
-          const parentTypeName = parentType.name;
-          for (const [responseName, fieldNodes] of fields.entries()) {
-            const fieldPath = addPath(path, responseName, parentTypeName);
-            const result2 = this.executeField(
-              exeContext,
-              parentType,
-              sourceValue,
-              fieldNodes,
-              fieldPath,
-              responseNode
-            );
-            if (result2 !== void 0) {
-              if (isPromise(result2)) {
-                results[responseName] = void 0;
-                const promise = result2.then((resolved) => {
-                  results[responseName] = resolved;
-                });
-                promises.push(promise);
-              } else {
-                results[responseName] = result2;
-              }
-            }
-          }
-          if (!promises.length) {
-            return results;
-          }
-          return resolveAfterAll(results, promises);
-        }
-        executeField(
-          exeContext,
-          parentType,
-          source,
-          fieldNodes,
-          path,
-          responseNode
-        ) {
-          const fieldContext = this.getFieldContext(parentType, fieldNodes);
-          if (!fieldContext) {
-            return;
-          }
-          const returnType = fieldContext.returnType;
-          const info2 = this.buildResolveInfo(exeContext, fieldContext, path);
-          try {
-            const result2 = exeContext.resolveField(
-              exeContext,
-              fieldContext,
-              source,
-              info2
-            );
-            let completed;
-            const valueCompleter = this.getValueCompleter(returnType);
-            if (isPromise(result2)) {
-              completed = result2.then((resolved) =>
-                valueCompleter(
-                  exeContext,
-                  fieldContext,
-                  info2,
-                  path,
-                  resolved,
-                  responseNode
-                )
-              );
-            } else {
-              completed = valueCompleter(
-                exeContext,
-                fieldContext,
-                info2,
-                path,
-                result2,
-                responseNode
-              );
-            }
-            if (isPromise(completed)) {
-              return completed.then(void 0, (rawError) =>
-                this.handleRawError(
-                  rawError,
-                  fieldNodes,
-                  path,
-                  returnType,
-                  responseNode.errors
-                )
-              );
-            }
-            return completed;
-          } catch (rawError) {
-            return this.handleRawError(
-              rawError,
-              fieldNodes,
-              path,
-              returnType,
-              responseNode.errors
-            );
-          }
-        }
-        buildResolveInfo(exeContext, fieldContext, path) {
-          const { fieldName, fieldNodes, returnType, parentType } =
-            fieldContext;
-          const { _schema: schema, _executorSchema: executorSchema } = this;
-          const { fragments, rootValue, operation, variableValues } =
-            exeContext;
-          return {
-            fieldName,
-            fieldNodes,
-            returnType,
-            parentType,
-            path,
-            schema,
-            executorSchema,
-            fragments,
-            rootValue,
-            operation,
-            variableValues,
-          };
-        }
-        toLocatedError(rawError, fieldNodes, path) {
-          return locatedError(toError(rawError), fieldNodes, pathToArray(path));
-        }
-        handleRawError(rawError, fieldNodes, path, returnType, errors2) {
-          const error2 = this.toLocatedError(rawError, fieldNodes, path);
-          if (this._executorSchema.isNonNullType(returnType)) {
-            throw error2;
-          }
-          errors2.push(error2);
-          return null;
-        }
-        buildNullableValueCompleter(valueCompleter) {
-          return (
-            exeContext,
-            fieldContext,
-            info2,
-            path,
-            result2,
-            responseNode
-          ) => {
-            if (result2 instanceof Error) {
-              throw result2;
-            }
-            if (result2 == null) {
-              return null;
-            }
-            return valueCompleter(
-              exeContext,
-              fieldContext,
-              info2,
-              path,
-              result2,
-              responseNode
-            );
-          };
-        }
-        _getValueCompleter(returnType) {
-          if (this._executorSchema.isNonNullType(returnType)) {
-            return (
-              exeContext,
-              fieldContext,
-              info2,
-              path,
-              result2,
-              responseNode
-            ) => {
-              const innerValueCompleter = this.getValueCompleter(
-                returnType.ofType
-              );
-              const completed = innerValueCompleter(
-                exeContext,
-                fieldContext,
-                info2,
-                path,
-                result2,
-                responseNode
-              );
-              if (completed === null) {
-                throw new Error(
-                  `Cannot return null for non-nullable field ${info2.parentType.name}.${info2.fieldName}.`
-                );
-              }
-              return completed;
-            };
-          }
-          if (this._executorSchema.isListType(returnType)) {
-            return this.buildNullableValueCompleter(
-              (exeContext, fieldContext, info2, path, result2, responseNode) =>
-                this.completeListValue(
-                  exeContext,
-                  returnType,
-                  fieldContext,
-                  info2,
-                  path,
-                  result2,
-                  responseNode
-                )
-            );
-          }
-          if (this._executorSchema.isLeafType(returnType)) {
-            return this.buildNullableValueCompleter(
-              (
-                _exeContext,
-                _fieldContext,
-                _info,
-                _path,
-                result2,
-                _responseNode
-              ) => this.completeLeafValue(returnType, result2)
-            );
-          }
-          if (this._executorSchema.isAbstractType(returnType)) {
-            return this.buildNullableValueCompleter(
-              (exeContext, fieldContext, info2, path, result2, responseNode) =>
-                this.completeAbstractValue(
-                  exeContext,
-                  returnType,
-                  fieldContext,
-                  info2,
-                  path,
-                  result2,
-                  responseNode
-                )
-            );
-          }
-          if (this._executorSchema.isObjectType(returnType)) {
-            return this.buildNullableValueCompleter(
-              (exeContext, fieldContext, info2, path, result2, responseNode) =>
-                this.completeObjectValue(
-                  exeContext,
-                  returnType,
-                  fieldContext,
-                  info2,
-                  path,
-                  result2,
-                  responseNode
-                )
-            );
-          }
-          invariant(
-            false,
-            "Cannot complete value of unexpected output type: " +
-              inspect(returnType)
-          );
-        }
-        completeListValue(
-          exeContext,
-          returnType,
-          fieldContext,
-          info2,
-          path,
-          result2,
-          responseNode
-        ) {
-          const itemType = returnType.ofType;
-          const valueCompleter = this.getValueCompleter(itemType);
-          const completedResults = [];
-          const promises = [];
-          const stream = exeContext.getStreamValues(
-            exeContext.variableValues,
-            fieldContext
-          );
-          if (isAsyncIterable(result2)) {
-            const iterator2 = result2[Symbol.asyncIterator]();
-            return this.completeAsyncIteratorValue(
-              exeContext,
-              itemType,
-              fieldContext,
-              info2,
-              valueCompleter,
-              path,
-              iterator2,
-              responseNode,
-              stream,
-              completedResults,
-              promises
-            );
-          }
-          if (!isIterableObject(result2)) {
-            throw new GraphQLError(
-              `Expected Iterable, but did not find one for field "${info2.parentType.name}.${info2.fieldName}".`
-            );
-          }
-          const iterator = result2[Symbol.iterator]();
-          this.completeIteratorValue(
-            exeContext,
-            itemType,
-            fieldContext,
-            info2,
-            valueCompleter,
-            path,
-            iterator,
-            responseNode,
-            stream,
-            completedResults,
-            promises
-          );
-          return promises.length
-            ? resolveAfterAll(completedResults, promises)
-            : completedResults;
-        }
-        getStreamValues(variableValues, fieldContext) {
-          const stream = getDirectiveValues(
-            this._executorSchema,
-            GraphQLStreamDirective,
-            fieldContext.initialFieldNode,
-            variableValues
-          );
-          if (!stream) {
-            return;
-          }
-          if (stream.if === false) {
-            return;
-          }
-          const { initialCount, maxChunkSize, maxInterval, inParallel, label } =
-            stream;
-          typeof initialCount === "number" ||
-            invariant(false, "initialCount must be a number");
-          initialCount >= 0 ||
-            invariant(
-              false,
-              "initialCount must be an integer greater than or equal to zero"
-            );
-          typeof maxChunkSize === "number" ||
-            invariant(false, "maxChunkSize must be a number");
-          maxChunkSize >= 1 ||
-            invariant(
-              false,
-              "maxChunkSize must be an integer greater than or equal to one"
-            );
-          if (maxInterval != null) {
-            typeof maxInterval === "number" ||
-              invariant(false, "maxInterval must be a number");
-            maxInterval >= 0 ||
-              invariant(
-                false,
-                "maxInterval must be an integer greater than or equal to zero"
-              );
-          }
-          return {
-            initialCount,
-            maxChunkSize,
-            maxInterval,
-            inParallel: inParallel === true,
-            label: typeof label === "string" ? label : void 0,
-          };
-        }
-        completeIteratorValue(
-          exeContext,
-          itemType,
-          fieldContext,
-          info2,
-          valueCompleter,
-          path,
-          iterator,
-          responseNode,
-          stream,
-          completedResults,
-          promises
-        ) {
-          if (stream) {
-            this.completeIteratorValueWithStream(
-              exeContext,
-              itemType,
-              fieldContext,
-              info2,
-              valueCompleter,
-              path,
-              iterator,
-              responseNode,
-              stream,
-              completedResults,
-              0,
-              promises
-            );
-            return;
-          }
-          this.completeIteratorValueWithoutStream(
-            exeContext,
-            itemType,
-            fieldContext,
-            info2,
-            valueCompleter,
-            path,
-            iterator,
-            responseNode,
-            completedResults,
-            0,
-            promises
-          );
-        }
-        onNewBundleContext(state, context, responseNode) {
-          state.pendingPushes++;
-          state.pendingStreamResults--;
-          context.responseNodes.push(responseNode);
-          return context;
-        }
-        onSubsequentResponseNode(state, context, responseNode) {
-          state.pendingStreamResults--;
-          context.responseNodes.push(responseNode);
-        }
-        createBundler(
-          exeContext,
-          parentResponseNode,
-          initialCount,
-          maxChunkSize,
-          maxInterval,
-          resultToNewDataContext,
-          indexToNewErrorContext,
-          onSubsequentData,
-          onSubsequentError,
-          dataContextToIncrementalResult,
-          errorContextToIncrementalResult
-        ) {
-          return new Bundler({
-            initialIndex: initialCount,
-            maxBundleSize: maxChunkSize,
-            maxInterval,
-            createDataBundleContext: (index, result2) =>
-              this.onNewBundleContext(
-                exeContext.state,
-                resultToNewDataContext(index, result2),
-                result2.responseNode
-              ),
-            createErrorBundleContext: (index, responseNode) =>
-              this.onNewBundleContext(
-                exeContext.state,
-                indexToNewErrorContext(index),
-                responseNode
-              ),
-            onSubsequentData: (index, result2, context) => {
-              this.onSubsequentResponseNode(
-                exeContext.state,
-                context,
-                result2.responseNode
-              );
-              onSubsequentData(index, result2, context);
-            },
-            onSubsequentError: (index, responseNode, context) => {
-              this.onSubsequentResponseNode(
-                exeContext.state,
-                context,
-                responseNode
-              );
-              onSubsequentError(index, context);
-            },
-            onDataBundle: (context) =>
-              exeContext.publisher.queue(
-                context.responseNodes,
-                dataContextToIncrementalResult(context),
-                parentResponseNode
-              ),
-            onErrorBundle: (context) =>
-              exeContext.publisher.queue(
-                context.responseNodes,
-                errorContextToIncrementalResult(context),
-                parentResponseNode
-              ),
-          });
-        }
-        createStreamContext(
-          exeContext,
-          initialCount,
-          maxChunkSize,
-          maxInterval,
-          inParallel,
-          path,
-          label,
-          parentResponseNode
-        ) {
-          if (maxChunkSize === 1) {
-            const bundler = this.createBundler(
-              exeContext,
-              parentResponseNode,
-              initialCount,
-              maxChunkSize,
-              maxInterval,
-              (index, result2) => ({
-                responseNodes: [],
-                parentResponseNode,
-                result: result2.data,
-                atIndex: index,
-              }),
-              (index) => ({
-                responseNodes: [],
-                parentResponseNode,
-                atIndex: index,
-              }),
-              () => {},
-              () => {},
-              (context) => ({
-                responseContext: context,
-                data: context.result,
-                path: addPath(path, context.atIndex, void 0),
-                label,
-              }),
-              (context) => ({
-                responseContext: context,
-                data: null,
-                path: addPath(path, context.atIndex, void 0),
-                label,
-              })
-            );
-            return {
-              initialCount,
-              path,
-              bundler: inParallel
-                ? bundler
-                : getSequentialBundler(initialCount, bundler),
-            };
-          }
-          if (inParallel) {
-            return {
-              initialCount,
-              path,
-              bundler: this.createBundler(
-                exeContext,
-                parentResponseNode,
-                initialCount,
-                maxChunkSize,
-                maxInterval,
-                (index, result2) => ({
-                  responseNodes: [],
-                  parentResponseNode,
-                  atIndices: [index],
-                  results: [result2.data],
-                }),
-                (index) => ({
-                  responseNodes: [],
-                  parentResponseNode,
-                  atIndices: [index],
-                }),
-                (index, result2, context) => {
-                  context.results.push(result2.data);
-                  context.atIndices.push(index);
-                },
-                (index, context) => {
-                  context.atIndices.push(index);
-                },
-                (context) => ({
-                  responseContext: context,
-                  data: context.results,
-                  path,
-                  atIndices: context.atIndices,
-                  label,
-                }),
-                (context) => ({
-                  responseContext: context,
-                  data: null,
-                  path,
-                  atIndices: context.atIndices,
-                  label,
-                })
-              ),
-            };
-          }
-          return {
-            initialCount,
-            path,
-            bundler: getSequentialBundler(
-              initialCount,
-              this.createBundler(
-                exeContext,
-                parentResponseNode,
-                initialCount,
-                maxChunkSize,
-                maxInterval,
-                (index, result2) => ({
-                  responseNodes: [],
-                  parentResponseNode,
-                  atIndex: index,
-                  results: [result2.data],
-                }),
-                (index) => ({
-                  responseNodes: [],
-                  parentResponseNode,
-                  atIndex: index,
-                }),
-                (_index, result2, context) => {
-                  context.results.push(result2.data);
-                },
-                () => {},
-                (context) => ({
-                  responseContext: context,
-                  data: context.results,
-                  path,
-                  atIndex: context.atIndex,
-                  label,
-                }),
-                (context) => ({
-                  responseContext: context,
-                  data: null,
-                  path,
-                  atIndex: context.atIndex,
-                  label,
-                })
-              )
-            ),
-          };
-        }
-        completeIteratorValueWithStream(
-          exeContext,
-          itemType,
-          fieldContext,
-          info2,
-          valueCompleter,
-          path,
-          iterator,
-          responseNode,
-          stream,
-          completedResults,
-          _index,
-          promises
-        ) {
-          const initialCount = stream.initialCount;
-          let index = _index;
-          while (true) {
-            if (index >= initialCount) {
-              const { maxChunkSize, maxInterval, inParallel, label } = stream;
-              const streamContext = this.createStreamContext(
-                exeContext,
-                initialCount,
-                maxChunkSize,
-                maxInterval,
-                inParallel,
-                path,
-                label,
-                responseNode
-              );
-              const nextIndex = this.addIteratorValue(
-                index,
-                iterator,
-                exeContext,
-                itemType,
-                fieldContext,
-                info2,
-                valueCompleter,
-                streamContext
-              );
-              streamContext.bundler.setTotal(nextIndex);
-              break;
-            }
-            const iteration = iterator.next();
-            if (iteration.done) {
-              return;
-            }
-            const itemPath = addPath(path, index, void 0);
-            this.completeListItemValue(
-              completedResults,
-              index,
-              promises,
-              iteration.value,
-              exeContext,
-              itemType,
-              valueCompleter,
-              fieldContext,
-              info2,
-              itemPath,
-              responseNode
-            );
-            index++;
-          }
-        }
-        completeIteratorValueWithoutStream(
-          exeContext,
-          itemType,
-          fieldContext,
-          info2,
-          valueCompleter,
-          path,
-          iterator,
-          responseNode,
-          completedResults,
-          _index,
-          promises
-        ) {
-          let index = _index;
-          while (true) {
-            const iteration = iterator.next();
-            if (iteration.done) {
-              return index;
-            }
-            const itemPath = addPath(path, index, void 0);
-            this.completeListItemValue(
-              completedResults,
-              index,
-              promises,
-              iteration.value,
-              exeContext,
-              itemType,
-              valueCompleter,
-              fieldContext,
-              info2,
-              itemPath,
-              responseNode
-            );
-            index++;
-          }
-        }
-        async completeAsyncIteratorValue(
-          exeContext,
-          itemType,
-          fieldContext,
-          info2,
-          valueCompleter,
-          path,
-          iterator,
-          responseNode,
-          stream,
-          completedResults,
-          promises
-        ) {
-          if (stream) {
-            await this.completeAsyncIteratorValueWithStream(
-              exeContext,
-              itemType,
-              fieldContext,
-              info2,
-              valueCompleter,
-              path,
-              iterator,
-              responseNode,
-              stream,
-              completedResults,
-              promises
-            );
-          } else {
-            await this.completeAsyncIteratorValueWithoutStream(
-              exeContext,
-              itemType,
-              fieldContext,
-              info2,
-              valueCompleter,
-              path,
-              iterator,
-              responseNode,
-              completedResults,
-              promises
-            );
-          }
-          return promises.length
-            ? resolveAfterAll(completedResults, promises)
-            : completedResults;
-        }
-        async completeAsyncIteratorValueWithStream(
-          exeContext,
-          itemType,
-          fieldContext,
-          info2,
-          valueCompleter,
-          path,
-          iterator,
-          responseNode,
-          stream,
-          completedResults,
-          promises
-        ) {
-          const initialCount = stream.initialCount;
-          let index = 0;
-          try {
-            while (true) {
-              if (index >= initialCount) {
-                const { maxChunkSize, maxInterval, inParallel, label } = stream;
-                const streamContext = this.createStreamContext(
-                  exeContext,
-                  initialCount,
-                  maxChunkSize,
-                  maxInterval,
-                  inParallel,
-                  path,
-                  label,
-                  responseNode
-                );
-                this.addAsyncIteratorValue(
-                  index,
-                  iterator,
-                  exeContext,
-                  itemType,
-                  fieldContext,
-                  info2,
-                  valueCompleter,
-                  streamContext
-                );
-                return;
-              }
-              const iteration = await iterator.next();
-              if (iteration.done) {
-                break;
-              }
-              const itemPath = addPath(path, index, void 0);
-              this.completeListItemValue(
-                completedResults,
-                index,
-                promises,
-                iteration.value,
-                exeContext,
-                itemType,
-                valueCompleter,
-                fieldContext,
-                info2,
-                itemPath,
-                responseNode
-              );
-              index++;
-            }
-          } catch (rawError) {
-            const itemPath = addPath(path, index, void 0);
-            completedResults.push(
-              this.handleRawError(
-                rawError,
-                fieldContext.fieldNodes,
-                itemPath,
-                itemType,
-                responseNode.errors
-              )
-            );
-          }
-        }
-        async completeAsyncIteratorValueWithoutStream(
-          exeContext,
-          itemType,
-          fieldContext,
-          info2,
-          valueCompleter,
-          path,
-          iterator,
-          responseNode,
-          completedResults,
-          promises
-        ) {
-          let index = 0;
-          try {
-            while (true) {
-              const iteration = await iterator.next();
-              if (iteration.done) {
-                break;
-              }
-              const itemPath = addPath(path, index, void 0);
-              this.completeListItemValue(
-                completedResults,
-                index,
-                promises,
-                iteration.value,
-                exeContext,
-                itemType,
-                valueCompleter,
-                fieldContext,
-                info2,
-                itemPath,
-                responseNode
-              );
-              index++;
-            }
-          } catch (rawError) {
-            const itemPath = addPath(path, index, void 0);
-            completedResults.push(
-              this.handleRawError(
-                rawError,
-                fieldContext.fieldNodes,
-                itemPath,
-                itemType,
-                responseNode.errors
-              )
-            );
-          }
-        }
-        completeListItemValue(
-          completedResults,
-          index,
-          promises,
-          item,
-          exeContext,
-          itemType,
-          valueCompleter,
-          fieldContext,
-          info2,
-          itemPath,
-          responseNode
-        ) {
-          try {
-            let completedItem;
-            if (isPromise(item)) {
-              completedItem = item.then((resolved) =>
-                valueCompleter(
-                  exeContext,
-                  fieldContext,
-                  info2,
-                  itemPath,
-                  resolved,
-                  responseNode
-                )
-              );
-            } else {
-              completedItem = valueCompleter(
-                exeContext,
-                fieldContext,
-                info2,
-                itemPath,
-                item,
-                responseNode
-              );
-            }
-            completedResults[index] = completedItem;
-            if (!isPromise(completedItem)) {
-              return;
-            }
-            const promise = completedItem
-              .then(void 0, (rawError) =>
-                this.handleRawError(
-                  rawError,
-                  fieldContext.fieldNodes,
-                  itemPath,
-                  itemType,
-                  responseNode.errors
-                )
-              )
-              .then((resolved) => {
-                completedResults[index] = resolved;
-              });
-            promises.push(promise);
-          } catch (rawError) {
-            completedResults[index] = this.handleRawError(
-              rawError,
-              fieldContext.fieldNodes,
-              itemPath,
-              itemType,
-              responseNode.errors
-            );
-          }
-        }
-        completeLeafValue(returnType, result2) {
-          const serializedResult = returnType.serialize(result2);
-          if (serializedResult == null) {
-            throw new Error(
-              `Expected \`${inspect(returnType)}.serialize(${inspect(
-                result2
-              )})\` to return non-nullable value, returned: ${inspect(
-                serializedResult
-              )}`
-            );
-          }
-          return serializedResult;
-        }
-        completeAbstractValue(
-          exeContext,
-          returnType,
-          fieldContext,
-          info2,
-          path,
-          result2,
-          responseNode
-        ) {
-          var _returnType$resolveTy;
-          const resolveTypeFn =
-            (_returnType$resolveTy = returnType.resolveType) !== null &&
-            _returnType$resolveTy !== void 0
-              ? _returnType$resolveTy
-              : exeContext.typeResolver;
-          const contextValue = exeContext.contextValue;
-          const runtimeType = resolveTypeFn(
-            result2,
-            contextValue,
-            info2,
-            returnType
-          );
-          if (isPromise(runtimeType)) {
-            return runtimeType.then((resolvedRuntimeType) =>
-              this.completeObjectValue(
-                exeContext,
-                this.ensureValidRuntimeType(
-                  resolvedRuntimeType,
-                  returnType,
-                  fieldContext,
-                  result2
-                ),
-                fieldContext,
-                info2,
-                path,
-                result2,
-                responseNode
-              )
-            );
-          }
-          return this.completeObjectValue(
-            exeContext,
-            this.ensureValidRuntimeType(
-              runtimeType,
-              returnType,
-              fieldContext,
-              result2
-            ),
-            fieldContext,
-            info2,
-            path,
-            result2,
-            responseNode
-          );
-        }
-        ensureValidRuntimeType(
-          runtimeTypeOrName,
-          returnType,
-          fieldContext,
-          result2
-        ) {
-          if (runtimeTypeOrName == null) {
-            throw new GraphQLError(
-              `Abstract type "${returnType.name}" must resolve to an Object type at runtime for field "${fieldContext.parentType.name}.${fieldContext.fieldName}". Either the "${returnType.name}" type should provide a "resolveType" function or each possible type should provide an "isTypeOf" function.`,
-              fieldContext.fieldNodes
-            );
-          }
-          const runtimeTypeName =
-            typeof runtimeTypeOrName === "object" &&
-            this._executorSchema.isNamedType(runtimeTypeOrName)
-              ? runtimeTypeOrName.name
-              : runtimeTypeOrName;
-          if (typeof runtimeTypeName !== "string") {
-            throw new GraphQLError(
-              `Abstract type "${
-                returnType.name
-              }" must resolve to an Object type at runtime for field "${
-                fieldContext.parentType.name
-              }.${fieldContext.fieldName}" with value ${inspect(
-                result2
-              )}, received "${inspect(runtimeTypeName)}".`
-            );
-          }
-          const runtimeType =
-            this._executorSchema.getNamedType(runtimeTypeName);
-          if (runtimeType == null) {
-            throw new GraphQLError(
-              `Abstract type "${returnType.name}" was resolved to a type "${runtimeTypeName}" that does not exist inside the schema.`,
-              fieldContext.fieldNodes
-            );
-          }
-          if (!this._executorSchema.isObjectType(runtimeType)) {
-            throw new GraphQLError(
-              `Abstract type "${returnType.name}" was resolved to a non-object type "${runtimeTypeName}".`,
-              fieldContext.fieldNodes
-            );
-          }
-          if (!this._executorSchema.isSubType(returnType, runtimeType)) {
-            throw new GraphQLError(
-              `Runtime Object type "${runtimeType.name}" is not a possible type for "${returnType.name}".`,
-              fieldContext.fieldNodes
-            );
-          }
-          return runtimeType;
-        }
-        completeObjectValue(
-          exeContext,
-          returnType,
-          fieldContext,
-          info2,
-          path,
-          result2,
-          responseNode
-        ) {
-          if (returnType.isTypeOf) {
-            const isTypeOf = returnType.isTypeOf(
-              result2,
-              exeContext.contextValue,
-              info2
-            );
-            if (isPromise(isTypeOf)) {
-              return isTypeOf.then((resolvedIsTypeOf) => {
-                if (!resolvedIsTypeOf) {
-                  throw this.invalidReturnTypeError(
-                    returnType,
-                    result2,
-                    fieldContext.fieldNodes
-                  );
-                }
-                return this.collectAndExecuteSubfields(
-                  exeContext,
-                  returnType,
-                  fieldContext,
-                  path,
-                  result2,
-                  responseNode
-                );
-              });
-            }
-            if (!isTypeOf) {
-              throw this.invalidReturnTypeError(
-                returnType,
-                result2,
-                fieldContext.fieldNodes
-              );
-            }
-          }
-          return this.collectAndExecuteSubfields(
-            exeContext,
-            returnType,
-            fieldContext,
-            path,
-            result2,
-            responseNode
-          );
-        }
-        invalidReturnTypeError(returnType, result2, fieldNodes) {
-          return new GraphQLError(
-            `Expected value of type "${returnType.name}" but got: ${inspect(
-              result2
-            )}.`,
-            fieldNodes
-          );
-        }
-        collectAndExecuteSubfields(
-          exeContext,
-          returnType,
-          fieldContext,
-          path,
-          result2,
-          responseNode
-        ) {
-          const { subFieldCollector } = exeContext;
-          const { fields: subFieldNodes, patches: subPatches } =
-            subFieldCollector(returnType, fieldContext.fieldNodes);
-          const subFields = this.executeFields(
-            exeContext,
-            returnType,
-            result2,
-            path,
-            subFieldNodes,
-            responseNode
-          );
-          this.addPatches(
-            exeContext,
-            subPatches,
-            returnType,
-            result2,
-            path,
-            responseNode
-          );
-          return subFields;
-        }
-        _getFieldDef(fieldName, parentType) {
-          const fieldDef = parentType.getFields()[fieldName];
-          if (fieldDef) {
-            return fieldDef;
-          }
-          if (
-            fieldName === SchemaMetaFieldDef.name &&
-            this._executorSchema.getRootType("query") === parentType
-          ) {
-            return SchemaMetaFieldDef;
-          } else if (
-            fieldName === TypeMetaFieldDef.name &&
-            this._executorSchema.getRootType("query") === parentType
-          ) {
-            return TypeMetaFieldDef;
-          } else if (
-            fieldName === DirectiveMetaFieldDef.name &&
-            this._executorSchema.getRootType("query") === parentType
-          ) {
-            return DirectiveMetaFieldDef;
-          } else if (fieldName === TypeNameMetaFieldDef.name) {
-            return TypeNameMetaFieldDef;
-          }
-        }
-        _getFieldContext(parentType, fieldNodes) {
-          const initialFieldNode = fieldNodes[0];
-          const fieldName = initialFieldNode.name.value;
-          const fieldDef = this._getFieldDef(fieldName, parentType);
-          if (!fieldDef) {
-            return;
-          }
-          return {
-            fieldDef,
-            initialFieldNode,
-            fieldName: fieldDef.name,
-            fieldNodes,
-            returnType: fieldDef.type,
-            parentType,
-          };
-        }
-        async executeSubscriptionImpl(exeContext) {
-          return this.executeOperationImpl(
-            exeContext,
-            this.executeRootSubscriptionFields.bind(this),
-            this.buildSubscribeResponse.bind(this)
-          );
-        }
-        async executeRootSubscriptionFields(
-          exeContext,
-          parentType,
-          sourceValue,
-          path,
-          fields,
-          responseNode
-        ) {
-          const [responseName, fieldNodes] = [...fields.entries()][0];
-          const fieldPath = addPath(path, responseName, parentType.name);
-          return this.executeRootSubscriptionField(
-            exeContext,
-            parentType,
-            sourceValue,
-            fieldNodes,
-            fieldPath,
-            responseNode
-          );
-        }
-        buildCreateSourceEventStreamResponse(exeContext, eventStream) {
-          const { rootResponseNode } = exeContext;
-          const errors2 = rootResponseNode.errors;
-          if (errors2.length) {
-            return {
-              errors: errors2,
-            };
-          }
-          if (!isAsyncIterable(eventStream)) {
-            throw new Error(
-              `Subscription field must return Async Iterable. Received: ${inspect(
-                eventStream
-              )}.`
-            );
-          }
-          return eventStream;
-        }
-        buildSubscribeResponse(exeContext, _eventStream) {
-          const eventStream = this.buildCreateSourceEventStreamResponse(
-            exeContext,
-            _eventStream
-          );
-          if (!isAsyncIterable(eventStream)) {
-            return eventStream;
-          }
-          const mapSourceToResponse = (payload) => {
-            const perPayloadExecutionContext =
-              this.buildPerPayloadExecutionContext(exeContext, payload);
-            return this.executeQueryImpl(perPayloadExecutionContext);
-          };
-          return flattenAsyncIterable(
-            mapAsyncIterable(eventStream, mapSourceToResponse)
-          );
-        }
-        async createSourceEventStreamImpl(exeContext) {
-          return this.executeOperationImpl(
-            exeContext,
-            this.executeRootSubscriptionFields.bind(this),
-            this.buildCreateSourceEventStreamResponse.bind(this)
-          );
-        }
-        async executeRootSubscriptionField(
-          exeContext,
-          parentType,
-          sourceValue,
-          fieldNodes,
-          fieldPath,
-          responseNode
-        ) {
-          const fieldContext = this.getFieldContext(parentType, fieldNodes);
-          if (!fieldContext) {
-            const fieldName = fieldNodes[0].name.value;
-            responseNode.errors.push(
-              new GraphQLError(
-                `The subscription field "${fieldName}" is not defined.`,
-                fieldNodes
-              )
-            );
-            return null;
-          }
-          const info2 = this.buildResolveInfo(
-            exeContext,
-            fieldContext,
-            fieldPath
-          );
-          try {
-            const eventStream = await exeContext.resolveField(
-              exeContext,
-              fieldContext,
-              sourceValue,
-              info2
-            );
-            if (eventStream instanceof Error) {
-              throw eventStream;
-            }
-            return eventStream;
-          } catch (rawError) {
-            responseNode.errors.push(
-              this.toLocatedError(rawError, fieldNodes, fieldPath)
-            );
-            return null;
-          }
-        }
-        addPatches(
-          exeContext,
-          patches,
-          parentType,
-          source,
-          path,
-          parentResponseNode
-        ) {
-          const { state, publisher } = exeContext;
-          for (const patch of patches) {
-            state.pendingPushes++;
-            const { label, fields: patchFields } = patch;
-            const errors2 = [];
-            const responseNode = {
-              errors: errors2,
-            };
-            const responseContext = {
-              responseNodes: [responseNode],
-              parentResponseNode,
-            };
-            Promise.resolve(source)
-              .then(() =>
-                this.executeFields(
-                  exeContext,
-                  parentType,
-                  source,
-                  path,
-                  patchFields,
-                  responseNode
-                )
-              )
-              .then(
-                (data) =>
-                  publisher.queue(
-                    responseContext.responseNodes,
-                    {
-                      responseContext,
-                      data,
-                      path,
-                      label,
-                    },
-                    responseContext.parentResponseNode
-                  ),
-                (error2) => {
-                  errors2.push(error2);
-                  publisher.queue(
-                    responseContext.responseNodes,
-                    {
-                      responseContext,
-                      data: null,
-                      path,
-                      label,
-                    },
-                    responseContext.parentResponseNode
-                  );
-                }
-              );
-          }
-        }
-        addIteratorValue(
-          initialIndex,
-          iterator,
-          exeContext,
-          itemType,
-          fieldContext,
-          info2,
-          valueCompleter,
-          streamContext
-        ) {
-          let index = initialIndex;
-          let iteration = iterator.next();
-          while (!iteration.done) {
-            this.addValue(
-              iteration.value,
-              exeContext,
-              itemType,
-              fieldContext,
-              info2,
-              valueCompleter,
-              index,
-              streamContext
-            );
-            index++;
-            iteration = iterator.next();
-          }
-          return index;
-        }
-        async addAsyncIteratorValue(
-          initialIndex,
-          iterator,
-          exeContext,
-          itemType,
-          fieldContext,
-          info2,
-          valueCompleter,
-          streamContext
-        ) {
-          exeContext.state.iterators.add(iterator);
-          let index = initialIndex;
-          try {
-            let iteration = await iterator.next();
-            while (!iteration.done) {
-              this.addValue(
-                iteration.value,
-                exeContext,
-                itemType,
-                fieldContext,
-                info2,
-                valueCompleter,
-                index,
-                streamContext
-              );
-              index++;
-              iteration = await iterator.next();
-            }
-            streamContext.bundler.setTotal(index);
-          } catch (rawError) {
-            exeContext.state.pendingStreamResults++;
-            this.handleRawStreamError(
-              fieldContext,
-              itemType,
-              streamContext,
-              rawError,
-              index
-            );
-            streamContext.bundler.setTotal(index + 1);
-          }
-          this.closeAsyncIterator(exeContext, iterator);
-        }
-        handleRawStreamError(
-          fieldContext,
-          itemType,
-          streamContext,
-          rawError,
-          index
-        ) {
-          const { path } = streamContext;
-          const itemPath = addPath(path, index, void 0);
-          const error2 = this.toLocatedError(
-            rawError,
-            fieldContext.fieldNodes,
-            itemPath
-          );
-          if (this._executorSchema.isNonNullType(itemType)) {
-            streamContext.bundler.queueError(index, {
-              errors: [error2],
-            });
-          } else {
-            streamContext.bundler.queueData(index, {
-              responseNode: {
-                errors: [error2],
-              },
-              data: null,
-            });
-          }
-        }
-        addValue(
-          value,
-          exeContext,
-          itemType,
-          fieldContext,
-          info2,
-          valueCompleter,
-          index,
-          streamContext
-        ) {
-          const itemPath = addPath(streamContext.path, index, void 0);
-          const responseNode = {
-            errors: [],
-          };
-          exeContext.state.pendingStreamResults++;
-          Promise.resolve(value)
-            .then((resolved) =>
-              valueCompleter(
-                exeContext,
-                fieldContext,
-                info2,
-                itemPath,
-                resolved,
-                responseNode
-              )
-            )
-            .then(
-              (data) =>
-                streamContext.bundler.queueData(index, {
-                  responseNode,
-                  data,
-                }),
-              (rawError) =>
-                this.handleRawStreamError(
-                  fieldContext,
-                  itemType,
-                  streamContext,
-                  rawError,
-                  index
-                )
-            );
-        }
-        closeAsyncIterator(exeContext, iterator) {
-          const { state, publisher } = exeContext;
-          state.iterators.delete(iterator);
-          if (!this.hasNext(exeContext.state)) {
-            publisher.stop({
-              hasNext: false,
-            });
-          }
-        }
-        hasNext(state) {
-          return (
-            state.pendingPushes > 0 ||
-            state.pendingStreamResults > 0 ||
-            state.iterators.size > 0
-          );
-        }
-        collectFieldsImpl(
-          fragments,
-          variableValues,
-          getDeferValues,
-          runtimeType,
-          selectionSet,
-          fields,
-          patches,
-          visitedFragmentNames
-        ) {
-          for (const selection of selectionSet.selections) {
-            switch (selection.kind) {
-              case Kind.FIELD: {
-                if (!this.shouldIncludeNode(variableValues, selection)) {
-                  continue;
-                }
-                const name2 = this.getFieldEntryKey(selection);
-                const fieldList = fields.get(name2);
-                if (fieldList !== void 0) {
-                  fields.set(name2, this.updateFieldList(fieldList, selection));
-                } else {
-                  fields.set(name2, this.createFieldList(selection));
-                }
-                break;
-              }
-              case Kind.INLINE_FRAGMENT: {
-                if (
-                  !this.shouldIncludeNode(variableValues, selection) ||
-                  !this.doesFragmentConditionMatch(selection, runtimeType)
-                ) {
-                  continue;
-                }
-                const defer = getDeferValues(variableValues, selection);
-                if (defer) {
-                  const patchFields = /* @__PURE__ */ new Map();
-                  this.collectFieldsImpl(
-                    fragments,
-                    variableValues,
-                    getDeferValues,
-                    runtimeType,
-                    selection.selectionSet,
-                    patchFields,
-                    patches,
-                    visitedFragmentNames
-                  );
-                  patches.push({
-                    label: defer.label,
-                    fields: patchFields,
-                  });
-                } else {
-                  this.collectFieldsImpl(
-                    fragments,
-                    variableValues,
-                    getDeferValues,
-                    runtimeType,
-                    selection.selectionSet,
-                    fields,
-                    patches,
-                    visitedFragmentNames
-                  );
-                }
-                break;
-              }
-              case Kind.FRAGMENT_SPREAD: {
-                const fragName = selection.name.value;
-                if (!this.shouldIncludeNode(variableValues, selection)) {
-                  continue;
-                }
-                const defer = getDeferValues(variableValues, selection);
-                if (visitedFragmentNames.has(fragName) && !defer) {
-                  continue;
-                }
-                const fragment = fragments[fragName];
-                if (
-                  !fragment ||
-                  !this.doesFragmentConditionMatch(fragment, runtimeType)
-                ) {
-                  continue;
-                }
-                if (defer) {
-                  const patchFields = /* @__PURE__ */ new Map();
-                  this.collectFieldsImpl(
-                    fragments,
-                    variableValues,
-                    getDeferValues,
-                    runtimeType,
-                    fragment.selectionSet,
-                    patchFields,
-                    patches,
-                    visitedFragmentNames
-                  );
-                  patches.push({
-                    label: defer.label,
-                    fields: patchFields,
-                  });
-                } else {
-                  visitedFragmentNames.add(fragName);
-                  this.collectFieldsImpl(
-                    fragments,
-                    variableValues,
-                    getDeferValues,
-                    runtimeType,
-                    fragment.selectionSet,
-                    fields,
-                    patches,
-                    visitedFragmentNames
-                  );
-                }
-                break;
-              }
-            }
-          }
-        }
-        getDeferValues(variableValues, node) {
-          const defer = getDirectiveValues(
-            this._executorSchema,
-            GraphQLDeferDirective,
-            node,
-            variableValues
-          );
-          if (!defer) {
-            return;
-          }
-          if (defer.if === false) {
-            return;
-          }
-          return {
-            label: typeof defer.label === "string" ? defer.label : void 0,
-          };
-        }
-        shouldIncludeNode(variableValues, node) {
-          const skip2 = getDirectiveValues(
-            this._executorSchema,
-            GraphQLSkipDirective,
-            node,
-            variableValues
-          );
-          if (
-            (skip2 === null || skip2 === void 0 ? void 0 : skip2.if) === true
-          ) {
-            return false;
-          }
-          const include = getDirectiveValues(
-            this._executorSchema,
-            GraphQLIncludeDirective,
-            node,
-            variableValues
-          );
-          if (
-            (include === null || include === void 0 ? void 0 : include.if) ===
-            false
-          ) {
-            return false;
-          }
-          return true;
-        }
-        doesFragmentConditionMatch(fragment, type2) {
-          const typeConditionNode = fragment.typeCondition;
-          if (!typeConditionNode) {
-            return true;
-          }
-          const conditionalType =
-            this._executorSchema.getType(typeConditionNode);
-          if (conditionalType === type2) {
-            return true;
-          }
-          if (
-            conditionalType &&
-            this._executorSchema.isAbstractType(conditionalType)
-          ) {
-            return this._executorSchema.isSubType(conditionalType, type2);
-          }
-          return false;
-        }
-        getFieldEntryKey(node) {
-          return node.alias ? node.alias.value : node.name.value;
-        }
-      }
-      const defaultFieldResolver = function (
-        source,
-        args,
-        contextValue,
-        info2
-      ) {
-        if (isObjectLike(source) || typeof source === "function") {
-          const property = source[info2.fieldName];
-          if (typeof property === "function") {
-            return source[info2.fieldName](args, contextValue, info2);
-          }
-          return property;
-        }
-      };
-      const defaultTypeResolver = function (
-        value,
-        contextValue,
-        info2,
-        abstractType
-      ) {
-        if (isObjectLike(value) && typeof value.__typename === "string") {
-          return value.__typename;
-        }
-        const possibleTypes =
-          info2.executorSchema.getPossibleTypes(abstractType);
-        const promisedIsTypeOfResults = [];
-        for (let i = 0; i < possibleTypes.length; i++) {
-          const type2 = possibleTypes[i];
-          if (type2.isTypeOf) {
-            const isTypeOfResult = type2.isTypeOf(value, contextValue, info2);
-            if (isPromise(isTypeOfResult)) {
-              promisedIsTypeOfResults[i] = isTypeOfResult;
-            } else if (isTypeOfResult) {
-              return type2.name;
-            }
-          }
-        }
-        if (promisedIsTypeOfResults.length) {
-          return Promise.all(promisedIsTypeOfResults).then(
-            (isTypeOfResults) => {
-              for (let i = 0; i < isTypeOfResults.length; i++) {
-                if (isTypeOfResults[i]) {
-                  return possibleTypes[i].name;
-                }
-              }
-            }
-          );
-        }
-      };
-      function isPromiseLike$1(object) {
-        return object != null && typeof object.then === "function";
-      }
-      const defaultOnRejectedFn = (reason) => {
-        throw reason;
-      };
-      class ValueOrPromise {
-        constructor(executor) {
-          let value;
-          try {
-            value = executor();
-          } catch (reason) {
-            this.state = { status: "rejected", value: reason };
-            return;
-          }
-          if (isPromiseLike$1(value)) {
-            this.state = { status: "pending", value };
-            return;
-          }
-          this.state = { status: "fulfilled", value };
-        }
-        then(onFulfilled, onRejected) {
-          const state = this.state;
-          if (state.status === "pending") {
-            return new ValueOrPromise(() =>
-              state.value.then(onFulfilled, onRejected)
-            );
-          }
-          const onRejectedFn =
-            typeof onRejected === "function" ? onRejected : defaultOnRejectedFn;
-          if (state.status === "rejected") {
-            return new ValueOrPromise(() => onRejectedFn(state.value));
-          }
-          try {
-            const onFulfilledFn =
-              typeof onFulfilled === "function" ? onFulfilled : void 0;
-            return onFulfilledFn === void 0
-              ? new ValueOrPromise(() => state.value)
-              : new ValueOrPromise(() => onFulfilledFn(state.value));
-          } catch (e) {
-            return new ValueOrPromise(() => onRejectedFn(e));
-          }
-        }
-        catch(onRejected) {
-          return this.then(void 0, onRejected);
-        }
-        resolve() {
-          const state = this.state;
-          if (state.status === "pending") {
-            return Promise.resolve(state.value);
-          }
-          if (state.status === "rejected") {
-            throw state.value;
-          }
-          return state.value;
-        }
-        static all(valueOrPromises) {
-          let containsPromise = false;
-          const values = [];
-          for (const valueOrPromise of valueOrPromises) {
-            const state = valueOrPromise.state;
-            if (state.status === "rejected") {
-              return new ValueOrPromise(() => {
-                throw state.value;
-              });
-            }
-            if (state.status === "pending") {
-              containsPromise = true;
-            }
-            values.push(state.value);
-          }
-          if (containsPromise) {
-            return new ValueOrPromise(() => Promise.all(values));
-          }
-          return new ValueOrPromise(() => values);
-        }
-      }
-      var DataLoader = /* @__PURE__ */ (function () {
-        function DataLoader2(batchLoadFn, options) {
-          if (typeof batchLoadFn !== "function") {
-            throw new TypeError(
-              "DataLoader must be constructed with a function which accepts " +
-                ("Array<key> and returns Promise<Array<value>>, but got: " +
-                  batchLoadFn +
-                  ".")
-            );
-          }
-          this._batchLoadFn = batchLoadFn;
-          this._maxBatchSize = getValidMaxBatchSize(options);
-          this._batchScheduleFn = getValidBatchScheduleFn(options);
-          this._cacheKeyFn = getValidCacheKeyFn(options);
-          this._cacheMap = getValidCacheMap(options);
-          this._batch = null;
-        }
-        var _proto = DataLoader2.prototype;
-        _proto.load = function load(key) {
-          if (key === null || key === void 0) {
-            throw new TypeError(
-              "The loader.load() function must be called with a value, " +
-                ("but got: " + String(key) + ".")
-            );
-          }
-          var batch = getCurrentBatch(this);
-          var cacheMap = this._cacheMap;
-          var cacheKey = this._cacheKeyFn(key);
-          if (cacheMap) {
-            var cachedPromise = cacheMap.get(cacheKey);
-            if (cachedPromise) {
-              var cacheHits = batch.cacheHits || (batch.cacheHits = []);
-              return new Promise(function (resolve) {
-                cacheHits.push(function () {
-                  resolve(cachedPromise);
-                });
-              });
-            }
-          }
-          batch.keys.push(key);
-          var promise = new Promise(function (resolve, reject2) {
-            batch.callbacks.push({
-              resolve,
-              reject: reject2,
-            });
-          });
-          if (cacheMap) {
-            cacheMap.set(cacheKey, promise);
-          }
-          return promise;
-        };
-        _proto.loadMany = function loadMany(keys) {
-          if (!isArrayLike(keys)) {
-            throw new TypeError(
-              "The loader.loadMany() function must be called with Array<key> " +
-                ("but got: " + keys + ".")
-            );
-          }
-          var loadPromises = [];
-          for (var i = 0; i < keys.length; i++) {
-            loadPromises.push(
-              this.load(keys[i])["catch"](function (error2) {
-                return error2;
-              })
-            );
-          }
-          return Promise.all(loadPromises);
-        };
-        _proto.clear = function clear(key) {
-          var cacheMap = this._cacheMap;
-          if (cacheMap) {
-            var cacheKey = this._cacheKeyFn(key);
-            cacheMap["delete"](cacheKey);
-          }
-          return this;
-        };
-        _proto.clearAll = function clearAll() {
-          var cacheMap = this._cacheMap;
-          if (cacheMap) {
-            cacheMap.clear();
-          }
-          return this;
-        };
-        _proto.prime = function prime2(key, value) {
-          var cacheMap = this._cacheMap;
-          if (cacheMap) {
-            var cacheKey = this._cacheKeyFn(key);
-            if (cacheMap.get(cacheKey) === void 0) {
-              var promise;
-              if (value instanceof Error) {
-                promise = Promise.reject(value);
-                promise["catch"](function () {});
-              } else {
-                promise = Promise.resolve(value);
-              }
-              cacheMap.set(cacheKey, promise);
-            }
-          }
-          return this;
-        };
-        return DataLoader2;
-      })();
-      var enqueuePostPromiseJob =
-        typeof process === "object" && typeof process.nextTick === "function"
-          ? function (fn) {
-              if (!resolvedPromise) {
-                resolvedPromise = Promise.resolve();
-              }
-              resolvedPromise.then(function () {
-                process.nextTick(fn);
-              });
-            }
-          : typeof setImmediate === "function"
-          ? function (fn) {
-              setImmediate(fn);
-            }
-          : function (fn) {
-              setTimeout(fn);
-            };
-      var resolvedPromise;
-      function getCurrentBatch(loader) {
-        var existingBatch = loader._batch;
-        if (
-          existingBatch !== null &&
-          !existingBatch.hasDispatched &&
-          existingBatch.keys.length < loader._maxBatchSize &&
-          (!existingBatch.cacheHits ||
-            existingBatch.cacheHits.length < loader._maxBatchSize)
-        ) {
-          return existingBatch;
-        }
-        var newBatch = {
-          hasDispatched: false,
-          keys: [],
-          callbacks: [],
-        };
-        loader._batch = newBatch;
-        loader._batchScheduleFn(function () {
-          dispatchBatch(loader, newBatch);
-        });
-        return newBatch;
-      }
-      function dispatchBatch(loader, batch) {
-        batch.hasDispatched = true;
-        if (batch.keys.length === 0) {
-          resolveCacheHits(batch);
-          return;
-        }
-        var batchPromise = loader._batchLoadFn(batch.keys);
-        if (!batchPromise || typeof batchPromise.then !== "function") {
-          return failedDispatch(
-            loader,
-            batch,
-            new TypeError(
-              "DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but the function did " +
-                ("not return a Promise: " + String(batchPromise) + ".")
-            )
-          );
-        }
-        batchPromise
-          .then(function (values) {
-            if (!isArrayLike(values)) {
-              throw new TypeError(
-                "DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but the function did " +
-                  ("not return a Promise of an Array: " + String(values) + ".")
-              );
-            }
-            if (values.length !== batch.keys.length) {
-              throw new TypeError(
-                "DataLoader must be constructed with a function which accepts Array<key> and returns Promise<Array<value>>, but the function did not return a Promise of an Array of the same length as the Array of keys." +
-                  ("\n\nKeys:\n" + String(batch.keys)) +
-                  ("\n\nValues:\n" + String(values))
-              );
-            }
-            resolveCacheHits(batch);
-            for (var i = 0; i < batch.callbacks.length; i++) {
-              var value = values[i];
-              if (value instanceof Error) {
-                batch.callbacks[i].reject(value);
-              } else {
-                batch.callbacks[i].resolve(value);
-              }
-            }
-          })
-          ["catch"](function (error2) {
-            failedDispatch(loader, batch, error2);
-          });
-      }
-      function failedDispatch(loader, batch, error2) {
-        resolveCacheHits(batch);
-        for (var i = 0; i < batch.keys.length; i++) {
-          loader.clear(batch.keys[i]);
-          batch.callbacks[i].reject(error2);
-        }
-      }
-      function resolveCacheHits(batch) {
-        if (batch.cacheHits) {
-          for (var i = 0; i < batch.cacheHits.length; i++) {
-            batch.cacheHits[i]();
-          }
-        }
-      }
-      function getValidMaxBatchSize(options) {
-        var shouldBatch = !options || options.batch !== false;
-        if (!shouldBatch) {
-          return 1;
-        }
-        var maxBatchSize = options && options.maxBatchSize;
-        if (maxBatchSize === void 0) {
-          return Infinity;
-        }
-        if (typeof maxBatchSize !== "number" || maxBatchSize < 1) {
-          throw new TypeError(
-            "maxBatchSize must be a positive number: " + maxBatchSize
-          );
-        }
-        return maxBatchSize;
-      }
-      function getValidBatchScheduleFn(options) {
-        var batchScheduleFn = options && options.batchScheduleFn;
-        if (batchScheduleFn === void 0) {
-          return enqueuePostPromiseJob;
-        }
-        if (typeof batchScheduleFn !== "function") {
-          throw new TypeError(
-            "batchScheduleFn must be a function: " + batchScheduleFn
-          );
-        }
-        return batchScheduleFn;
-      }
-      function getValidCacheKeyFn(options) {
-        var cacheKeyFn = options && options.cacheKeyFn;
-        if (cacheKeyFn === void 0) {
-          return function (key) {
-            return key;
-          };
-        }
-        if (typeof cacheKeyFn !== "function") {
-          throw new TypeError("cacheKeyFn must be a function: " + cacheKeyFn);
-        }
-        return cacheKeyFn;
-      }
-      function getValidCacheMap(options) {
-        var shouldCache = !options || options.cache !== false;
-        if (!shouldCache) {
-          return null;
-        }
-        var cacheMap = options && options.cacheMap;
-        if (cacheMap === void 0) {
-          return /* @__PURE__ */ new Map();
-        }
-        if (cacheMap !== null) {
-          var cacheFunctions = ["get", "set", "delete", "clear"];
-          var missingFunctions = cacheFunctions.filter(function (fnName) {
-            return cacheMap && typeof cacheMap[fnName] !== "function";
-          });
-          if (missingFunctions.length !== 0) {
-            throw new TypeError(
-              "Custom cacheMap missing methods: " + missingFunctions.join(", ")
-            );
-          }
-        }
-        return cacheMap;
-      }
-      function isArrayLike(x2) {
-        return (
-          typeof x2 === "object" &&
-          x2 !== null &&
-          typeof x2.length === "number" &&
-          (x2.length === 0 ||
-            (x2.length > 0 &&
-              Object.prototype.hasOwnProperty.call(x2, x2.length - 1)))
-        );
-      }
-      var dataloader = DataLoader;
-      function createPrefix(index) {
-        return `_${index}_`;
-      }
-      function parseKey(prefixedKey) {
-        const match2 = /^_([\d]+)_(.*)$/.exec(prefixedKey);
-        if (
-          match2 &&
-          match2.length === 3 &&
-          !isNaN(Number(match2[1])) &&
-          match2[2]
-        ) {
-          return { index: Number(match2[1]), originalKey: match2[2] };
-        }
-        throw new Error(`Key ${prefixedKey} is not correctly prefixed`);
-      }
-      function mergeRequests(requests, extensionsReducer) {
-        var _a2, _b, _c, _d, _e;
-        const mergedVariables = /* @__PURE__ */ Object.create(null);
-        const mergedVariableDefinitions = [];
-        const mergedSelections = [];
-        const mergedFragmentDefinitions = [];
-        let mergedExtensions = /* @__PURE__ */ Object.create(null);
-        for (const index in requests) {
-          const request = requests[index];
-          const prefixedRequests = prefixRequest(createPrefix(index), request);
-          for (const def of prefixedRequests.document.definitions) {
-            if (isOperationDefinition(def)) {
-              mergedSelections.push(...def.selectionSet.selections);
-              if (def.variableDefinitions) {
-                mergedVariableDefinitions.push(...def.variableDefinitions);
-              }
-            }
-            if (isFragmentDefinition(def)) {
-              mergedFragmentDefinitions.push(def);
-            }
-          }
-          Object.assign(mergedVariables, prefixedRequests.variables);
-          mergedExtensions = extensionsReducer(mergedExtensions, request);
-        }
-        const firstRequest = requests[0];
-        const operationType =
-          (_a2 = firstRequest.operationType) !== null && _a2 !== void 0
-            ? _a2
-            : getOperationASTFromRequest(firstRequest).operation;
-        const mergedOperationDefinition = {
-          kind: Kind.OPERATION_DEFINITION,
-          operation: operationType,
-          variableDefinitions: mergedVariableDefinitions,
-          selectionSet: {
-            kind: Kind.SELECTION_SET,
-            selections: mergedSelections,
-          },
-        };
-        const operationName =
-          (_b = firstRequest.operationName) !== null && _b !== void 0
-            ? _b
-            : (_e =
-                (_d =
-                  (_c = firstRequest.info) === null || _c === void 0
-                    ? void 0
-                    : _c.operation) === null || _d === void 0
-                  ? void 0
-                  : _d.name) === null || _e === void 0
-            ? void 0
-            : _e.value;
-        if (operationName) {
-          mergedOperationDefinition.name = {
-            kind: Kind.NAME,
-            value: operationName,
-          };
-        }
-        return {
-          document: {
-            kind: Kind.DOCUMENT,
-            definitions: [
-              mergedOperationDefinition,
-              ...mergedFragmentDefinitions,
-            ],
-          },
-          variables: mergedVariables,
-          extensions: mergedExtensions,
-          context: requests[0].context,
-          info: requests[0].info,
-          operationType,
-        };
-      }
-      function prefixRequest(prefix, request) {
-        var _a2;
-        const executionVariables =
-          (_a2 = request.variables) !== null && _a2 !== void 0 ? _a2 : {};
-        function prefixNode(node) {
-          return prefixNodeName(node, prefix);
-        }
-        let prefixedDocument = aliasTopLevelFields(prefix, request.document);
-        const executionVariableNames = Object.keys(executionVariables);
-        const hasFragmentDefinitions = request.document.definitions.some(
-          (def) => isFragmentDefinition(def)
-        );
-        const fragmentSpreadImpl = {};
-        if (executionVariableNames.length > 0 || hasFragmentDefinitions) {
-          prefixedDocument = visit(prefixedDocument, {
-            [Kind.VARIABLE]: prefixNode,
-            [Kind.FRAGMENT_DEFINITION]: prefixNode,
-            [Kind.FRAGMENT_SPREAD]: (node) => {
-              node = prefixNodeName(node, prefix);
-              fragmentSpreadImpl[node.name.value] = true;
-              return node;
-            },
-          });
-        }
-        const prefixedVariables = {};
-        for (const variableName of executionVariableNames) {
-          prefixedVariables[prefix + variableName] =
-            executionVariables[variableName];
-        }
-        if (hasFragmentDefinitions) {
-          prefixedDocument = __spreadProps(
-            __spreadValues({}, prefixedDocument),
-            {
-              definitions: prefixedDocument.definitions.filter((def) => {
-                return (
-                  !isFragmentDefinition(def) ||
-                  fragmentSpreadImpl[def.name.value]
-                );
-              }),
-            }
-          );
-        }
-        return {
-          document: prefixedDocument,
-          variables: prefixedVariables,
-        };
-      }
-      function aliasTopLevelFields(prefix, document2) {
-        const transformer = {
-          [Kind.OPERATION_DEFINITION]: (def) => {
-            const { selections } = def.selectionSet;
-            return __spreadProps(__spreadValues({}, def), {
-              selectionSet: __spreadProps(
-                __spreadValues({}, def.selectionSet),
-                {
-                  selections: aliasFieldsInSelection(
-                    prefix,
-                    selections,
-                    document2
-                  ),
-                }
-              ),
-            });
-          },
-        };
-        return visit(document2, transformer, {
-          [Kind.DOCUMENT]: [`definitions`],
-        });
-      }
-      function aliasFieldsInSelection(prefix, selections, document2) {
-        return selections.map((selection) => {
-          switch (selection.kind) {
-            case Kind.INLINE_FRAGMENT:
-              return aliasFieldsInInlineFragment(prefix, selection, document2);
-            case Kind.FRAGMENT_SPREAD: {
-              const inlineFragment = inlineFragmentSpread(selection, document2);
-              return aliasFieldsInInlineFragment(
-                prefix,
-                inlineFragment,
-                document2
-              );
-            }
-            case Kind.FIELD:
-            default:
-              return aliasField(selection, prefix);
-          }
-        });
-      }
-      function aliasFieldsInInlineFragment(prefix, fragment, document2) {
-        const { selections } = fragment.selectionSet;
-        return __spreadProps(__spreadValues({}, fragment), {
-          selectionSet: __spreadProps(
-            __spreadValues({}, fragment.selectionSet),
-            {
-              selections: aliasFieldsInSelection(prefix, selections, document2),
-            }
-          ),
-        });
-      }
-      function inlineFragmentSpread(spread, document2) {
-        const fragment = document2.definitions.find(
-          (def) =>
-            isFragmentDefinition(def) && def.name.value === spread.name.value
-        );
-        if (!fragment) {
-          throw new Error(`Fragment ${spread.name.value} does not exist`);
-        }
-        const { typeCondition, selectionSet } = fragment;
-        return {
-          kind: Kind.INLINE_FRAGMENT,
-          typeCondition,
-          selectionSet,
-          directives: spread.directives,
-        };
-      }
-      function prefixNodeName(namedNode, prefix) {
-        return __spreadProps(__spreadValues({}, namedNode), {
-          name: __spreadProps(__spreadValues({}, namedNode.name), {
-            value: prefix + namedNode.name.value,
-          }),
-        });
-      }
-      function aliasField(field, aliasPrefix) {
-        const aliasNode = field.alias ? field.alias : field.name;
-        return __spreadProps(__spreadValues({}, field), {
-          alias: __spreadProps(__spreadValues({}, aliasNode), {
-            value: aliasPrefix + aliasNode.value,
-          }),
-        });
-      }
-      function isOperationDefinition(def) {
-        return def.kind === Kind.OPERATION_DEFINITION;
-      }
-      function isFragmentDefinition(def) {
-        return def.kind === Kind.FRAGMENT_DEFINITION;
-      }
-      function splitResult({ data, errors: errors2 }, numResults) {
-        const splitResults = [];
-        for (let i = 0; i < numResults; i++) {
-          splitResults.push({});
-        }
-        if (data) {
-          for (const prefixedKey in data) {
-            const { index, originalKey } = parseKey(prefixedKey);
-            const result2 = splitResults[index];
-            if (result2 == null) {
-              continue;
-            }
-            if (result2.data == null) {
-              result2.data = { [originalKey]: data[prefixedKey] };
-            } else {
-              result2.data[originalKey] = data[prefixedKey];
-            }
-          }
-        }
-        if (errors2) {
-          for (const error2 of errors2) {
-            if (error2.path) {
-              const parsedKey = parseKey(error2.path[0]);
-              const { index, originalKey } = parsedKey;
-              const newError = relocatedError(error2, [
-                originalKey,
-                ...error2.path.slice(1),
-              ]);
-              const resultErrors = (splitResults[index].errors =
-                splitResults[index].errors || []);
-              resultErrors.push(newError);
-            } else {
-              splitResults.forEach((result2) => {
-                const resultErrors = (result2.errors = result2.errors || []);
-                resultErrors.push(new GraphQLError(error2.message));
-              });
-            }
-          }
-        }
-        return splitResults;
-      }
-      function createBatchingExecutor(
-        executor,
-        dataLoaderOptions,
-        extensionsReducer = defaultExtensionsReducer
-      ) {
-        const loadFn = createLoadFn(executor, extensionsReducer);
-        const loader = new dataloader(loadFn, dataLoaderOptions);
-        return function batchingExecutor(request) {
-          const operationAst = getOperationASTFromRequest(request);
-          return operationAst.operation === "subscription"
-            ? executor(request)
-            : loader.load(request);
-        };
-      }
-      function createLoadFn(executor, extensionsReducer) {
-        return async function batchExecuteLoadFn(requests) {
-          const execBatches = [];
-          let index = 0;
-          const request = requests[index];
-          let currentBatch = [request];
-          execBatches.push(currentBatch);
-          const operationAst = getOperationASTFromRequest(request);
-          const operationType = operationAst.operation;
-          if (operationType == null) {
-            throw new Error("could not identify operation type of document");
-          }
-          while (++index < requests.length) {
-            const currentRequest = requests[index];
-            const currentOperationAST =
-              getOperationASTFromRequest(currentRequest);
-            const currentOperationType = currentOperationAST.operation;
-            if (operationType === currentOperationType) {
-              currentBatch.push(currentRequest);
-            } else {
-              currentBatch = [currentRequest];
-              execBatches.push(currentBatch);
-            }
-          }
-          const results = await Promise.all(
-            execBatches.map(async (execBatch) => {
-              const mergedRequests = mergeRequests(
-                execBatch,
-                extensionsReducer
-              );
-              const resultBatches = await executor(mergedRequests);
-              return splitResult(resultBatches, execBatch.length);
-            })
-          );
-          return results.flat();
-        };
-      }
-      function defaultExtensionsReducer(mergedExtensions, request) {
-        const newExtensions = request.extensions;
-        if (newExtensions != null) {
-          Object.assign(mergedExtensions, newExtensions);
-        }
-        return mergedExtensions;
-      }
-      const getBatchingExecutor = memoize2of4(function getBatchingExecutor2(
-        _context,
-        executor,
-        dataLoaderOptions,
-        extensionsReducer
-      ) {
-        return createBatchingExecutor(
-          executor,
-          dataLoaderOptions,
-          extensionsReducer
-        );
-      });
-      function applySchemaTransforms(
-        originalWrappingSchema,
-        subschemaConfig,
-        transformedSchema
-      ) {
-        const schemaTransforms = subschemaConfig.transforms;
-        if (schemaTransforms == null) {
-          return originalWrappingSchema;
-        }
-        return schemaTransforms.reduce(
-          (schema, transform) =>
-            transform.transformSchema != null
-              ? transform.transformSchema(
-                  schema,
-                  subschemaConfig,
-                  transformedSchema
-                )
-              : schema,
-          originalWrappingSchema
-        );
-      }
-      class Subschema {
-        constructor(config2) {
-          var _a2;
-          this.schema = config2.schema;
-          this.executor = config2.executor;
-          this.batch = config2.batch;
-          this.batchingOptions = config2.batchingOptions;
-          this.createProxyingResolver = config2.createProxyingResolver;
-          this.transforms =
-            (_a2 = config2.transforms) !== null && _a2 !== void 0 ? _a2 : [];
-          this.transformedSchema = applySchemaTransforms(this.schema, config2);
-          this.merge = config2.merge;
-        }
-      }
-      function getDocumentMetadata(document2) {
-        const operations = [];
-        const fragments = [];
-        const fragmentNames = /* @__PURE__ */ new Set();
-        for (let i = 0; i < document2.definitions.length; i++) {
-          const def = document2.definitions[i];
-          if (def.kind === Kind.FRAGMENT_DEFINITION) {
-            fragments.push(def);
-            fragmentNames.add(def.name.value);
-          } else if (def.kind === Kind.OPERATION_DEFINITION) {
-            operations.push(def);
-          }
-        }
-        return {
-          operations,
-          fragments,
-          fragmentNames,
-        };
-      }
-      function prepareGatewayDocument(
-        originalDocument,
-        transformedSchema,
-        returnType,
-        infoSchema
-      ) {
-        const wrappedConcreteTypesDocument = wrapConcreteTypes(
-          returnType,
-          transformedSchema,
-          originalDocument
-        );
-        if (infoSchema == null) {
-          return wrappedConcreteTypesDocument;
-        }
-        const {
-          possibleTypesMap,
-          reversePossibleTypesMap: reversePossibleTypesMap2,
-          interfaceExtensionsMap,
-          fieldNodesByType,
-          fieldNodesByField,
-          dynamicSelectionSetsByField,
-        } = getSchemaMetaData(infoSchema, transformedSchema);
-        const { operations, fragments, fragmentNames } = getDocumentMetadata(
-          wrappedConcreteTypesDocument
-        );
-        const { expandedFragments, fragmentReplacements } =
-          getExpandedFragments(fragments, fragmentNames, possibleTypesMap);
-        const typeInfo = new TypeInfo(transformedSchema);
-        const expandedDocument = {
-          kind: Kind.DOCUMENT,
-          definitions: [...operations, ...fragments, ...expandedFragments],
-        };
-        const visitorKeyMap = {
-          Document: ["definitions"],
-          OperationDefinition: ["selectionSet"],
-          SelectionSet: ["selections"],
-          Field: ["selectionSet"],
-          InlineFragment: ["selectionSet"],
-          FragmentDefinition: ["selectionSet"],
-        };
-        return visit(
-          expandedDocument,
-          visitWithTypeInfo(typeInfo, {
-            [Kind.SELECTION_SET]: (node) =>
-              visitSelectionSet(
-                node,
-                fragmentReplacements,
-                transformedSchema,
-                typeInfo,
-                possibleTypesMap,
-                reversePossibleTypesMap2,
-                interfaceExtensionsMap,
-                fieldNodesByType,
-                fieldNodesByField,
-                dynamicSelectionSetsByField
-              ),
-          }),
-          visitorKeyMap
-        );
-      }
-      function visitSelectionSet(
-        node,
-        fragmentReplacements,
-        schema,
-        typeInfo,
-        possibleTypesMap,
-        reversePossibleTypesMap2,
-        interfaceExtensionsMap,
-        fieldNodesByType,
-        fieldNodesByField,
-        dynamicSelectionSetsByField
-      ) {
-        var _a2, _b;
-        const newSelections = /* @__PURE__ */ new Set();
-        const maybeType = typeInfo.getParentType();
-        if (maybeType != null) {
-          const parentType = getNamedType(maybeType);
-          const parentTypeName = parentType.name;
-          const fieldNodes = fieldNodesByType[parentTypeName];
-          if (fieldNodes) {
-            for (const fieldNode of fieldNodes) {
-              newSelections.add(fieldNode);
-            }
-          }
-          const interfaceExtensions = interfaceExtensionsMap[parentType.name];
-          const interfaceExtensionFields = [];
-          for (const selection of node.selections) {
-            if (selection.kind === Kind.INLINE_FRAGMENT) {
-              if (selection.typeCondition != null) {
-                const possibleTypes =
-                  possibleTypesMap[selection.typeCondition.name.value];
-                if (possibleTypes == null) {
-                  newSelections.add(selection);
-                  continue;
-                }
-                for (const possibleTypeName of possibleTypes) {
-                  const maybePossibleType = schema.getType(possibleTypeName);
-                  if (
-                    maybePossibleType != null &&
-                    implementsAbstractType(
-                      schema,
-                      parentType,
-                      maybePossibleType
-                    )
-                  ) {
-                    newSelections.add(
-                      generateInlineFragment(
-                        possibleTypeName,
-                        selection.selectionSet
-                      )
-                    );
-                  }
-                }
-              }
-            } else if (selection.kind === Kind.FRAGMENT_SPREAD) {
-              const fragmentName = selection.name.value;
-              if (!fragmentReplacements[fragmentName]) {
-                newSelections.add(selection);
-                continue;
-              }
-              for (const replacement of fragmentReplacements[fragmentName]) {
-                const typeName = replacement.typeName;
-                const maybeReplacementType = schema.getType(typeName);
-                if (
-                  maybeReplacementType != null &&
-                  implementsAbstractType(schema, parentType, maybeType)
-                ) {
-                  newSelections.add({
-                    kind: Kind.FRAGMENT_SPREAD,
-                    name: {
-                      kind: Kind.NAME,
-                      value: replacement.fragmentName,
-                    },
-                  });
-                }
-              }
-            } else {
-              const fieldName = selection.name.value;
-              const fieldNodes2 =
-                (_a2 = fieldNodesByField[parentTypeName]) === null ||
-                _a2 === void 0
-                  ? void 0
-                  : _a2[fieldName];
-              if (fieldNodes2 != null) {
-                for (const fieldNode of fieldNodes2) {
-                  newSelections.add(fieldNode);
-                }
-              }
-              const dynamicSelectionSets =
-                (_b = dynamicSelectionSetsByField[parentTypeName]) === null ||
-                _b === void 0
-                  ? void 0
-                  : _b[fieldName];
-              if (dynamicSelectionSets != null) {
-                for (const selectionSetFn of dynamicSelectionSets) {
-                  const selectionSet = selectionSetFn(selection);
-                  if (selectionSet != null) {
-                    for (const selection2 of selectionSet.selections) {
-                      newSelections.add(selection2);
-                    }
-                  }
-                }
-              }
-              if (
-                interfaceExtensions === null || interfaceExtensions === void 0
-                  ? void 0
-                  : interfaceExtensions[fieldName]
-              ) {
-                interfaceExtensionFields.push(selection);
-              } else {
-                newSelections.add(selection);
-              }
-            }
-          }
-          if (reversePossibleTypesMap2[parentType.name]) {
-            newSelections.add({
-              kind: Kind.FIELD,
-              name: {
-                kind: Kind.NAME,
-                value: "__typename",
-              },
-            });
-          }
-          if (interfaceExtensionFields.length) {
-            const possibleTypes = possibleTypesMap[parentType.name];
-            if (possibleTypes != null) {
-              for (const possibleType of possibleTypes) {
-                newSelections.add(
-                  generateInlineFragment(possibleType, {
-                    kind: Kind.SELECTION_SET,
-                    selections: interfaceExtensionFields,
-                  })
-                );
-              }
-            }
-          }
-          return __spreadProps(__spreadValues({}, node), {
-            selections: Array.from(newSelections),
-          });
-        }
-        return node;
-      }
-      function generateInlineFragment(typeName, selectionSet) {
-        return {
-          kind: Kind.INLINE_FRAGMENT,
-          typeCondition: {
-            kind: Kind.NAMED_TYPE,
-            name: {
-              kind: Kind.NAME,
-              value: typeName,
-            },
-          },
-          selectionSet,
-        };
-      }
-      const getSchemaMetaData = memoize2$1((sourceSchema, targetSchema) => {
-        var _a2, _b, _c, _d;
-        const typeMap = sourceSchema.getTypeMap();
-        const targetTypeMap = targetSchema.getTypeMap();
-        const possibleTypesMap = /* @__PURE__ */ Object.create(null);
-        const interfaceExtensionsMap = /* @__PURE__ */ Object.create(null);
-        for (const typeName in typeMap) {
-          const type2 = typeMap[typeName];
-          if (isAbstractType(type2)) {
-            const targetType = targetTypeMap[typeName];
-            if (isInterfaceType(type2) && isInterfaceType(targetType)) {
-              const targetTypeFields = targetType.getFields();
-              const sourceTypeFields = type2.getFields();
-              const extensionFields = /* @__PURE__ */ Object.create(null);
-              let isExtensionFieldsEmpty = true;
-              for (const fieldName in sourceTypeFields) {
-                if (!targetTypeFields[fieldName]) {
-                  extensionFields[fieldName] = true;
-                  isExtensionFieldsEmpty = false;
-                }
-              }
-              if (!isExtensionFieldsEmpty) {
-                interfaceExtensionsMap[typeName] = extensionFields;
-              }
-            }
-            if (
-              interfaceExtensionsMap[typeName] ||
-              !isAbstractType(targetType)
-            ) {
-              const implementations = sourceSchema.getPossibleTypes(type2);
-              possibleTypesMap[typeName] = [];
-              for (const impl of implementations) {
-                if (targetTypeMap[impl.name]) {
-                  possibleTypesMap[typeName].push(impl.name);
-                }
-              }
-            }
-          }
-        }
-        const stitchingInfo =
-          (_a2 = sourceSchema.extensions) === null || _a2 === void 0
-            ? void 0
-            : _a2["stitchingInfo"];
-        return {
-          possibleTypesMap,
-          reversePossibleTypesMap: reversePossibleTypesMap(possibleTypesMap),
-          interfaceExtensionsMap,
-          fieldNodesByType:
-            (_b =
-              stitchingInfo === null || stitchingInfo === void 0
-                ? void 0
-                : stitchingInfo.fieldNodesByType) !== null && _b !== void 0
-              ? _b
-              : {},
-          fieldNodesByField:
-            (_c =
-              stitchingInfo === null || stitchingInfo === void 0
-                ? void 0
-                : stitchingInfo.fieldNodesByField) !== null && _c !== void 0
-              ? _c
-              : {},
-          dynamicSelectionSetsByField:
-            (_d =
-              stitchingInfo === null || stitchingInfo === void 0
-                ? void 0
-                : stitchingInfo.dynamicSelectionSetsByField) !== null &&
-            _d !== void 0
-              ? _d
-              : {},
-        };
-      });
-      function reversePossibleTypesMap(possibleTypesMap) {
-        const result2 = /* @__PURE__ */ Object.create(null);
-        for (const typeName in possibleTypesMap) {
-          const toTypeNames = possibleTypesMap[typeName];
-          for (const toTypeName of toTypeNames) {
-            if (!result2[toTypeName]) {
-              result2[toTypeName] = [];
-            }
-            result2[toTypeName].push(typeName);
-          }
-        }
-        return result2;
-      }
-      function getExpandedFragments(
-        fragments,
-        fragmentNames,
-        possibleTypesMap
-      ) {
-        let fragmentCounter = 0;
-        function generateFragmentName(typeName) {
-          let fragmentName;
-          do {
-            fragmentName = `_${typeName}_Fragment${fragmentCounter.toString()}`;
-            fragmentCounter++;
-          } while (fragmentNames.has(fragmentName));
-          return fragmentName;
-        }
-        const expandedFragments = [];
-        const fragmentReplacements = /* @__PURE__ */ Object.create(null);
-        for (const fragment of fragments) {
-          const possibleTypes =
-            possibleTypesMap[fragment.typeCondition.name.value];
-          if (possibleTypes != null) {
-            const fragmentName = fragment.name.value;
-            fragmentReplacements[fragmentName] = [];
-            for (const possibleTypeName of possibleTypes) {
-              const name2 = generateFragmentName(possibleTypeName);
-              fragmentNames.add(name2);
-              expandedFragments.push({
-                kind: Kind.FRAGMENT_DEFINITION,
-                name: {
-                  kind: Kind.NAME,
-                  value: name2,
-                },
-                typeCondition: {
-                  kind: Kind.NAMED_TYPE,
-                  name: {
-                    kind: Kind.NAME,
-                    value: possibleTypeName,
-                  },
-                },
-                selectionSet: fragment.selectionSet,
-              });
-              fragmentReplacements[fragmentName].push({
-                fragmentName: name2,
-                typeName: possibleTypeName,
-              });
-            }
-          }
-        }
-        return {
-          expandedFragments,
-          fragmentReplacements,
-        };
-      }
-      function wrapConcreteTypes(returnType, targetSchema, document2) {
-        const namedType = getNamedType(returnType);
-        if (!isObjectType(namedType)) {
-          return document2;
-        }
-        const rootTypeNames = getRootTypeNames(targetSchema);
-        const typeInfo = new TypeInfo(targetSchema);
-        const visitorKeys = {
-          Document: ["definitions"],
-          OperationDefinition: ["selectionSet"],
-          SelectionSet: ["selections"],
-          InlineFragment: ["selectionSet"],
-          FragmentDefinition: ["selectionSet"],
-        };
-        return visit(
-          document2,
-          visitWithTypeInfo(typeInfo, {
-            [Kind.FRAGMENT_DEFINITION]: (node) => {
-              const typeName = node.typeCondition.name.value;
-              if (!rootTypeNames.has(typeName)) {
-                return false;
-              }
-            },
-            [Kind.FIELD]: (node) => {
-              const type2 = typeInfo.getType();
-              if (type2 != null && isAbstractType(getNamedType(type2))) {
-                return __spreadProps(__spreadValues({}, node), {
-                  selectionSet: {
-                    kind: Kind.SELECTION_SET,
-                    selections: [
-                      {
-                        kind: Kind.INLINE_FRAGMENT,
-                        typeCondition: {
-                          kind: Kind.NAMED_TYPE,
-                          name: {
-                            kind: Kind.NAME,
-                            value: namedType.name,
-                          },
-                        },
-                        selectionSet: node.selectionSet,
-                      },
-                    ],
-                  },
-                });
-              }
-            },
-          }),
-          visitorKeys
-        );
-      }
-      function finalizeGatewayDocument(targetSchema, fragments, operations) {
-        var _a2;
-        let usedVariables = [];
-        let usedFragments = [];
-        const newOperations = [];
-        let newFragments = [];
-        const validFragments = [];
-        const validFragmentsWithType = /* @__PURE__ */ Object.create(null);
-        for (const fragment of fragments) {
-          const typeName = fragment.typeCondition.name.value;
-          const type2 = targetSchema.getType(typeName);
-          if (type2 != null) {
-            validFragments.push(fragment);
-            validFragmentsWithType[fragment.name.value] = type2;
-          }
-        }
-        let fragmentSet = /* @__PURE__ */ Object.create(null);
-        for (const operation of operations) {
-          const type2 = getDefinedRootType(targetSchema, operation.operation);
-          const {
-            selectionSet,
-            usedFragments: operationUsedFragments,
-            usedVariables: operationUsedVariables,
-          } = finalizeSelectionSet(
-            targetSchema,
-            type2,
-            validFragmentsWithType,
-            operation.selectionSet
-          );
-          usedFragments = union(usedFragments, operationUsedFragments);
-          const {
-            usedVariables: collectedUsedVariables,
-            newFragments: collectedNewFragments,
-            fragmentSet: collectedFragmentSet,
-          } = collectFragmentVariables(
-            targetSchema,
-            fragmentSet,
-            validFragments,
-            validFragmentsWithType,
-            usedFragments
-          );
-          const operationOrFragmentVariables = union(
-            operationUsedVariables,
-            collectedUsedVariables
-          );
-          usedVariables = union(usedVariables, operationOrFragmentVariables);
-          newFragments = collectedNewFragments;
-          fragmentSet = collectedFragmentSet;
-          const variableDefinitions = (
-            (_a2 = operation.variableDefinitions) !== null && _a2 !== void 0
-              ? _a2
-              : []
-          ).filter(
-            (variable) =>
-              operationOrFragmentVariables.indexOf(
-                variable.variable.name.value
-              ) !== -1
-          );
-          newOperations.push({
-            kind: Kind.OPERATION_DEFINITION,
-            operation: operation.operation,
-            name: operation.name,
-            directives: operation.directives,
-            variableDefinitions,
-            selectionSet,
-          });
-        }
-        const newDocument = {
-          kind: Kind.DOCUMENT,
-          definitions: [...newOperations, ...newFragments],
-        };
-        return {
-          usedVariables,
-          newDocument,
-        };
-      }
-      function finalizeGatewayRequest(originalRequest, delegationContext) {
-        let { document: document2, variables } = originalRequest;
-        let { operations, fragments } = getDocumentMetadata(document2);
-        const { targetSchema, args } = delegationContext;
-        if (args) {
-          const requestWithNewVariables = addVariablesToRootFields(
-            targetSchema,
-            operations,
-            args
-          );
-          operations = requestWithNewVariables.newOperations;
-          variables = Object.assign(
-            {},
-            variables !== null && variables !== void 0 ? variables : {},
-            requestWithNewVariables.newVariables
-          );
-        }
-        const { usedVariables, newDocument } = finalizeGatewayDocument(
-          targetSchema,
-          fragments,
-          operations
-        );
-        const newVariables = {};
-        if (variables != null) {
-          for (const variableName of usedVariables) {
-            const variableValue = variables[variableName];
-            if (variableValue !== void 0) {
-              newVariables[variableName] = variableValue;
-            }
-          }
-        }
-        return __spreadProps(__spreadValues({}, originalRequest), {
-          document: newDocument,
-          variables: newVariables,
-        });
-      }
-      function addVariablesToRootFields(targetSchema, operations, args) {
-        const newVariables = /* @__PURE__ */ Object.create(null);
-        const newOperations = operations.map((operation) => {
-          var _a2, _b;
-          const variableDefinitionMap = (
-            (_a2 = operation.variableDefinitions) !== null && _a2 !== void 0
-              ? _a2
-              : []
-          ).reduce(
-            (prev, def) =>
-              __spreadProps(__spreadValues({}, prev), {
-                [def.variable.name.value]: def,
-              }),
-            {}
-          );
-          const type2 = getDefinedRootType(targetSchema, operation.operation);
-          const newSelections = [];
-          for (const selection of operation.selectionSet.selections) {
-            if (selection.kind === Kind.FIELD) {
-              const argumentNodes =
-                (_b = selection.arguments) !== null && _b !== void 0 ? _b : [];
-              const argumentNodeMap = argumentNodes.reduce(
-                (prev, argument) =>
-                  __spreadProps(__spreadValues({}, prev), {
-                    [argument.name.value]: argument,
-                  }),
-                {}
-              );
-              const targetField = type2.getFields()[selection.name.value];
-              if (targetField != null) {
-                updateArguments(
-                  targetField,
-                  argumentNodeMap,
-                  variableDefinitionMap,
-                  newVariables,
-                  args
-                );
-              }
-              newSelections.push(
-                __spreadProps(__spreadValues({}, selection), {
-                  arguments: Object.values(argumentNodeMap),
-                })
-              );
-            } else {
-              newSelections.push(selection);
-            }
-          }
-          const newSelectionSet = {
-            kind: Kind.SELECTION_SET,
-            selections: newSelections,
-          };
-          return __spreadProps(__spreadValues({}, operation), {
-            variableDefinitions: Object.values(variableDefinitionMap),
-            selectionSet: newSelectionSet,
-          });
-        });
-        return {
-          newOperations,
-          newVariables,
-        };
-      }
-      function updateArguments(
-        targetField,
-        argumentNodeMap,
-        variableDefinitionMap,
-        variableValues,
-        newArgs
-      ) {
-        const generateVariableName = createVariableNameGenerator(
-          variableDefinitionMap
-        );
-        for (const argument of targetField.args) {
-          const argName = argument.name;
-          const argType = argument.type;
-          if (argName in newArgs) {
-            updateArgument(
-              argumentNodeMap,
-              variableDefinitionMap,
-              variableValues,
-              argName,
-              generateVariableName(argName),
-              argType,
-              serializeInputValue(argType, newArgs[argName])
-            );
-          }
-        }
-      }
-      function collectFragmentVariables(
-        targetSchema,
-        fragmentSet,
-        validFragments,
-        validFragmentsWithType,
-        usedFragments
-      ) {
-        let remainingFragments = usedFragments.slice();
-        let usedVariables = [];
-        const newFragments = [];
-        while (remainingFragments.length !== 0) {
-          const nextFragmentName = remainingFragments.pop();
-          const fragment = validFragments.find(
-            (fr) => fr.name.value === nextFragmentName
-          );
-          if (fragment != null) {
-            const name2 = nextFragmentName;
-            const typeName = fragment.typeCondition.name.value;
-            const type2 = targetSchema.getType(typeName);
-            if (type2 == null) {
-              throw new Error(
-                `Fragment reference type "${typeName}", but the type is not contained within the target schema.`
-              );
-            }
-            const {
-              selectionSet,
-              usedFragments: fragmentUsedFragments,
-              usedVariables: fragmentUsedVariables,
-            } = finalizeSelectionSet(
-              targetSchema,
-              type2,
-              validFragmentsWithType,
-              fragment.selectionSet
-            );
-            remainingFragments = union(
-              remainingFragments,
-              fragmentUsedFragments
-            );
-            usedVariables = union(usedVariables, fragmentUsedVariables);
-            if (name2 && !(name2 in fragmentSet)) {
-              fragmentSet[name2] = true;
-              newFragments.push({
-                kind: Kind.FRAGMENT_DEFINITION,
-                name: {
-                  kind: Kind.NAME,
-                  value: name2,
-                },
-                typeCondition: fragment.typeCondition,
-                selectionSet,
-              });
-            }
-          }
-        }
-        return {
-          usedVariables,
-          newFragments,
-          fragmentSet,
-        };
-      }
-      const filteredSelectionSetVisitorKeys = {
-        SelectionSet: ["selections"],
-        Field: ["selectionSet"],
-        InlineFragment: ["selectionSet"],
-        FragmentDefinition: ["selectionSet"],
-      };
-      const variablesVisitorKeys = {
-        SelectionSet: ["selections"],
-        Field: ["arguments", "directives", "selectionSet"],
-        Argument: ["value"],
-        InlineFragment: ["directives", "selectionSet"],
-        FragmentSpread: ["directives"],
-        FragmentDefinition: ["selectionSet"],
-        ObjectValue: ["fields"],
-        ObjectField: ["name", "value"],
-        Directive: ["arguments"],
-        ListValue: ["values"],
-      };
-      function finalizeSelectionSet(
-        schema,
-        type2,
-        validFragments,
-        selectionSet
-      ) {
-        const usedFragments = [];
-        const usedVariables = [];
-        const typeInfo =
-          versionInfo.major < 16
-            ? new TypeInfo(schema, void 0, type2)
-            : new TypeInfo(schema, type2);
-        const filteredSelectionSet = visit(
-          selectionSet,
-          visitWithTypeInfo(typeInfo, {
-            [Kind.FIELD]: {
-              enter: (node) => {
-                const parentType = typeInfo.getParentType();
-                if (isObjectType(parentType) || isInterfaceType(parentType)) {
-                  const fields = parentType.getFields();
-                  const field =
-                    node.name.value === "__typename"
-                      ? TypeNameMetaFieldDef
-                      : fields[node.name.value];
-                  if (!field) {
-                    return null;
-                  }
-                  const args = field.args != null ? field.args : [];
-                  const argsMap = /* @__PURE__ */ Object.create(null);
-                  for (const arg of args) {
-                    argsMap[arg.name] = arg;
-                  }
-                  if (node.arguments != null) {
-                    const newArgs = [];
-                    for (const arg of node.arguments) {
-                      if (arg.name.value in argsMap) {
-                        newArgs.push(arg);
-                      }
-                    }
-                    if (newArgs.length !== node.arguments.length) {
-                      return __spreadProps(__spreadValues({}, node), {
-                        arguments: newArgs,
-                      });
-                    }
-                  }
-                }
-              },
-              leave: (node) => {
-                const type3 = typeInfo.getType();
-                if (type3 == null) {
-                  throw new Error(
-                    `No type was found for field node ${inspect$1(node)}.`
-                  );
-                }
-                const namedType = getNamedType(type3);
-                if (!schema.getType(namedType.name) == null) {
-                  return null;
-                }
-                if (isObjectType(namedType) || isInterfaceType(namedType)) {
-                  const selections =
-                    node.selectionSet != null
-                      ? node.selectionSet.selections
-                      : null;
-                  if (selections == null || selections.length === 0) {
-                    return null;
-                  }
-                }
-              },
-            },
-            [Kind.FRAGMENT_SPREAD]: {
-              enter: (node) => {
-                if (!(node.name.value in validFragments)) {
-                  return null;
-                }
-                const parentType = typeInfo.getParentType();
-                const innerType = validFragments[node.name.value];
-                if (!implementsAbstractType(schema, parentType, innerType)) {
-                  return null;
-                }
-                usedFragments.push(node.name.value);
-              },
-            },
-            [Kind.INLINE_FRAGMENT]: {
-              enter: (node) => {
-                if (node.typeCondition != null) {
-                  const parentType = typeInfo.getParentType();
-                  const innerType = schema.getType(
-                    node.typeCondition.name.value
-                  );
-                  if (!implementsAbstractType(schema, parentType, innerType)) {
-                    return null;
-                  }
-                }
-              },
-            },
-            [Kind.SELECTION_SET]: {
-              leave: (node) => {
-                const parentType = typeInfo.getParentType();
-                if (parentType != null && isAbstractType(parentType)) {
-                  const selections = node.selections.concat([
-                    {
-                      kind: Kind.FIELD,
-                      name: {
-                        kind: Kind.NAME,
-                        value: "__typename",
-                      },
-                    },
-                  ]);
-                  return __spreadProps(__spreadValues({}, node), {
-                    selections,
-                  });
-                }
-              },
-            },
-          }),
-          filteredSelectionSetVisitorKeys
-        );
-        visit(
-          filteredSelectionSet,
-          {
-            [Kind.VARIABLE]: (variableNode) => {
-              usedVariables.push(variableNode.name.value);
-            },
-          },
-          variablesVisitorKeys
-        );
-        return {
-          selectionSet: filteredSelectionSet,
-          usedFragments,
-          usedVariables,
-        };
-      }
-      function union(...arrays) {
-        const cache = /* @__PURE__ */ Object.create(null);
-        const result2 = [];
-        for (const array of arrays) {
-          for (const item of array) {
-            if (!(item in cache)) {
-              cache[item] = true;
-              result2.push(item);
-            }
-          }
-        }
-        return result2;
-      }
-      const UNPATHED_ERRORS_SYMBOL = Symbol("subschemaErrors");
-      const OBJECT_SUBSCHEMA_SYMBOL = Symbol("initialSubschema");
-      const FIELD_SUBSCHEMA_MAP_SYMBOL = Symbol("subschemaMap");
-      function isExternalObject(data) {
-        return data[UNPATHED_ERRORS_SYMBOL] !== void 0;
-      }
-      function annotateExternalObject(
-        object,
-        errors2,
-        subschema,
-        subschemaMap
-      ) {
-        Object.defineProperties(object, {
-          [OBJECT_SUBSCHEMA_SYMBOL]: { value: subschema },
-          [FIELD_SUBSCHEMA_MAP_SYMBOL]: { value: subschemaMap },
-          [UNPATHED_ERRORS_SYMBOL]: { value: errors2 },
-        });
-        return object;
-      }
-      function getSubschema(object, responseKey) {
-        var _a2;
-        return (_a2 = object[FIELD_SUBSCHEMA_MAP_SYMBOL][responseKey]) !==
-          null && _a2 !== void 0
-          ? _a2
-          : object[OBJECT_SUBSCHEMA_SYMBOL];
-      }
-      function getUnpathedErrors(object) {
-        return object[UNPATHED_ERRORS_SYMBOL];
-      }
-      const EMPTY_ARRAY = [];
-      const EMPTY_OBJECT = /* @__PURE__ */ Object.create(null);
-      async function mergeFields(
-        mergedTypeInfo,
-        object,
-        sourceSubschema,
-        context,
-        info2
-      ) {
-        var _a2;
-        const delegationMaps = mergedTypeInfo.delegationPlanBuilder(
-          info2.schema,
-          sourceSubschema,
-          info2.variableValues != null &&
-            Object.keys(info2.variableValues).length > 0
-            ? info2.variableValues
-            : EMPTY_OBJECT,
-          info2.fragments != null && Object.keys(info2.fragments).length > 0
-            ? info2.fragments
-            : EMPTY_OBJECT,
-          (
-            (_a2 = info2.fieldNodes) === null || _a2 === void 0
-              ? void 0
-              : _a2.length
-          )
-            ? info2.fieldNodes
-            : EMPTY_ARRAY
-        );
-        for (const delegationMap of delegationMaps) {
-          await executeDelegationStage(
-            mergedTypeInfo,
-            delegationMap,
-            object,
-            context,
-            info2
-          );
-        }
-        return object;
-      }
-      async function executeDelegationStage(
-        mergedTypeInfo,
-        delegationMap,
-        object,
-        context,
-        info2
-      ) {
-        const combinedErrors = object[UNPATHED_ERRORS_SYMBOL];
-        const path = pathToArray$1(info2.path);
-        const combinedFieldSubschemaMap = object[FIELD_SUBSCHEMA_MAP_SYMBOL];
-        await Promise.all(
-          [...delegationMap.entries()].map(
-            async ([subschema, selectionSet]) => {
-              var _a2;
-              const schema = subschema.transformedSchema || info2.schema;
-              const type2 = schema.getType(object.__typename);
-              const resolver = mergedTypeInfo.resolvers.get(subschema);
-              if (resolver) {
-                let source;
-                try {
-                  source = await resolver(
-                    object,
-                    context,
-                    info2,
-                    subschema,
-                    selectionSet,
-                    void 0,
-                    type2
-                  );
-                } catch (error2) {
-                  source = error2;
-                }
-                if (source instanceof Error || source == null) {
-                  const fieldNodeResponseKeyMap = collectFields(
-                    schema,
-                    EMPTY_OBJECT,
-                    EMPTY_OBJECT,
-                    type2,
-                    selectionSet,
-                    /* @__PURE__ */ new Map(),
-                    /* @__PURE__ */ new Set()
-                  );
-                  const nullResult = {};
-                  for (const [
-                    responseKey,
-                    fieldNodes,
-                  ] of fieldNodeResponseKeyMap) {
-                    const combinedPath = [...path, responseKey];
-                    if (source instanceof GraphQLError) {
-                      nullResult[responseKey] = relocatedError(
-                        source,
-                        combinedPath
-                      );
-                    } else if (source instanceof Error) {
-                      nullResult[responseKey] = locatedError(
-                        source,
-                        fieldNodes,
-                        combinedPath
-                      );
-                    } else {
-                      nullResult[responseKey] = null;
-                    }
-                  }
-                  source = nullResult;
-                } else {
-                  if (source[UNPATHED_ERRORS_SYMBOL]) {
-                    combinedErrors.push(...source[UNPATHED_ERRORS_SYMBOL]);
-                  }
-                }
-                const objectSubschema = source[OBJECT_SUBSCHEMA_SYMBOL];
-                const fieldSubschemaMap = source[FIELD_SUBSCHEMA_MAP_SYMBOL];
-                for (const responseKey in source) {
-                  object[responseKey] = source[responseKey];
-                  combinedFieldSubschemaMap[responseKey] =
-                    (_a2 =
-                      fieldSubschemaMap === null || fieldSubschemaMap === void 0
-                        ? void 0
-                        : fieldSubschemaMap[responseKey]) !== null &&
-                    _a2 !== void 0
-                      ? _a2
-                      : objectSubschema;
-                }
-              }
-            }
-          )
-        );
-      }
-      function resolveExternalValue(
-        result2,
-        unpathedErrors,
-        subschema,
-        context,
-        info2,
-        returnType = getReturnType(info2),
-        skipTypeMerging
-      ) {
-        const type2 = getNullableType(returnType);
-        if (result2 instanceof Error) {
-          return result2;
-        }
-        if (result2 == null) {
-          return reportUnpathedErrorsViaNull(unpathedErrors);
-        }
-        if ("parseValue" in type2) {
-          return type2.parseValue(result2);
-        } else if (isCompositeType(type2)) {
-          return resolveExternalObject(
-            type2,
-            result2,
-            unpathedErrors,
-            subschema,
-            context,
-            info2,
-            skipTypeMerging
-          );
-        } else if (isListType(type2)) {
-          return resolveExternalList(
-            type2,
-            result2,
-            unpathedErrors,
-            subschema,
-            context,
-            info2,
-            skipTypeMerging
-          );
-        }
-      }
-      function resolveExternalObject(
-        type2,
-        object,
-        unpathedErrors,
-        subschema,
-        context,
-        info2,
-        skipTypeMerging
-      ) {
-        var _a2;
-        if (!isExternalObject(object)) {
-          annotateExternalObject(
-            object,
-            unpathedErrors,
-            subschema,
-            /* @__PURE__ */ Object.create(null)
-          );
-        }
-        if (skipTypeMerging || info2 == null) {
-          return object;
-        }
-        const stitchingInfo =
-          (_a2 = info2.schema.extensions) === null || _a2 === void 0
-            ? void 0
-            : _a2["stitchingInfo"];
-        if (stitchingInfo == null) {
-          return object;
-        }
-        const typeName = isAbstractType(type2) ? object.__typename : type2.name;
-        const mergedTypeInfo = stitchingInfo.mergedTypes[typeName];
-        let targetSubschemas;
-        if (mergedTypeInfo != null) {
-          targetSubschemas = mergedTypeInfo.targetSubschemas.get(subschema);
-        }
-        if (!targetSubschemas || !targetSubschemas.length) {
-          return object;
-        }
-        return mergeFields(mergedTypeInfo, object, subschema, context, info2);
-      }
-      function resolveExternalList(
-        type2,
-        list3,
-        unpathedErrors,
-        subschema,
-        context,
-        info2,
-        skipTypeMerging
-      ) {
-        return list3.map((listMember) =>
-          resolveExternalListMember(
-            getNullableType(type2.ofType),
-            listMember,
-            unpathedErrors,
-            subschema,
-            context,
-            info2,
-            skipTypeMerging
-          )
-        );
-      }
-      function resolveExternalListMember(
-        type2,
-        listMember,
-        unpathedErrors,
-        subschema,
-        context,
-        info2,
-        skipTypeMerging
-      ) {
-        if (listMember instanceof Error) {
-          return listMember;
-        }
-        if (listMember == null) {
-          return reportUnpathedErrorsViaNull(unpathedErrors);
-        }
-        if ("parseValue" in type2) {
-          return type2.parseValue(listMember);
-        } else if (isCompositeType(type2)) {
-          return resolveExternalObject(
-            type2,
-            listMember,
-            unpathedErrors,
-            subschema,
-            context,
-            info2,
-            skipTypeMerging
-          );
-        } else if (isListType(type2)) {
-          return resolveExternalList(
-            type2,
-            listMember,
-            unpathedErrors,
-            subschema,
-            context,
-            info2,
-            skipTypeMerging
-          );
-        }
-      }
-      const reportedErrors = /* @__PURE__ */ new WeakMap();
-      function reportUnpathedErrorsViaNull(unpathedErrors) {
-        if (unpathedErrors.length) {
-          const unreportedErrors = [];
-          for (const error2 of unpathedErrors) {
-            if (!reportedErrors.has(error2)) {
-              unreportedErrors.push(error2);
-              reportedErrors.set(error2, true);
-            }
-          }
-          if (unreportedErrors.length) {
-            if (unreportedErrors.length === 1) {
-              return unreportedErrors[0];
-            }
-            const combinedError = new AggregateErrorImpl(
-              unreportedErrors,
-              unreportedErrors.map((error2) => error2.message).join(", \n")
-            );
-            return locatedError(
-              combinedError,
-              void 0,
-              unreportedErrors[0].path
-            );
-          }
-        }
-        return null;
-      }
-      function getReturnType(info2) {
-        if (info2 == null) {
-          throw new Error(
-            `Return type cannot be inferred without a source schema.`
-          );
-        }
-        return info2.returnType;
-      }
-      function checkResultAndHandleErrors(result2, delegationContext) {
-        const {
-          context,
-          info: info2,
-          fieldName: responseKey = getResponseKey(info2),
-          subschema,
-          returnType = getReturnType$1(info2),
-          skipTypeMerging,
-          onLocatedError,
-        } = delegationContext;
-        const { data, unpathedErrors } = mergeDataAndErrors(
-          result2.data == null ? void 0 : result2.data[responseKey],
-          result2.errors == null ? [] : result2.errors,
-          info2 != null && info2.path ? pathToArray$1(info2.path) : void 0,
-          onLocatedError
-        );
-        return resolveExternalValue(
-          data,
-          unpathedErrors,
-          subschema,
-          context,
-          info2,
-          returnType,
-          skipTypeMerging
-        );
-      }
-      function mergeDataAndErrors(
-        data,
-        errors2,
-        path,
-        onLocatedError,
-        index = 1
-      ) {
-        var _a2;
-        if (data == null) {
-          if (!errors2.length) {
-            return { data: null, unpathedErrors: [] };
-          }
-          if (errors2.length === 1) {
-            const error2 = onLocatedError
-              ? onLocatedError(errors2[0])
-              : errors2[0];
-            const newPath =
-              path === void 0
-                ? error2.path
-                : error2.path === void 0
-                ? path
-                : path.concat(error2.path.slice(1));
-            return {
-              data: relocatedError(errors2[0], newPath),
-              unpathedErrors: [],
-            };
-          }
-          const combinedError = new AggregateErrorImpl(
-            errors2,
-            errors2.map((error2) => error2.message).join(", \n")
-          );
-          const newError = locatedError(combinedError, void 0, path);
-          return { data: newError, unpathedErrors: [] };
-        }
-        if (!errors2.length) {
-          return { data, unpathedErrors: [] };
-        }
-        const unpathedErrors = [];
-        const errorMap = /* @__PURE__ */ new Map();
-        for (const error2 of errors2) {
-          const pathSegment =
-            (_a2 = error2.path) === null || _a2 === void 0
-              ? void 0
-              : _a2[index];
-          if (pathSegment != null) {
-            let pathSegmentErrors = errorMap.get(pathSegment);
-            if (pathSegmentErrors === void 0) {
-              pathSegmentErrors = [error2];
-              errorMap.set(pathSegment, pathSegmentErrors);
-            } else {
-              pathSegmentErrors.push(error2);
-            }
-          } else {
-            unpathedErrors.push(error2);
-          }
-        }
-        for (const [pathSegment, pathSegmentErrors] of errorMap) {
-          if (data[pathSegment] !== void 0) {
-            const { data: newData, unpathedErrors: newErrors } =
-              mergeDataAndErrors(
-                data[pathSegment],
-                pathSegmentErrors,
-                path,
-                onLocatedError,
-                index + 1
-              );
-            data[pathSegment] = newData;
-            unpathedErrors.push(...newErrors);
-          } else {
-            unpathedErrors.push(...pathSegmentErrors);
-          }
-        }
-        return { data, unpathedErrors };
-      }
-      function getResponseKey(info2) {
-        if (info2 == null) {
-          throw new Error(
-            `Data cannot be extracted from result without an explicit key or source schema.`
-          );
-        }
-        return getResponseKeyFromInfo(info2);
-      }
-      function getReturnType$1(info2) {
-        if (info2 == null) {
-          throw new Error(
-            `Return type cannot be inferred without a source schema.`
-          );
-        }
-        return info2.returnType;
-      }
-      class Transformer {
-        constructor(context) {
-          this.transformations = [];
-          this.delegationContext = context;
-          const transforms = context.transforms;
-          const delegationTransforms = transforms.slice().reverse();
-          for (const transform of delegationTransforms) {
-            this.addTransform(transform, {});
-          }
-        }
-        addTransform(transform, context = {}) {
-          this.transformations.push({ transform, context });
-        }
-        transformRequest(originalRequest) {
-          var _a2;
-          let request = __spreadProps(__spreadValues({}, originalRequest), {
-            document: prepareGatewayDocument(
-              originalRequest.document,
-              this.delegationContext.transformedSchema,
-              this.delegationContext.returnType,
-              (_a2 = this.delegationContext.info) === null || _a2 === void 0
-                ? void 0
-                : _a2.schema
-            ),
-          });
-          for (const transformation of this.transformations) {
-            if (transformation.transform.transformRequest) {
-              request = transformation.transform.transformRequest(
-                request,
-                this.delegationContext,
-                transformation.context
-              );
-            }
-          }
-          return finalizeGatewayRequest(request, this.delegationContext);
-        }
-        transformResult(originalResult) {
-          let result2 = originalResult;
-          for (let i = this.transformations.length - 1; i >= 0; i--) {
-            const transformation = this.transformations[i];
-            if (transformation.transform.transformResult) {
-              result2 = transformation.transform.transformResult(
-                result2,
-                this.delegationContext,
-                transformation.context
-              );
-            }
-          }
-          return checkResultAndHandleErrors(result2, this.delegationContext);
-        }
-      }
-      function getDelegatingOperation(parentType, schema) {
-        if (parentType === schema.getMutationType()) {
-          return "mutation";
-        } else if (parentType === schema.getSubscriptionType()) {
-          return "subscription";
-        }
-        return "query";
-      }
-      function createRequest({
-        sourceSchema,
-        sourceParentType,
-        sourceFieldName,
-        fragments,
-        variableDefinitions,
-        variableValues,
-        targetRootValue,
-        targetOperationName,
-        targetOperation,
-        targetFieldName,
-        selectionSet,
-        fieldNodes,
-        context,
-        info: info2,
-      }) {
-        var _a2, _b;
-        let newSelectionSet;
-        const argumentNodeMap = /* @__PURE__ */ Object.create(null);
-        if (selectionSet != null) {
-          newSelectionSet = selectionSet;
-        } else {
-          const selections = [];
-          for (const fieldNode of fieldNodes || []) {
-            if (fieldNode.selectionSet) {
-              for (const selection of fieldNode.selectionSet.selections) {
-                selections.push(selection);
-              }
-            }
-          }
-          newSelectionSet = selections.length
-            ? {
-                kind: Kind.SELECTION_SET,
-                selections,
-              }
-            : void 0;
-          const args =
-            (_a2 =
-              fieldNodes === null || fieldNodes === void 0
-                ? void 0
-                : fieldNodes[0]) === null || _a2 === void 0
-              ? void 0
-              : _a2.arguments;
-          if (args) {
-            for (const argNode of args) {
-              argumentNodeMap[argNode.name.value] = argNode;
-            }
-          }
-        }
-        const newVariables = /* @__PURE__ */ Object.create(null);
-        const variableDefinitionMap = /* @__PURE__ */ Object.create(null);
-        if (sourceSchema != null && variableDefinitions != null) {
-          for (const def of variableDefinitions) {
-            const varName = def.variable.name.value;
-            variableDefinitionMap[varName] = def;
-            const varType = typeFromAST(sourceSchema, def.type);
-            const serializedValue = serializeInputValue(
-              varType,
-              variableValues === null || variableValues === void 0
-                ? void 0
-                : variableValues[varName]
-            );
-            if (serializedValue !== void 0) {
-              newVariables[varName] = serializedValue;
-            }
-          }
-        }
-        if (sourceParentType != null && sourceFieldName != null) {
-          updateArgumentsWithDefaults(
-            sourceParentType,
-            sourceFieldName,
-            argumentNodeMap,
-            variableDefinitionMap,
-            newVariables
-          );
-        }
-        const rootFieldName =
-          targetFieldName !== null && targetFieldName !== void 0
-            ? targetFieldName
-            : (_b =
-                fieldNodes === null || fieldNodes === void 0
-                  ? void 0
-                  : fieldNodes[0]) === null || _b === void 0
-            ? void 0
-            : _b.name.value;
-        if (rootFieldName === void 0) {
-          throw new Error(
-            `Either "targetFieldName" or a non empty "fieldNodes" array must be provided.`
-          );
-        }
-        const rootfieldNode = {
-          kind: Kind.FIELD,
-          arguments: Object.values(argumentNodeMap),
-          name: {
-            kind: Kind.NAME,
-            value: rootFieldName,
-          },
-          selectionSet: newSelectionSet,
-        };
-        const operationName = targetOperationName
-          ? {
-              kind: Kind.NAME,
-              value: targetOperationName,
-            }
-          : void 0;
-        const operationDefinition = {
-          kind: Kind.OPERATION_DEFINITION,
-          name: operationName,
-          operation: targetOperation,
-          variableDefinitions: Object.values(variableDefinitionMap),
-          selectionSet: {
-            kind: Kind.SELECTION_SET,
-            selections: [rootfieldNode],
-          },
-        };
-        const definitions = [operationDefinition];
-        if (fragments != null) {
-          for (const fragmentName in fragments) {
-            const fragment = fragments[fragmentName];
-            definitions.push(fragment);
-          }
-        }
-        const document2 = {
-          kind: Kind.DOCUMENT,
-          definitions,
-        };
-        return {
-          document: document2,
-          variables: newVariables,
-          rootValue: targetRootValue,
-          operationName: targetOperationName,
-          context,
-          info: info2,
-          operationType: targetOperation,
-        };
-      }
-      function updateArgumentsWithDefaults(
-        sourceParentType,
-        sourceFieldName,
-        argumentNodeMap,
-        variableDefinitionMap,
-        variableValues
-      ) {
-        const generateVariableName = createVariableNameGenerator(
-          variableDefinitionMap
-        );
-        const sourceField = sourceParentType.getFields()[sourceFieldName];
-        for (const argument of sourceField.args) {
-          const argName = argument.name;
-          const sourceArgType = argument.type;
-          if (argumentNodeMap[argName] === void 0) {
-            const defaultValue2 = argument.defaultValue;
-            if (defaultValue2 !== void 0) {
-              updateArgument(
-                argumentNodeMap,
-                variableDefinitionMap,
-                variableValues,
-                argName,
-                generateVariableName(argName),
-                sourceArgType,
-                serializeInputValue(sourceArgType, defaultValue2)
-              );
-            }
-          }
-        }
-      }
-      function defaultMergedResolver(parent, args, context, info2) {
-        if (!parent) {
-          return null;
-        }
-        const responseKey = getResponseKeyFromInfo(info2);
-        if (!isExternalObject(parent)) {
-          return defaultFieldResolver$1(parent, args, context, info2);
-        }
-        const data = parent[responseKey];
-        const unpathedErrors = getUnpathedErrors(parent);
-        const subschema = getSubschema(parent, responseKey);
-        return resolveExternalValue(
-          data,
-          unpathedErrors,
-          subschema,
-          context,
-          info2
-        );
-      }
-      function isSubschemaConfig(value) {
-        return Boolean(
-          value === null || value === void 0 ? void 0 : value.schema
-        );
-      }
-      function delegateToSchema(options) {
-        var _a2, _b;
-        const {
-          info: info2,
-          schema,
-          rootValue = (_a2 = schema.rootValue) !== null && _a2 !== void 0
-            ? _a2
-            : info2.rootValue,
-          operationName = (_b = info2.operation.name) === null || _b === void 0
-            ? void 0
-            : _b.value,
-          operation = getDelegatingOperation(info2.parentType, info2.schema),
-          fieldName = info2.fieldName,
-          selectionSet,
-          fieldNodes = info2.fieldNodes,
-          context,
-        } = options;
-        const request = createRequest({
-          sourceSchema: info2.schema,
-          sourceParentType: info2.parentType,
-          sourceFieldName: info2.fieldName,
-          fragments: info2.fragments,
-          variableDefinitions: info2.operation.variableDefinitions,
-          variableValues: info2.variableValues,
-          targetRootValue: rootValue,
-          targetOperationName: operationName,
-          targetOperation: operation,
-          targetFieldName: fieldName,
-          selectionSet,
-          fieldNodes,
-          context,
-          info: info2,
-        });
-        return delegateRequest(
-          __spreadProps(__spreadValues({}, options), {
-            request,
-          })
-        );
-      }
-      function getDelegationReturnType(targetSchema, operation, fieldName) {
-        const rootType = getDefinedRootType(targetSchema, operation);
-        return rootType.getFields()[fieldName].type;
-      }
-      function delegateRequest(options) {
-        const delegationContext = getDelegationContext(options);
-        const transformer = new Transformer(delegationContext);
-        const processedRequest = transformer.transformRequest(options.request);
-        if (options.validateRequest) {
-          validateRequest(delegationContext, processedRequest.document);
-        }
-        const executor = getExecutor(delegationContext);
-        return new ValueOrPromise(() => executor(processedRequest))
-          .then((originalResult) => {
-            if (isAsyncIterable$1(originalResult)) {
-              const iterator = originalResult[Symbol.asyncIterator]();
-              return mapAsyncIterator(iterator, (result2) =>
-                transformer.transformResult(result2)
-              );
-            }
-            return transformer.transformResult(originalResult);
-          })
-          .resolve();
-      }
-      function getDelegationContext({
-        request,
-        schema,
-        fieldName,
-        returnType,
-        args,
-        info: info2,
-        transforms = [],
-        transformedSchema,
-        skipTypeMerging = false,
-      }) {
-        var _a2, _b, _c, _d;
-        const operationDefinition = getOperationASTFromRequest(request);
-        let targetFieldName;
-        if (fieldName == null) {
-          targetFieldName =
-            operationDefinition.selectionSet.selections[0].name.value;
-        } else {
-          targetFieldName = fieldName;
-        }
-        const stitchingInfo =
-          (_a2 =
-            info2 === null || info2 === void 0
-              ? void 0
-              : info2.schema.extensions) === null || _a2 === void 0
-            ? void 0
-            : _a2["stitchingInfo"];
-        const subschemaOrSubschemaConfig =
-          (_b =
-            stitchingInfo === null || stitchingInfo === void 0
-              ? void 0
-              : stitchingInfo.subschemaMap.get(schema)) !== null &&
-          _b !== void 0
-            ? _b
-            : schema;
-        const operation = operationDefinition.operation;
-        if (isSubschemaConfig(subschemaOrSubschemaConfig)) {
-          const targetSchema = subschemaOrSubschemaConfig.schema;
-          return {
-            subschema: schema,
-            subschemaConfig: subschemaOrSubschemaConfig,
-            targetSchema,
-            operation,
-            fieldName: targetFieldName,
-            args,
-            context: request.context,
-            info: info2,
-            returnType:
-              (_c =
-                returnType !== null && returnType !== void 0
-                  ? returnType
-                  : info2 === null || info2 === void 0
-                  ? void 0
-                  : info2.returnType) !== null && _c !== void 0
-                ? _c
-                : getDelegationReturnType(
-                    targetSchema,
-                    operation,
-                    targetFieldName
-                  ),
-            transforms:
-              subschemaOrSubschemaConfig.transforms != null
-                ? subschemaOrSubschemaConfig.transforms.concat(transforms)
-                : transforms,
-            transformedSchema:
-              transformedSchema !== null && transformedSchema !== void 0
-                ? transformedSchema
-                : subschemaOrSubschemaConfig instanceof Subschema
-                ? subschemaOrSubschemaConfig.transformedSchema
-                : targetSchema,
-            skipTypeMerging,
-          };
-        }
-        return {
-          subschema: schema,
-          subschemaConfig: void 0,
-          targetSchema: subschemaOrSubschemaConfig,
-          operation,
-          fieldName: targetFieldName,
-          args,
-          context: request.context,
-          info: info2,
-          returnType:
-            (_d =
-              returnType !== null && returnType !== void 0
-                ? returnType
-                : info2 === null || info2 === void 0
-                ? void 0
-                : info2.returnType) !== null && _d !== void 0
-              ? _d
-              : getDelegationReturnType(
-                  subschemaOrSubschemaConfig,
-                  operation,
-                  targetFieldName
-                ),
-          transforms,
-          transformedSchema:
-            transformedSchema !== null && transformedSchema !== void 0
-              ? transformedSchema
-              : subschemaOrSubschemaConfig,
-          skipTypeMerging,
-        };
-      }
-      function validateRequest(delegationContext, document2) {
-        const errors2 = validate(delegationContext.targetSchema, document2);
-        if (errors2.length > 0) {
-          if (errors2.length > 1) {
-            const combinedError = new AggregateErrorImpl(
-              errors2,
-              errors2.map((error3) => error3.message).join(", \n")
-            );
-            throw combinedError;
-          }
-          const error2 = errors2[0];
-          throw error2.originalError || error2;
-        }
-      }
-      const GLOBAL_CONTEXT = {};
-      function getExecutor(delegationContext) {
-        const { subschemaConfig, targetSchema, context } = delegationContext;
-        let executor =
-          (subschemaConfig === null || subschemaConfig === void 0
-            ? void 0
-            : subschemaConfig.executor) || createDefaultExecutor(targetSchema);
-        if (
-          subschemaConfig === null || subschemaConfig === void 0
-            ? void 0
-            : subschemaConfig.batch
-        ) {
-          const batchingOptions =
-            subschemaConfig === null || subschemaConfig === void 0
-              ? void 0
-              : subschemaConfig.batchingOptions;
-          executor = getBatchingExecutor(
-            context !== null && context !== void 0 ? context : GLOBAL_CONTEXT,
-            executor,
-            batchingOptions === null || batchingOptions === void 0
-              ? void 0
-              : batchingOptions.dataLoaderOptions,
-            batchingOptions === null || batchingOptions === void 0
-              ? void 0
-              : batchingOptions.extensionsReducer
-          );
-        }
-        return executor;
-      }
-      const createDefaultExecutor = memoize1$1(function createDefaultExecutor2(
-        schema
-      ) {
-        const executorInstance = new Executor({ schema });
-        return function defaultExecutor(request) {
-          const executionArgs = {
-            document: request.document,
-            rootValue: request.rootValue,
-            contextValue: request.context,
-            variableValues: request.variables,
-            operationName: request.operationName,
-          };
-          return executorInstance.execute(executionArgs);
-        };
-      });
-      function generateProxyingResolvers(subschemaConfig) {
-        var _a2;
-        const targetSchema = subschemaConfig.schema;
-        const createProxyingResolver =
-          (_a2 = subschemaConfig.createProxyingResolver) !== null &&
-          _a2 !== void 0
-            ? _a2
-            : defaultCreateProxyingResolver;
-        const transformedSchema = applySchemaTransforms(
-          targetSchema,
-          subschemaConfig
-        );
-        const rootTypeMap = getRootTypeMap(targetSchema);
-        const resolvers = {};
-        for (const [operation, rootType] of rootTypeMap.entries()) {
-          const typeName = rootType.name;
-          const fields = rootType.getFields();
-          resolvers[typeName] = {};
-          for (const fieldName in fields) {
-            const proxyingResolver = createProxyingResolver({
-              subschemaConfig,
-              transformedSchema,
-              operation,
-              fieldName,
-            });
-            const finalResolver = createPossiblyNestedProxyingResolver(
-              subschemaConfig,
-              proxyingResolver
-            );
-            if (operation === "subscription") {
-              resolvers[typeName][fieldName] = {
-                subscribe: finalResolver,
-                resolve: identical,
-              };
-            } else {
-              resolvers[typeName][fieldName] = {
-                resolve: finalResolver,
-              };
-            }
-          }
-        }
-        return resolvers;
-      }
-      function identical(value) {
-        return value;
-      }
-      function createPossiblyNestedProxyingResolver(
-        subschemaConfig,
-        proxyingResolver
-      ) {
-        return function possiblyNestedProxyingResolver(
-          parent,
-          args,
-          context,
-          info2
-        ) {
-          if (parent != null) {
-            const responseKey = getResponseKeyFromInfo(info2);
-            if (isExternalObject(parent)) {
-              const unpathedErrors = getUnpathedErrors(parent);
-              const subschema = getSubschema(parent, responseKey);
-              if (
-                subschemaConfig === subschema &&
-                parent[responseKey] !== void 0
-              ) {
-                return resolveExternalValue(
-                  parent[responseKey],
-                  unpathedErrors,
-                  subschema,
-                  context,
-                  info2
-                );
-              }
-            }
-          }
-          return proxyingResolver(parent, args, context, info2);
-        };
-      }
-      function defaultCreateProxyingResolver({
-        subschemaConfig,
-        operation,
-        transformedSchema,
-      }) {
-        return function proxyingResolver(_parent, _args, context, info2) {
-          return delegateToSchema({
-            schema: subschemaConfig,
-            operation,
-            context,
-            info: info2,
-            transformedSchema,
-          });
-        };
-      }
-      function wrapSchema(subschemaConfig) {
-        const targetSchema = subschemaConfig.schema;
-        const proxyingResolvers = generateProxyingResolvers(subschemaConfig);
-        const schema = createWrappingSchema(targetSchema, proxyingResolvers);
-        const transformedSchema = applySchemaTransforms(
-          schema,
-          subschemaConfig
-        );
-        return applySchemaTransforms(
-          schema,
-          subschemaConfig,
-          transformedSchema
-        );
-      }
-      function createWrappingSchema(schema, proxyingResolvers) {
-        return mapSchema(schema, {
-          [MapperKind.ROOT_OBJECT]: (type2) => {
-            var _a2;
-            const config2 = type2.toConfig();
-            const fieldConfigMap = config2.fields;
-            for (const fieldName in fieldConfigMap) {
-              const field = fieldConfigMap[fieldName];
-              if (field == null) {
-                continue;
-              }
-              fieldConfigMap[fieldName] = __spreadValues(
-                __spreadValues({}, field),
-                (_a2 = proxyingResolvers[type2.name]) === null || _a2 === void 0
-                  ? void 0
-                  : _a2[fieldName]
-              );
-            }
-            return new GraphQLObjectType(config2);
-          },
-          [MapperKind.OBJECT_TYPE]: (type2) => {
-            const config2 = type2.toConfig();
-            config2.isTypeOf = void 0;
-            for (const fieldName in config2.fields) {
-              const field = config2.fields[fieldName];
-              if (field == null) {
-                continue;
-              }
-              field.resolve = defaultMergedResolver;
-              field.subscribe = void 0;
-            }
-            return new GraphQLObjectType(config2);
-          },
-          [MapperKind.INTERFACE_TYPE]: (type2) => {
-            const config2 = type2.toConfig();
-            delete config2.resolveType;
-            return new GraphQLInterfaceType(config2);
-          },
-          [MapperKind.UNION_TYPE]: (type2) => {
-            const config2 = type2.toConfig();
-            delete config2.resolveType;
-            return new GraphQLUnionType(config2);
-          },
-        });
-      }
-      function getSchemaFromIntrospection(introspectionResult, options) {
-        var _a2;
-        if (
-          (_a2 =
-            introspectionResult === null || introspectionResult === void 0
-              ? void 0
-              : introspectionResult.data) === null || _a2 === void 0
-            ? void 0
-            : _a2.__schema
-        ) {
-          return buildClientSchema(introspectionResult.data, options);
-        }
-        throw new Error(
-          "Could not obtain introspection result, received: " +
-            JSON.stringify(introspectionResult)
-        );
-      }
-      function introspectSchema(executor, context, options) {
-        const parsedIntrospectionQuery = parse$1(
-          getIntrospectionQuery(options),
-          options
-        );
-        return new ValueOrPromise(() =>
-          executor({
-            document: parsedIntrospectionQuery,
-            context,
-          })
-        )
-          .then((introspection2) => {
-            if (isAsyncIterable$1(introspection2)) {
-              const iterator = introspection2[Symbol.asyncIterator]();
-              return iterator.next().then(({ value }) => value);
-            }
-            return introspection2;
-          })
-          .then((introspection2) =>
-            getSchemaFromIntrospection(introspection2, options)
-          )
-          .resolve();
-      }
-      const baseHasOwnProperty = Object.prototype.hasOwnProperty;
-      function isObject$3(val) {
-        return typeof val === "object" && val !== null;
-      }
-      function areGraphQLErrors(obj) {
-        return (
-          Array.isArray(obj) &&
-          obj.length > 0 &&
-          obj.every((ob2) => "message" in ob2)
-        );
-      }
-      function hasOwnProperty(obj, prop2) {
-        return baseHasOwnProperty.call(obj, prop2);
-      }
-      function hasOwnObjectProperty(obj, prop2) {
-        return baseHasOwnProperty.call(obj, prop2) && isObject$3(obj[prop2]);
-      }
-      function hasOwnStringProperty(obj, prop2) {
-        return (
-          baseHasOwnProperty.call(obj, prop2) && typeof obj[prop2] === "string"
-        );
-      }
-      function limitCloseReason(reason, whenTooLong) {
-        return reason.length < 124 ? reason : whenTooLong;
-      }
-      const GRAPHQL_TRANSPORT_WS_PROTOCOL = "graphql-transport-ws";
-      var CloseCode;
-      (function (CloseCode2) {
-        CloseCode2[(CloseCode2["InternalServerError"] = 4500)] =
-          "InternalServerError";
-        CloseCode2[(CloseCode2["InternalClientError"] = 4005)] =
-          "InternalClientError";
-        CloseCode2[(CloseCode2["BadRequest"] = 4400)] = "BadRequest";
-        CloseCode2[(CloseCode2["BadResponse"] = 4004)] = "BadResponse";
-        CloseCode2[(CloseCode2["Unauthorized"] = 4401)] = "Unauthorized";
-        CloseCode2[(CloseCode2["Forbidden"] = 4403)] = "Forbidden";
-        CloseCode2[(CloseCode2["SubprotocolNotAcceptable"] = 4406)] =
-          "SubprotocolNotAcceptable";
-        CloseCode2[(CloseCode2["ConnectionInitialisationTimeout"] = 4408)] =
-          "ConnectionInitialisationTimeout";
-        CloseCode2[(CloseCode2["ConnectionAcknowledgementTimeout"] = 4504)] =
-          "ConnectionAcknowledgementTimeout";
-        CloseCode2[(CloseCode2["SubscriberAlreadyExists"] = 4409)] =
-          "SubscriberAlreadyExists";
-        CloseCode2[(CloseCode2["TooManyInitialisationRequests"] = 4429)] =
-          "TooManyInitialisationRequests";
-      })(CloseCode || (CloseCode = {}));
-      var MessageType;
-      (function (MessageType2) {
-        MessageType2["ConnectionInit"] = "connection_init";
-        MessageType2["ConnectionAck"] = "connection_ack";
-        MessageType2["Ping"] = "ping";
-        MessageType2["Pong"] = "pong";
-        MessageType2["Subscribe"] = "subscribe";
-        MessageType2["Next"] = "next";
-        MessageType2["Error"] = "error";
-        MessageType2["Complete"] = "complete";
-      })(MessageType || (MessageType = {}));
-      function isMessage(val) {
-        if (isObject$3(val)) {
-          if (!hasOwnStringProperty(val, "type")) {
-            return false;
-          }
-          switch (val.type) {
-            case MessageType.ConnectionInit:
-              return (
-                !hasOwnProperty(val, "payload") ||
-                val.payload === void 0 ||
-                isObject$3(val.payload)
-              );
-            case MessageType.ConnectionAck:
-            case MessageType.Ping:
-            case MessageType.Pong:
-              return (
-                !hasOwnProperty(val, "payload") ||
-                val.payload === void 0 ||
-                isObject$3(val.payload)
-              );
-            case MessageType.Subscribe:
-              return (
-                hasOwnStringProperty(val, "id") &&
-                hasOwnObjectProperty(val, "payload") &&
-                (!hasOwnProperty(val.payload, "operationName") ||
-                  val.payload.operationName === void 0 ||
-                  val.payload.operationName === null ||
-                  typeof val.payload.operationName === "string") &&
-                hasOwnStringProperty(val.payload, "query") &&
-                (!hasOwnProperty(val.payload, "variables") ||
-                  val.payload.variables === void 0 ||
-                  val.payload.variables === null ||
-                  hasOwnObjectProperty(val.payload, "variables")) &&
-                (!hasOwnProperty(val.payload, "extensions") ||
-                  val.payload.extensions === void 0 ||
-                  val.payload.extensions === null ||
-                  hasOwnObjectProperty(val.payload, "extensions"))
-              );
-            case MessageType.Next:
-              return (
-                hasOwnStringProperty(val, "id") &&
-                hasOwnObjectProperty(val, "payload")
-              );
-            case MessageType.Error:
-              return (
-                hasOwnStringProperty(val, "id") && areGraphQLErrors(val.payload)
-              );
-            case MessageType.Complete:
-              return hasOwnStringProperty(val, "id");
-            default:
-              return false;
-          }
-        }
-        return false;
-      }
-      function parseMessage(data, reviver) {
-        if (isMessage(data)) {
-          return data;
-        }
-        if (typeof data !== "string") {
-          throw new Error("Message not parsable");
-        }
-        const message = JSON.parse(data, reviver);
-        if (!isMessage(message)) {
-          throw new Error("Invalid message");
-        }
-        return message;
-      }
-      function stringifyMessage(msg, replacer) {
-        if (!isMessage(msg)) {
-          throw new Error("Cannot stringify invalid message");
-        }
-        return JSON.stringify(msg, replacer);
-      }
-      function createClient$1(options) {
-        const {
-          url,
-          connectionParams,
-          lazy = true,
-          onNonLazyError = console.error,
-          lazyCloseTimeout = 0,
-          keepAlive = 0,
-          disablePong,
-          connectionAckWaitTimeout = 0,
-          retryAttempts = 5,
-          retryWait = async function randomisedExponentialBackoff(retries2) {
-            let retryDelay = 1e3;
-            for (let i = 0; i < retries2; i++) {
-              retryDelay *= 2;
-            }
-            await new Promise((resolve) =>
-              setTimeout(
-                resolve,
-                retryDelay + Math.floor(Math.random() * (3e3 - 300) + 300)
-              )
-            );
-          },
-          isFatalConnectionProblem = (errOrCloseEvent) =>
-            !isLikeCloseEvent(errOrCloseEvent),
-          on,
-          webSocketImpl,
-          generateID = function generateUUID() {
-            return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
-              /[xy]/g,
-              (c) => {
-                const r2 = (Math.random() * 16) | 0,
-                  v2 = c == "x" ? r2 : (r2 & 3) | 8;
-                return v2.toString(16);
-              }
-            );
-          },
-          jsonMessageReplacer: replacer,
-          jsonMessageReviver: reviver,
-        } = options;
-        let ws2;
-        if (webSocketImpl) {
-          if (!isWebSocket(webSocketImpl)) {
-            throw new Error("Invalid WebSocket implementation provided");
-          }
-          ws2 = webSocketImpl;
-        } else if (typeof WebSocket !== "undefined") {
-          ws2 = WebSocket;
-        } else if (typeof global !== "undefined") {
-          ws2 = global.WebSocket || global.MozWebSocket;
-        } else if (typeof window !== "undefined") {
-          ws2 = window.WebSocket || window.MozWebSocket;
-        }
-        if (!ws2)
-          throw new Error(
-            "WebSocket implementation missing; on Node you can `import WebSocket from 'ws';` and pass `webSocketImpl: WebSocket` to `createClient`"
-          );
-        const WebSocketImpl = ws2;
-        const emitter = (() => {
-          const message = (() => {
-            const listeners3 = {};
-            return {
-              on(id2, listener) {
-                listeners3[id2] = listener;
-                return () => {
-                  delete listeners3[id2];
-                };
-              },
-              emit(message2) {
-                var _a2;
-                if ("id" in message2)
-                  (_a2 = listeners3[message2.id]) === null || _a2 === void 0
-                    ? void 0
-                    : _a2.call(listeners3, message2);
-              },
-            };
-          })();
-          const listeners2 = {
-            connecting: (on === null || on === void 0 ? void 0 : on.connecting)
-              ? [on.connecting]
-              : [],
-            opened: (on === null || on === void 0 ? void 0 : on.opened)
-              ? [on.opened]
-              : [],
-            connected: (on === null || on === void 0 ? void 0 : on.connected)
-              ? [on.connected]
-              : [],
-            ping: (on === null || on === void 0 ? void 0 : on.ping)
-              ? [on.ping]
-              : [],
-            pong: (on === null || on === void 0 ? void 0 : on.pong)
-              ? [on.pong]
-              : [],
-            message: (on === null || on === void 0 ? void 0 : on.message)
-              ? [message.emit, on.message]
-              : [message.emit],
-            closed: (on === null || on === void 0 ? void 0 : on.closed)
-              ? [on.closed]
-              : [],
-            error: (on === null || on === void 0 ? void 0 : on.error)
-              ? [on.error]
-              : [],
-          };
-          return {
-            onMessage: message.on,
-            on(event, listener) {
-              const l2 = listeners2[event];
-              l2.push(listener);
-              return () => {
-                l2.splice(l2.indexOf(listener), 1);
-              };
-            },
-            emit(event, ...args) {
-              for (const listener of [...listeners2[event]]) {
-                listener(...args);
-              }
-            },
-          };
-        })();
-        function errorOrClosed(cb2) {
-          const listening = [
-            emitter.on("error", (err) => {
-              listening.forEach((unlisten) => unlisten());
-              cb2(err);
-            }),
-            emitter.on("closed", (event) => {
-              listening.forEach((unlisten) => unlisten());
-              cb2(event);
-            }),
-          ];
-        }
-        let connecting,
-          locks = 0,
-          retrying = false,
-          retries = 0,
-          disposed = false;
-        async function connect2() {
-          const [socket, throwOnClose] = await (connecting !== null &&
-          connecting !== void 0
-            ? connecting
-            : (connecting = new Promise((connected, denied) =>
-                (async () => {
-                  if (retrying) {
-                    await retryWait(retries);
-                    if (!locks) {
-                      connecting = void 0;
-                      return denied({
-                        code: 1e3,
-                        reason: "All Subscriptions Gone",
-                      });
-                    }
-                    retries++;
-                  }
-                  emitter.emit("connecting");
-                  const socket2 = new WebSocketImpl(
-                    typeof url === "function" ? await url() : url,
-                    GRAPHQL_TRANSPORT_WS_PROTOCOL
-                  );
-                  let connectionAckTimeout, queuedPing;
-                  function enqueuePing() {
-                    if (isFinite(keepAlive) && keepAlive > 0) {
-                      clearTimeout(queuedPing);
-                      queuedPing = setTimeout(() => {
-                        if (socket2.readyState === WebSocketImpl.OPEN) {
-                          socket2.send(
-                            stringifyMessage({ type: MessageType.Ping })
-                          );
-                          emitter.emit("ping", false, void 0);
-                        }
-                      }, keepAlive);
-                    }
-                  }
-                  errorOrClosed((errOrEvent) => {
-                    connecting = void 0;
-                    clearTimeout(connectionAckTimeout);
-                    clearTimeout(queuedPing);
-                    denied(errOrEvent);
-                    if (
-                      isLikeCloseEvent(errOrEvent) &&
-                      errOrEvent.code === 4499
-                    ) {
-                      socket2.close(4499, "Terminated");
-                      socket2.onerror = null;
-                      socket2.onclose = null;
-                    }
-                  });
-                  socket2.onerror = (err) => emitter.emit("error", err);
-                  socket2.onclose = (event) => emitter.emit("closed", event);
-                  socket2.onopen = async () => {
-                    try {
-                      emitter.emit("opened", socket2);
-                      const payload =
-                        typeof connectionParams === "function"
-                          ? await connectionParams()
-                          : connectionParams;
-                      if (socket2.readyState !== WebSocketImpl.OPEN) return;
-                      socket2.send(
-                        stringifyMessage(
-                          payload
-                            ? {
-                                type: MessageType.ConnectionInit,
-                                payload,
-                              }
-                            : {
-                                type: MessageType.ConnectionInit,
-                              },
-                          replacer
-                        )
-                      );
-                      if (
-                        isFinite(connectionAckWaitTimeout) &&
-                        connectionAckWaitTimeout > 0
-                      ) {
-                        connectionAckTimeout = setTimeout(() => {
-                          socket2.close(
-                            CloseCode.ConnectionAcknowledgementTimeout,
-                            "Connection acknowledgement timeout"
-                          );
-                        }, connectionAckWaitTimeout);
-                      }
-                      enqueuePing();
-                    } catch (err) {
-                      emitter.emit("error", err);
-                      socket2.close(
-                        CloseCode.InternalClientError,
-                        limitCloseReason(
-                          err instanceof Error
-                            ? err.message
-                            : new Error(err).message,
-                          "Internal client error"
-                        )
-                      );
-                    }
-                  };
-                  let acknowledged = false;
-                  socket2.onmessage = ({ data }) => {
-                    try {
-                      const message = parseMessage(data, reviver);
-                      emitter.emit("message", message);
-                      if (message.type === "ping" || message.type === "pong") {
-                        emitter.emit(message.type, true, message.payload);
-                        if (message.type === "pong") {
-                          enqueuePing();
-                        } else if (!disablePong) {
-                          socket2.send(
-                            stringifyMessage(
-                              message.payload
-                                ? {
-                                    type: MessageType.Pong,
-                                    payload: message.payload,
-                                  }
-                                : {
-                                    type: MessageType.Pong,
-                                  }
-                            )
-                          );
-                          emitter.emit("pong", false, message.payload);
-                        }
-                        return;
-                      }
-                      if (acknowledged) return;
-                      if (message.type !== MessageType.ConnectionAck)
-                        throw new Error(
-                          `First message cannot be of type ${message.type}`
-                        );
-                      clearTimeout(connectionAckTimeout);
-                      acknowledged = true;
-                      emitter.emit("connected", socket2, message.payload);
-                      retrying = false;
-                      retries = 0;
-                      connected([
-                        socket2,
-                        new Promise((_, reject2) => errorOrClosed(reject2)),
-                      ]);
-                    } catch (err) {
-                      socket2.onmessage = null;
-                      emitter.emit("error", err);
-                      socket2.close(
-                        CloseCode.BadResponse,
-                        limitCloseReason(
-                          err instanceof Error
-                            ? err.message
-                            : new Error(err).message,
-                          "Bad response"
-                        )
-                      );
-                    }
-                  };
-                })()
-              )));
-          if (socket.readyState === WebSocketImpl.CLOSING) await throwOnClose;
-          let release = () => {};
-          const released = new Promise((resolve) => (release = resolve));
-          return [
-            socket,
-            release,
-            Promise.race([
-              released.then(() => {
-                if (!locks) {
-                  const complete = () => socket.close(1e3, "Normal Closure");
-                  if (isFinite(lazyCloseTimeout) && lazyCloseTimeout > 0) {
-                    setTimeout(() => {
-                      if (!locks && socket.readyState === WebSocketImpl.OPEN)
-                        complete();
-                    }, lazyCloseTimeout);
-                  } else {
-                    complete();
-                  }
-                }
-              }),
-              throwOnClose,
-            ]),
-          ];
-        }
-        function shouldRetryConnectOrThrow(errOrCloseEvent) {
-          if (
-            isLikeCloseEvent(errOrCloseEvent) &&
-            (isFatalInternalCloseCode(errOrCloseEvent.code) ||
-              [
-                CloseCode.InternalServerError,
-                CloseCode.InternalClientError,
-                CloseCode.BadRequest,
-                CloseCode.BadResponse,
-                CloseCode.Unauthorized,
-                CloseCode.SubprotocolNotAcceptable,
-                CloseCode.SubscriberAlreadyExists,
-                CloseCode.TooManyInitialisationRequests,
-              ].includes(errOrCloseEvent.code))
-          )
-            throw errOrCloseEvent;
-          if (disposed) return false;
-          if (isLikeCloseEvent(errOrCloseEvent) && errOrCloseEvent.code === 1e3)
-            return locks > 0;
-          if (!retryAttempts || retries >= retryAttempts) throw errOrCloseEvent;
-          if (isFatalConnectionProblem(errOrCloseEvent)) throw errOrCloseEvent;
-          return (retrying = true);
-        }
-        if (!lazy) {
-          (async () => {
-            locks++;
-            for (;;) {
-              try {
-                const [, , throwOnClose] = await connect2();
-                await throwOnClose;
-              } catch (errOrCloseEvent) {
-                try {
-                  if (!shouldRetryConnectOrThrow(errOrCloseEvent)) return;
-                } catch (errOrCloseEvent2) {
-                  return onNonLazyError === null || onNonLazyError === void 0
-                    ? void 0
-                    : onNonLazyError(errOrCloseEvent2);
-                }
-              }
-            }
-          })();
-        }
-        return {
-          on: emitter.on,
-          subscribe(payload, sink) {
-            const id2 = generateID();
-            let done = false,
-              errored = false,
-              releaser = () => {
-                locks--;
-                done = true;
-              };
-            (async () => {
-              locks++;
-              for (;;) {
-                try {
-                  const [socket, release, waitForReleaseOrThrowOnClose] =
-                    await connect2();
-                  if (done) return release();
-                  const unlisten = emitter.onMessage(id2, (message) => {
-                    switch (message.type) {
-                      case MessageType.Next: {
-                        sink.next(message.payload);
-                        return;
-                      }
-                      case MessageType.Error: {
-                        (errored = true), (done = true);
-                        sink.error(message.payload);
-                        releaser();
-                        return;
-                      }
-                      case MessageType.Complete: {
-                        done = true;
-                        releaser();
-                        return;
-                      }
-                    }
-                  });
-                  socket.send(
-                    stringifyMessage(
-                      {
-                        id: id2,
-                        type: MessageType.Subscribe,
-                        payload,
-                      },
-                      replacer
-                    )
-                  );
-                  releaser = () => {
-                    if (!done && socket.readyState === WebSocketImpl.OPEN)
-                      socket.send(
-                        stringifyMessage(
-                          {
-                            id: id2,
-                            type: MessageType.Complete,
-                          },
-                          replacer
-                        )
-                      );
-                    locks--;
-                    done = true;
-                    release();
-                  };
-                  await waitForReleaseOrThrowOnClose.finally(unlisten);
-                  return;
-                } catch (errOrCloseEvent) {
-                  if (!shouldRetryConnectOrThrow(errOrCloseEvent)) return;
-                }
-              }
-            })()
-              .then(() => {
-                if (!errored) sink.complete();
-              })
-              .catch((err) => {
-                sink.error(err);
-              });
-            return () => {
-              if (!done) releaser();
-            };
-          },
-          async dispose() {
-            disposed = true;
-            if (connecting) {
-              const [socket] = await connecting;
-              socket.close(1e3, "Normal Closure");
-            }
-          },
-          terminate() {
-            if (connecting) {
-              emitter.emit("closed", {
-                code: 4499,
-                reason: "Terminated",
-                wasClean: false,
-              });
-            }
-          },
-        };
-      }
-      function isLikeCloseEvent(val) {
-        return isObject$3(val) && "code" in val && "reason" in val;
-      }
-      function isFatalInternalCloseCode(code3) {
-        if ([1e3, 1001, 1006, 1005, 1012, 1013, 1013].includes(code3))
-          return false;
-        return code3 >= 1e3 && code3 <= 1999;
-      }
-      function isWebSocket(val) {
-        return (
-          typeof val === "function" &&
-          "constructor" in val &&
-          "CLOSED" in val &&
-          "CLOSING" in val &&
-          "CONNECTING" in val &&
-          "OPEN" in val
-        );
-      }
-      const TOKEN_HEADER_KEY = "x-graphql-event-stream-token";
-      function validateStreamEvent(e) {
-        e = e;
-        if (e !== "next" && e !== "complete")
-          throw new Error(`Invalid stream event "${e}"`);
-        return e;
-      }
-      function parseStreamData(e, data) {
-        if (data) {
-          try {
-            data = JSON.parse(data);
-          } catch (_a2) {
-            throw new Error("Invalid stream data");
-          }
-        }
-        if (e === "next" && !data)
-          throw new Error('Stream data must be an object for "next" events');
-        return data || null;
-      }
-      function isObject$2(val) {
-        return typeof val === "object" && val !== null;
-      }
-      var ControlChars;
-      (function (ControlChars2) {
-        ControlChars2[(ControlChars2["NewLine"] = 10)] = "NewLine";
-        ControlChars2[(ControlChars2["CchunkiageReturn"] = 13)] =
-          "CchunkiageReturn";
-        ControlChars2[(ControlChars2["Space"] = 32)] = "Space";
-        ControlChars2[(ControlChars2["Colon"] = 58)] = "Colon";
-      })(ControlChars || (ControlChars = {}));
-      function createParser() {
-        let buffer2;
-        let position;
-        let fieldLength;
-        let discardTrailingNewline = false;
-        let message = { event: "", data: "" };
-        let pending = [];
-        const decoder2 = new TextDecoder();
-        return function parse2(chunk) {
-          if (buffer2 === void 0) {
-            buffer2 = chunk;
-            position = 0;
-            fieldLength = -1;
-          } else {
-            const concat2 = new Uint8Array(buffer2.length + chunk.length);
-            concat2.set(buffer2);
-            concat2.set(chunk, buffer2.length);
-            buffer2 = concat2;
-          }
-          const bufLength = buffer2.length;
-          let lineStart = 0;
-          while (position < bufLength) {
-            if (discardTrailingNewline) {
-              if (buffer2[position] === ControlChars.NewLine) {
-                lineStart = ++position;
-              }
-              discardTrailingNewline = false;
-            }
-            let lineEnd = -1;
-            for (; position < bufLength && lineEnd === -1; ++position) {
-              switch (buffer2[position]) {
-                case ControlChars.Colon:
-                  if (fieldLength === -1) {
-                    fieldLength = position - lineStart;
-                  }
-                  break;
-                case ControlChars.CchunkiageReturn:
-                  discardTrailingNewline = true;
-                case ControlChars.NewLine:
-                  lineEnd = position;
-                  break;
-              }
-            }
-            if (lineEnd === -1) {
-              break;
-            } else if (lineStart === lineEnd) {
-              if (message.event || message.data) {
-                if (!message.event) throw new Error("Missing message event");
-                const event = validateStreamEvent(message.event);
-                const data = parseStreamData(event, message.data);
-                pending.push({
-                  event,
-                  data,
-                });
-                message = { event: "", data: "" };
-              }
-            } else if (fieldLength > 0) {
-              const line = buffer2.subarray(lineStart, lineEnd);
-              const field = decoder2.decode(line.subarray(0, fieldLength));
-              const valueOffset =
-                fieldLength +
-                (line[fieldLength + 1] === ControlChars.Space ? 2 : 1);
-              const value = decoder2.decode(line.subarray(valueOffset));
-              switch (field) {
-                case "event":
-                  message.event = value;
-                  break;
-                case "data":
-                  message.data = message.data
-                    ? message.data + "\n" + value
-                    : value;
-                  break;
-              }
-            }
-            lineStart = position;
-            fieldLength = -1;
-          }
-          if (lineStart === bufLength) {
-            buffer2 = void 0;
-            const messages = [...pending];
-            pending = [];
-            return messages;
-          } else if (lineStart !== 0) {
-            buffer2 = buffer2.subarray(lineStart);
-            position -= lineStart;
-          }
-        };
-      }
-      var __asyncValues =
-        (globalThis && globalThis.__asyncValues) ||
-        function (o) {
-          if (!Symbol.asyncIterator)
-            throw new TypeError("Symbol.asyncIterator is not defined.");
-          var m = o[Symbol.asyncIterator],
-            i;
-          return m
-            ? m.call(o)
-            : ((o =
-                typeof __values === "function"
-                  ? __values(o)
-                  : o[Symbol.iterator]()),
-              (i = {}),
-              verb("next"),
-              verb("throw"),
-              verb("return"),
-              (i[Symbol.asyncIterator] = function () {
-                return this;
-              }),
-              i);
-          function verb(n2) {
-            i[n2] =
-              o[n2] &&
-              function (v2) {
-                return new Promise(function (resolve, reject2) {
-                  (v2 = o[n2](v2)), settle(resolve, reject2, v2.done, v2.value);
-                });
-              };
-          }
-          function settle(resolve, reject2, d, v2) {
-            Promise.resolve(v2).then(function (v3) {
-              resolve({ value: v3, done: d });
-            }, reject2);
-          }
-        };
-      var __await =
-        (globalThis && globalThis.__await) ||
-        function (v2) {
-          return this instanceof __await
-            ? ((this.v = v2), this)
-            : new __await(v2);
-        };
-      var __asyncGenerator =
-        (globalThis && globalThis.__asyncGenerator) ||
-        function (thisArg, _arguments, generator) {
-          if (!Symbol.asyncIterator)
-            throw new TypeError("Symbol.asyncIterator is not defined.");
-          var g = generator.apply(thisArg, _arguments || []),
-            i,
-            q2 = [];
-          return (
-            (i = {}),
-            verb("next"),
-            verb("throw"),
-            verb("return"),
-            (i[Symbol.asyncIterator] = function () {
-              return this;
-            }),
-            i
-          );
-          function verb(n2) {
-            if (g[n2])
-              i[n2] = function (v2) {
-                return new Promise(function (a, b) {
-                  q2.push([n2, v2, a, b]) > 1 || resume(n2, v2);
-                });
-              };
-          }
-          function resume(n2, v2) {
-            try {
-              step(g[n2](v2));
-            } catch (e) {
-              settle(q2[0][3], e);
-            }
-          }
-          function step(r2) {
-            r2.value instanceof __await
-              ? Promise.resolve(r2.value.v).then(fulfill, reject2)
-              : settle(q2[0][2], r2);
-          }
-          function fulfill(value) {
-            resume("next", value);
-          }
-          function reject2(value) {
-            resume("throw", value);
-          }
-          function settle(f, v2) {
-            if ((f(v2), q2.shift(), q2.length)) resume(q2[0][0], q2[0][1]);
-          }
-        };
-      function createClient(options) {
-        const {
-          singleConnection = false,
-          lazy = true,
-          onNonLazyError = console.error,
-          generateID = function generateUUID() {
-            return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
-              /[xy]/g,
-              (c) => {
-                const r2 = (Math.random() * 16) | 0,
-                  v2 = c == "x" ? r2 : (r2 & 3) | 8;
-                return v2.toString(16);
-              }
-            );
-          },
-          retryAttempts = 5,
-          retry = async function randomisedExponentialBackoff(retries2) {
-            let retryDelay = 1e3;
-            for (let i = 0; i < retries2; i++) {
-              retryDelay *= 2;
-            }
-            await new Promise((resolve) =>
-              setTimeout(
-                resolve,
-                retryDelay + Math.floor(Math.random() * (3e3 - 300) + 300)
-              )
-            );
-          },
-        } = options;
-        const fetchFn = options.fetchFn || fetch;
-        const AbortControllerImpl =
-          options.abortControllerImpl || AbortController;
-        const client2 = (() => {
-          let disposed = false;
-          const listeners2 = [];
-          return {
-            get disposed() {
-              return disposed;
-            },
-            onDispose(cb2) {
-              if (disposed) {
-                setTimeout(() => cb2(), 0);
-                return () => {};
-              }
-              listeners2.push(cb2);
-              return () => {
-                listeners2.splice(listeners2.indexOf(cb2), 1);
-              };
-            },
-            dispose() {
-              if (disposed) return;
-              disposed = true;
-              for (const listener of [...listeners2]) {
-                listener();
-              }
-            },
-          };
-        })();
-        let connCtrl,
-          conn,
-          locks = 0,
-          retryingErr = null,
-          retries = 0;
-        async function getOrConnect() {
-          try {
-            if (client2.disposed) throw new Error("Client has been disposed");
-            return await (conn !== null && conn !== void 0
-              ? conn
-              : (conn = (async () => {
-                  var _a2;
-                  if (retryingErr) {
-                    await retry(retries);
-                    if (connCtrl.signal.aborted)
-                      throw new Error("Connection aborted by the client");
-                    retries++;
-                  }
-                  connCtrl = new AbortControllerImpl();
-                  const unlistenDispose = client2.onDispose(() =>
-                    connCtrl.abort()
-                  );
-                  connCtrl.signal.addEventListener("abort", () => {
-                    unlistenDispose();
-                    conn = void 0;
-                  });
-                  const url =
-                    typeof options.url === "function"
-                      ? await options.url()
-                      : options.url;
-                  if (connCtrl.signal.aborted)
-                    throw new Error("Connection aborted by the client");
-                  const headers =
-                    typeof options.headers === "function"
-                      ? await options.headers()
-                      : (_a2 = options.headers) !== null && _a2 !== void 0
-                      ? _a2
-                      : {};
-                  if (connCtrl.signal.aborted)
-                    throw new Error("Connection aborted by the client");
-                  let res;
-                  try {
-                    res = await fetchFn(url, {
-                      signal: connCtrl.signal,
-                      method: "PUT",
-                      headers,
-                    });
-                  } catch (err) {
-                    throw new NetworkError(err);
-                  }
-                  if (res.status !== 201) throw new NetworkError(res);
-                  const token2 = await res.text();
-                  headers[TOKEN_HEADER_KEY] = token2;
-                  const connected = await connect({
-                    signal: connCtrl.signal,
-                    headers,
-                    url,
-                    fetchFn,
-                  });
-                  retryingErr = null;
-                  retries = 0;
-                  connected.waitForThrow().catch(() => (conn = void 0));
-                  return connected;
-                })()));
-          } catch (err) {
-            conn = void 0;
-            throw err;
-          }
-        }
-        if (singleConnection && !lazy) {
-          (async () => {
-            locks++;
-            for (;;) {
-              try {
-                const { waitForThrow } = await getOrConnect();
-                await waitForThrow();
-              } catch (err) {
-                if (client2.disposed) return;
-                if (!(err instanceof NetworkError))
-                  return onNonLazyError === null || onNonLazyError === void 0
-                    ? void 0
-                    : onNonLazyError(err);
-                if (!retryAttempts || retries >= retryAttempts)
-                  return onNonLazyError === null || onNonLazyError === void 0
-                    ? void 0
-                    : onNonLazyError(err);
-                retryingErr = err;
-              }
-            }
-          })();
-        }
-        return {
-          subscribe(request, sink) {
-            if (!singleConnection) {
-              const control2 = new AbortControllerImpl();
-              const unlisten2 = client2.onDispose(() => {
-                unlisten2();
-                control2.abort();
-              });
-              (async () => {
-                var e_1, _a2;
-                var _b;
-                let retryingErr2 = null,
-                  retries2 = 0;
-                for (;;) {
-                  try {
-                    if (retryingErr2) {
-                      await retry(retries2);
-                      if (control2.signal.aborted)
-                        throw new Error("Connection aborted by the client");
-                      retries2++;
-                    }
-                    const url =
-                      typeof options.url === "function"
-                        ? await options.url()
-                        : options.url;
-                    if (control2.signal.aborted)
-                      throw new Error("Connection aborted by the client");
-                    const headers =
-                      typeof options.headers === "function"
-                        ? await options.headers()
-                        : (_b = options.headers) !== null && _b !== void 0
-                        ? _b
-                        : {};
-                    if (control2.signal.aborted)
-                      throw new Error("Connection aborted by the client");
-                    const { getResults } = await connect({
-                      signal: control2.signal,
-                      headers,
-                      url,
-                      body: JSON.stringify(request),
-                      fetchFn,
-                    });
-                    retryingErr2 = null;
-                    retries2 = 0;
-                    try {
-                      for (
-                        var _c = ((e_1 = void 0), __asyncValues(getResults())),
-                          _d;
-                        (_d = await _c.next()), !_d.done;
+    <script type="module" crossorigin>
+      import { renderYogaGraphiQL } from "https://cdn.jsdelivr.net/npm/@graphql-yoga/graphiql@4.2.0/+esm";
 
-                      ) {
-                        const result2 = _d.value;
-                        sink.next(result2);
-                      }
-                    } catch (e_1_1) {
-                      e_1 = { error: e_1_1 };
-                    } finally {
-                      try {
-                        if (_d && !_d.done && (_a2 = _c.return))
-                          await _a2.call(_c);
-                      } finally {
-                        if (e_1) throw e_1.error;
-                      }
-                    }
-                    return control2.abort();
-                  } catch (err) {
-                    if (control2.signal.aborted) return;
-                    if (!(err instanceof NetworkError)) throw err;
-                    if (!retryAttempts || retries2 >= retryAttempts) throw err;
-                    retryingErr2 = err;
-                  }
-                }
-              })()
-                .then(() => sink.complete())
-                .catch((err) => sink.error(err));
-              return () => control2.abort();
-            }
-            locks++;
-            const control = new AbortControllerImpl();
-            const unlisten = client2.onDispose(() => {
-              unlisten();
-              control.abort();
-            });
-            (async () => {
-              var e_2, _a2;
-              const operationId = generateID();
-              request = Object.assign(Object.assign({}, request), {
-                extensions: Object.assign(
-                  Object.assign({}, request.extensions),
-                  { operationId }
-                ),
-              });
-              let complete = null;
-              for (;;) {
-                complete = null;
-                try {
-                  const { url, headers, getResults } = await getOrConnect();
-                  let res;
-                  try {
-                    res = await fetchFn(url, {
-                      signal: control.signal,
-                      method: "POST",
-                      headers,
-                      body: JSON.stringify(request),
-                    });
-                  } catch (err) {
-                    throw new NetworkError(err);
-                  }
-                  if (res.status !== 202) throw new NetworkError(res);
-                  complete = async () => {
-                    let res2;
-                    try {
-                      const control2 = new AbortControllerImpl();
-                      const unlisten2 = client2.onDispose(() => {
-                        unlisten2();
-                        control2.abort();
-                      });
-                      res2 = await fetchFn(
-                        url + "?operationId=" + operationId,
-                        {
-                          signal: control2.signal,
-                          method: "DELETE",
-                          headers,
-                        }
-                      );
-                    } catch (err) {
-                      throw new NetworkError(err);
-                    }
-                    if (res2.status !== 200) throw new NetworkError(res2);
-                  };
-                  try {
-                    for (
-                      var _b =
-                          ((e_2 = void 0),
-                          __asyncValues(
-                            getResults({
-                              signal: control.signal,
-                              operationId,
-                            })
-                          )),
-                        _c;
-                      (_c = await _b.next()), !_c.done;
-
-                    ) {
-                      const result2 = _c.value;
-                      sink.next(result2);
-                    }
-                  } catch (e_2_1) {
-                    e_2 = { error: e_2_1 };
-                  } finally {
-                    try {
-                      if (_c && !_c.done && (_a2 = _b.return))
-                        await _a2.call(_b);
-                    } finally {
-                      if (e_2) throw e_2.error;
-                    }
-                  }
-                  complete = null;
-                  return control.abort();
-                } catch (err) {
-                  if (control.signal.aborted)
-                    return await (complete === null || complete === void 0
-                      ? void 0
-                      : complete());
-                  if (!(err instanceof NetworkError)) throw err;
-                  if (!retryAttempts || retries >= retryAttempts) throw err;
-                  retryingErr = err;
-                } finally {
-                  if (control.signal.aborted && --locks === 0) connCtrl.abort();
-                }
-              }
-            })()
-              .then(() => sink.complete())
-              .catch((err) => sink.error(err));
-            return () => control.abort();
-          },
-          dispose() {
-            client2.dispose();
-          },
-        };
-      }
-      class NetworkError extends Error {
-        constructor(msgOrErrOrResponse) {
-          let message, response;
-          if (isResponseLike(msgOrErrOrResponse)) {
-            response = msgOrErrOrResponse;
-            message =
-              "Server responded with " +
-              msgOrErrOrResponse.status +
-              ": " +
-              msgOrErrOrResponse.statusText;
-          } else if (msgOrErrOrResponse instanceof Error)
-            message = msgOrErrOrResponse.message;
-          else message = String(msgOrErrOrResponse);
-          super(message);
-          this.name = this.constructor.name;
-          this.response = response;
-        }
-      }
-      function isResponseLike(val) {
-        return (
-          isObject$2(val) &&
-          typeof val["ok"] === "boolean" &&
-          typeof val["status"] === "number" &&
-          typeof val["statusText"] === "string"
-        );
-      }
-      async function connect(options) {
-        const { signal, url, headers, body, fetchFn } = options;
-        const waiting = {};
-        const queue = {};
-        let res;
-        try {
-          res = await fetchFn(url, {
-            signal,
-            method: body ? "POST" : "GET",
-            headers: Object.assign(Object.assign({}, headers), {
-              accept: "text/event-stream",
-            }),
-            body,
-          });
-        } catch (err) {
-          throw new NetworkError(err);
-        }
-        if (!res.ok) throw new NetworkError(res);
-        if (!res.body) throw new Error("Missing response body");
-        let error2 = null;
-        let waitingForThrow = null;
-        (async () => {
-          var e_3, _a2;
-          var _b;
-          try {
-            const parse2 = createParser();
-            try {
-              for (
-                var _c = __asyncValues(toAsyncIterator(res.body)), _d;
-                (_d = await _c.next()), !_d.done;
-
-              ) {
-                const chunk = _d.value;
-                if (typeof chunk === "string")
-                  throw new Error(`Unexpected string chunk "${chunk}"`);
-                const msgs = parse2(chunk);
-                if (!msgs) continue;
-                for (const msg of msgs) {
-                  const operationId =
-                    msg.data && "id" in msg.data ? msg.data.id : "";
-                  if (!(operationId in queue)) queue[operationId] = [];
-                  switch (msg.event) {
-                    case "next":
-                      if (operationId)
-                        queue[operationId].push(msg.data.payload);
-                      else queue[operationId].push(msg.data);
-                      break;
-                    case "complete":
-                      queue[operationId].push("complete");
-                      break;
-                    default:
-                      throw new Error(
-                        `Unexpected message event "${msg.event}"`
-                      );
-                  }
-                  (_b = waiting[operationId]) === null || _b === void 0
-                    ? void 0
-                    : _b.proceed();
-                }
-              }
-            } catch (e_3_1) {
-              e_3 = { error: e_3_1 };
-            } finally {
-              try {
-                if (_d && !_d.done && (_a2 = _c.return)) await _a2.call(_c);
-              } finally {
-                if (e_3) throw e_3.error;
-              }
-            }
-          } catch (err) {
-            error2 = err;
-            if (waitingForThrow) waitingForThrow(err);
-          } finally {
-            Object.values(waiting).forEach(({ proceed }) => proceed());
-          }
-        })();
-        return {
-          url,
-          headers,
-          waitForThrow: () =>
-            new Promise((_, reject2) => {
-              if (error2) return reject2(error2);
-              waitingForThrow = reject2;
-            }),
-          getResults(options2) {
-            var _a2;
-            return __asyncGenerator(this, arguments, function* getResults_1() {
-              const { signal: signal2, operationId = "" } =
-                options2 !== null && options2 !== void 0 ? options2 : {};
-              try {
-                for (;;) {
-                  while (
-                    (_a2 = queue[operationId]) === null || _a2 === void 0
-                      ? void 0
-                      : _a2.length
-                  ) {
-                    const result2 = queue[operationId].shift();
-                    if (result2 === "complete") return yield __await(void 0);
-                    yield yield __await(result2);
-                  }
-                  if (error2) throw error2;
-                  if (
-                    signal2 === null || signal2 === void 0
-                      ? void 0
-                      : signal2.aborted
-                  )
-                    throw new Error("Getting results aborted by the client");
-                  yield __await(
-                    new Promise((resolve) => {
-                      const proceed = () => {
-                        signal2 === null || signal2 === void 0
-                          ? void 0
-                          : signal2.removeEventListener("abort", proceed);
-                        delete waiting[operationId];
-                        resolve();
-                      };
-                      signal2 === null || signal2 === void 0
-                        ? void 0
-                        : signal2.addEventListener("abort", proceed);
-                      waiting[operationId] = { proceed };
-                    })
-                  );
-                }
-              } finally {
-                delete queue[operationId];
-              }
-            });
-          },
-        };
-      }
-      function toAsyncIterator(val) {
-        if (typeof Object(val)[Symbol.asyncIterator] === "function") {
-          val = val;
-          return val[Symbol.asyncIterator]();
-        }
-        return (function () {
-          return __asyncGenerator(this, arguments, function* () {
-            val = val;
-            const reader = val.getReader();
-            for (;;) {
-              const { value, done } = yield __await(reader.read());
-              if (done) return yield __await(value);
-              yield yield __await(value);
-            }
-          });
-        })();
-      }
-      var ws = null;
-      if (typeof WebSocket !== "undefined") {
-        ws = WebSocket;
-      } else if (typeof MozWebSocket !== "undefined") {
-        ws = MozWebSocket;
-      } else if (typeof commonjsGlobal !== "undefined") {
-        ws = commonjsGlobal.WebSocket || commonjsGlobal.MozWebSocket;
-      } else if (typeof window !== "undefined") {
-        ws = window.WebSocket || window.MozWebSocket;
-      } else if (typeof self !== "undefined") {
-        ws = self.WebSocket || self.MozWebSocket;
-      }
-      var browser$1 = ws;
-      var ReactNativeFile_1 = class ReactNativeFile {
-        constructor({ uri, name: name2, type: type2 }) {
-          this.uri = uri;
-          this.name = name2;
-          this.type = type2;
-        }
-      };
-      const ReactNativeFile2 = ReactNativeFile_1;
-      var isExtractableFile = function isExtractableFile2(value) {
-        return (
-          (typeof File !== "undefined" && value instanceof File) ||
-          (typeof Blob !== "undefined" && value instanceof Blob) ||
-          value instanceof ReactNativeFile2
-        );
-      };
-      var isExtractableFile$1 = isExtractableFile;
-      const defaultIsExtractableFile = isExtractableFile;
-      var extractFiles = function extractFiles2(
-        value,
-        path = "",
-        isExtractableFile3 = defaultIsExtractableFile
-      ) {
-        const files = /* @__PURE__ */ new Map();
-        const clones = /* @__PURE__ */ new Map();
-        function recurse(value2, path2, recursed) {
-          let clone = value2;
-          if (isExtractableFile3(value2)) {
-            clone = null;
-            const filePaths = files.get(value2);
-            filePaths ? filePaths.push(path2) : files.set(value2, [path2]);
-          } else {
-            const isList2 =
-              Array.isArray(value2) ||
-              (typeof FileList !== "undefined" && value2 instanceof FileList);
-            const isObject3 = value2 && value2.constructor === Object;
-            if (isList2 || isObject3) {
-              const hasClone = clones.has(value2);
-              if (hasClone) clone = clones.get(value2);
-              else {
-                clone = isList2 ? [] : {};
-                clones.set(value2, clone);
-              }
-              if (!recursed.has(value2)) {
-                const pathPrefix = path2 ? `${path2}.` : "";
-                const recursedDeeper = new Set(recursed).add(value2);
-                if (isList2) {
-                  let index = 0;
-                  for (const item of value2) {
-                    const itemClone = recurse(
-                      item,
-                      pathPrefix + index++,
-                      recursedDeeper
-                    );
-                    if (!hasClone) clone.push(itemClone);
-                  }
-                } else
-                  for (const key in value2) {
-                    const propertyClone = recurse(
-                      value2[key],
-                      pathPrefix + key,
-                      recursedDeeper
-                    );
-                    if (!hasClone) clone[key] = propertyClone;
-                  }
-              }
-            }
-          }
-          return clone;
-        }
-        return {
-          clone: recurse(value, path, /* @__PURE__ */ new Set()),
-          files,
-        };
-      };
-      var extractFiles$1 = extractFiles;
-      var client = {};
-      var backo2 = Backoff$1;
-      function Backoff$1(opts) {
-        opts = opts || {};
-        this.ms = opts.min || 100;
-        this.max = opts.max || 1e4;
-        this.factor = opts.factor || 2;
-        this.jitter = opts.jitter > 0 && opts.jitter <= 1 ? opts.jitter : 0;
-        this.attempts = 0;
-      }
-      Backoff$1.prototype.duration = function () {
-        var ms = this.ms * Math.pow(this.factor, this.attempts++);
-        if (this.jitter) {
-          var rand = Math.random();
-          var deviation = Math.floor(rand * this.jitter * ms);
-          ms =
-            (Math.floor(rand * 10) & 1) == 0 ? ms - deviation : ms + deviation;
-        }
-        return Math.min(ms, this.max) | 0;
-      };
-      Backoff$1.prototype.reset = function () {
-        this.attempts = 0;
-      };
-      Backoff$1.prototype.setMin = function (min) {
-        this.ms = min;
-      };
-      Backoff$1.prototype.setMax = function (max) {
-        this.max = max;
-      };
-      Backoff$1.prototype.setJitter = function (jitter) {
-        this.jitter = jitter;
-      };
-      var eventemitter3 = { exports: {} };
-      (function (module2) {
-        var has2 = Object.prototype.hasOwnProperty,
-          prefix = "~";
-        function Events() {}
-        if (Object.create) {
-          Events.prototype = /* @__PURE__ */ Object.create(null);
-          if (!new Events().__proto__) prefix = false;
-        }
-        function EE(fn, context, once) {
-          this.fn = fn;
-          this.context = context;
-          this.once = once || false;
-        }
-        function addListener(emitter, event, fn, context, once) {
-          if (typeof fn !== "function") {
-            throw new TypeError("The listener must be a function");
-          }
-          var listener = new EE(fn, context || emitter, once),
-            evt = prefix ? prefix + event : event;
-          if (!emitter._events[evt])
-            (emitter._events[evt] = listener), emitter._eventsCount++;
-          else if (!emitter._events[evt].fn)
-            emitter._events[evt].push(listener);
-          else emitter._events[evt] = [emitter._events[evt], listener];
-          return emitter;
-        }
-        function clearEvent(emitter, evt) {
-          if (--emitter._eventsCount === 0) emitter._events = new Events();
-          else delete emitter._events[evt];
-        }
-        function EventEmitter() {
-          this._events = new Events();
-          this._eventsCount = 0;
-        }
-        EventEmitter.prototype.eventNames = function eventNames() {
-          var names = [],
-            events,
-            name2;
-          if (this._eventsCount === 0) return names;
-          for (name2 in (events = this._events)) {
-            if (has2.call(events, name2))
-              names.push(prefix ? name2.slice(1) : name2);
-          }
-          if (Object.getOwnPropertySymbols) {
-            return names.concat(Object.getOwnPropertySymbols(events));
-          }
-          return names;
-        };
-        EventEmitter.prototype.listeners = function listeners2(event) {
-          var evt = prefix ? prefix + event : event,
-            handlers = this._events[evt];
-          if (!handlers) return [];
-          if (handlers.fn) return [handlers.fn];
-          for (
-            var i = 0, l2 = handlers.length, ee2 = new Array(l2);
-            i < l2;
-            i++
-          ) {
-            ee2[i] = handlers[i].fn;
-          }
-          return ee2;
-        };
-        EventEmitter.prototype.listenerCount = function listenerCount(event) {
-          var evt = prefix ? prefix + event : event,
-            listeners2 = this._events[evt];
-          if (!listeners2) return 0;
-          if (listeners2.fn) return 1;
-          return listeners2.length;
-        };
-        EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-          var evt = prefix ? prefix + event : event;
-          if (!this._events[evt]) return false;
-          var listeners2 = this._events[evt],
-            len = arguments.length,
-            args,
-            i;
-          if (listeners2.fn) {
-            if (listeners2.once)
-              this.removeListener(event, listeners2.fn, void 0, true);
-            switch (len) {
-              case 1:
-                return listeners2.fn.call(listeners2.context), true;
-              case 2:
-                return listeners2.fn.call(listeners2.context, a1), true;
-              case 3:
-                return listeners2.fn.call(listeners2.context, a1, a2), true;
-              case 4:
-                return listeners2.fn.call(listeners2.context, a1, a2, a3), true;
-              case 5:
-                return (
-                  listeners2.fn.call(listeners2.context, a1, a2, a3, a4), true
-                );
-              case 6:
-                return (
-                  listeners2.fn.call(listeners2.context, a1, a2, a3, a4, a5),
-                  true
-                );
-            }
-            for (i = 1, args = new Array(len - 1); i < len; i++) {
-              args[i - 1] = arguments[i];
-            }
-            listeners2.fn.apply(listeners2.context, args);
-          } else {
-            var length = listeners2.length,
-              j;
-            for (i = 0; i < length; i++) {
-              if (listeners2[i].once)
-                this.removeListener(event, listeners2[i].fn, void 0, true);
-              switch (len) {
-                case 1:
-                  listeners2[i].fn.call(listeners2[i].context);
-                  break;
-                case 2:
-                  listeners2[i].fn.call(listeners2[i].context, a1);
-                  break;
-                case 3:
-                  listeners2[i].fn.call(listeners2[i].context, a1, a2);
-                  break;
-                case 4:
-                  listeners2[i].fn.call(listeners2[i].context, a1, a2, a3);
-                  break;
-                default:
-                  if (!args)
-                    for (j = 1, args = new Array(len - 1); j < len; j++) {
-                      args[j - 1] = arguments[j];
-                    }
-                  listeners2[i].fn.apply(listeners2[i].context, args);
-              }
-            }
-          }
-          return true;
-        };
-        EventEmitter.prototype.on = function on(event, fn, context) {
-          return addListener(this, event, fn, context, false);
-        };
-        EventEmitter.prototype.once = function once(event, fn, context) {
-          return addListener(this, event, fn, context, true);
-        };
-        EventEmitter.prototype.removeListener = function removeListener(
-          event,
-          fn,
-          context,
-          once
-        ) {
-          var evt = prefix ? prefix + event : event;
-          if (!this._events[evt]) return this;
-          if (!fn) {
-            clearEvent(this, evt);
-            return this;
-          }
-          var listeners2 = this._events[evt];
-          if (listeners2.fn) {
-            if (
-              listeners2.fn === fn &&
-              (!once || listeners2.once) &&
-              (!context || listeners2.context === context)
-            ) {
-              clearEvent(this, evt);
-            }
-          } else {
-            for (
-              var i = 0, events = [], length = listeners2.length;
-              i < length;
-              i++
-            ) {
-              if (
-                listeners2[i].fn !== fn ||
-                (once && !listeners2[i].once) ||
-                (context && listeners2[i].context !== context)
-              ) {
-                events.push(listeners2[i]);
-              }
-            }
-            if (events.length)
-              this._events[evt] = events.length === 1 ? events[0] : events;
-            else clearEvent(this, evt);
-          }
-          return this;
-        };
-        EventEmitter.prototype.removeAllListeners = function removeAllListeners(
-          event
-        ) {
-          var evt;
-          if (event) {
-            evt = prefix ? prefix + event : event;
-            if (this._events[evt]) clearEvent(this, evt);
-          } else {
-            this._events = new Events();
-            this._eventsCount = 0;
-          }
-          return this;
-        };
-        EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
-        EventEmitter.prototype.addListener = EventEmitter.prototype.on;
-        EventEmitter.prefixed = prefix;
-        EventEmitter.EventEmitter = EventEmitter;
-        {
-          module2.exports = EventEmitter;
-        }
-      })(eventemitter3);
-      var isString$1 = {};
-      Object.defineProperty(isString$1, "__esModule", { value: true });
-      function isString(value) {
-        return typeof value === "string";
-      }
-      isString$1.default = isString;
-      var isObject$1 = {};
-      Object.defineProperty(isObject$1, "__esModule", { value: true });
-      function isObject2(value) {
-        return value !== null && typeof value === "object";
-      }
-      isObject$1.default = isObject2;
-      var require$$4 = /* @__PURE__ */ getAugmentedNamespace(printer);
-      var require$$5 = /* @__PURE__ */ getAugmentedNamespace(getOperationAST$1);
-      function symbolObservablePonyfill(root2) {
-        var result2;
-        var Symbol2 = root2.Symbol;
-        if (typeof Symbol2 === "function") {
-          if (Symbol2.observable) {
-            result2 = Symbol2.observable;
-          } else {
-            result2 = Symbol2("observable");
-            Symbol2.observable = result2;
-          }
-        } else {
-          result2 = "@@observable";
-        }
-        return result2;
-      }
-      var root;
-      if (typeof self !== "undefined") {
-        root = self;
-      } else if (typeof window !== "undefined") {
-        root = window;
-      } else if (typeof global !== "undefined") {
-        root = global;
-      } else if (typeof module !== "undefined") {
-        root = module;
-      } else {
-        root = Function("return this")();
-      }
-      var result = symbolObservablePonyfill(root);
-      var es = /* @__PURE__ */ Object.freeze({
-        __proto__: null,
-        [Symbol.toStringTag]: "Module",
-        default: result,
-      });
-      var require$$6 = /* @__PURE__ */ getAugmentedNamespace(es);
-      var protocol = {};
-      Object.defineProperty(protocol, "__esModule", { value: true });
-      protocol.GRAPHQL_SUBSCRIPTIONS = protocol.GRAPHQL_WS = void 0;
-      var GRAPHQL_WS = "graphql-ws";
-      protocol.GRAPHQL_WS = GRAPHQL_WS;
-      var GRAPHQL_SUBSCRIPTIONS = "graphql-subscriptions";
-      protocol.GRAPHQL_SUBSCRIPTIONS = GRAPHQL_SUBSCRIPTIONS;
-      var defaults = {};
-      Object.defineProperty(defaults, "__esModule", { value: true });
-      defaults.WS_TIMEOUT = defaults.MIN_WS_TIMEOUT = void 0;
-      var MIN_WS_TIMEOUT = 1e3;
-      defaults.MIN_WS_TIMEOUT = MIN_WS_TIMEOUT;
-      var WS_TIMEOUT = 3e4;
-      defaults.WS_TIMEOUT = WS_TIMEOUT;
-      var messageTypes = {};
-      Object.defineProperty(messageTypes, "__esModule", { value: true });
-      var MessageTypes = (function () {
-        function MessageTypes2() {
-          throw new Error("Static Class");
-        }
-        MessageTypes2.GQL_CONNECTION_INIT = "connection_init";
-        MessageTypes2.GQL_CONNECTION_ACK = "connection_ack";
-        MessageTypes2.GQL_CONNECTION_ERROR = "connection_error";
-        MessageTypes2.GQL_CONNECTION_KEEP_ALIVE = "ka";
-        MessageTypes2.GQL_CONNECTION_TERMINATE = "connection_terminate";
-        MessageTypes2.GQL_START = "start";
-        MessageTypes2.GQL_DATA = "data";
-        MessageTypes2.GQL_ERROR = "error";
-        MessageTypes2.GQL_COMPLETE = "complete";
-        MessageTypes2.GQL_STOP = "stop";
-        MessageTypes2.SUBSCRIPTION_START = "subscription_start";
-        MessageTypes2.SUBSCRIPTION_DATA = "subscription_data";
-        MessageTypes2.SUBSCRIPTION_SUCCESS = "subscription_success";
-        MessageTypes2.SUBSCRIPTION_FAIL = "subscription_fail";
-        MessageTypes2.SUBSCRIPTION_END = "subscription_end";
-        MessageTypes2.INIT = "init";
-        MessageTypes2.INIT_SUCCESS = "init_success";
-        MessageTypes2.INIT_FAIL = "init_fail";
-        MessageTypes2.KEEP_ALIVE = "keepalive";
-        return MessageTypes2;
-      })();
-      messageTypes.default = MessageTypes;
-      var __assign =
-        (commonjsGlobal && commonjsGlobal.__assign) ||
-        function () {
-          __assign =
-            Object.assign ||
-            function (t2) {
-              for (var s, i = 1, n2 = arguments.length; i < n2; i++) {
-                s = arguments[i];
-                for (var p2 in s)
-                  if (Object.prototype.hasOwnProperty.call(s, p2))
-                    t2[p2] = s[p2];
-              }
-              return t2;
-            };
-          return __assign.apply(this, arguments);
-        };
-      var __awaiter =
-        (commonjsGlobal && commonjsGlobal.__awaiter) ||
-        function (thisArg, _arguments, P2, generator) {
-          function adopt(value) {
-            return value instanceof P2
-              ? value
-              : new P2(function (resolve) {
-                  resolve(value);
-                });
-          }
-          return new (P2 || (P2 = Promise))(function (resolve, reject2) {
-            function fulfilled(value) {
-              try {
-                step(generator.next(value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function rejected(value) {
-              try {
-                step(generator["throw"](value));
-              } catch (e) {
-                reject2(e);
-              }
-            }
-            function step(result2) {
-              result2.done
-                ? resolve(result2.value)
-                : adopt(result2.value).then(fulfilled, rejected);
-            }
-            step(
-              (generator = generator.apply(thisArg, _arguments || [])).next()
-            );
-          });
-        };
-      var __generator =
-        (commonjsGlobal && commonjsGlobal.__generator) ||
-        function (thisArg, body) {
-          var _ = {
-              label: 0,
-              sent: function () {
-                if (t2[0] & 1) throw t2[1];
-                return t2[1];
-              },
-              trys: [],
-              ops: [],
-            },
-            f,
-            y2,
-            t2,
-            g;
-          return (
-            (g = { next: verb(0), throw: verb(1), return: verb(2) }),
-            typeof Symbol === "function" &&
-              (g[Symbol.iterator] = function () {
-                return this;
-              }),
-            g
-          );
-          function verb(n2) {
-            return function (v2) {
-              return step([n2, v2]);
-            };
-          }
-          function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_)
-              try {
-                if (
-                  ((f = 1),
-                  y2 &&
-                    (t2 =
-                      op[0] & 2
-                        ? y2["return"]
-                        : op[0]
-                        ? y2["throw"] || ((t2 = y2["return"]) && t2.call(y2), 0)
-                        : y2.next) &&
-                    !(t2 = t2.call(y2, op[1])).done)
-                )
-                  return t2;
-                if (((y2 = 0), t2)) op = [op[0] & 2, t2.value];
-                switch (op[0]) {
-                  case 0:
-                  case 1:
-                    t2 = op;
-                    break;
-                  case 4:
-                    _.label++;
-                    return { value: op[1], done: false };
-                  case 5:
-                    _.label++;
-                    y2 = op[1];
-                    op = [0];
-                    continue;
-                  case 7:
-                    op = _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                  default:
-                    if (
-                      !((t2 = _.trys),
-                      (t2 = t2.length > 0 && t2[t2.length - 1])) &&
-                      (op[0] === 6 || op[0] === 2)
-                    ) {
-                      _ = 0;
-                      continue;
-                    }
-                    if (
-                      op[0] === 3 &&
-                      (!t2 || (op[1] > t2[0] && op[1] < t2[3]))
-                    ) {
-                      _.label = op[1];
-                      break;
-                    }
-                    if (op[0] === 6 && _.label < t2[1]) {
-                      _.label = t2[1];
-                      t2 = op;
-                      break;
-                    }
-                    if (t2 && _.label < t2[2]) {
-                      _.label = t2[2];
-                      _.ops.push(op);
-                      break;
-                    }
-                    if (t2[2]) _.ops.pop();
-                    _.trys.pop();
-                    continue;
-                }
-                op = body.call(thisArg, _);
-              } catch (e) {
-                op = [6, e];
-                y2 = 0;
-              } finally {
-                f = t2 = 0;
-              }
-            if (op[0] & 5) throw op[1];
-            return { value: op[0] ? op[1] : void 0, done: true };
-          }
-        };
-      var __spreadArray =
-        (commonjsGlobal && commonjsGlobal.__spreadArray) ||
-        function (to, from, pack) {
-          if (pack || arguments.length === 2)
-            for (var i = 0, l2 = from.length, ar; i < l2; i++) {
-              if (ar || !(i in from)) {
-                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-                ar[i] = from[i];
-              }
-            }
-          return to.concat(ar || Array.prototype.slice.call(from));
-        };
-      Object.defineProperty(client, "__esModule", { value: true });
-      var SubscriptionClient_1 = (client.SubscriptionClient = void 0);
-      var _global =
-        typeof commonjsGlobal !== "undefined"
-          ? commonjsGlobal
-          : typeof window !== "undefined"
-          ? window
-          : {};
-      var NativeWebSocket = _global.WebSocket || _global.MozWebSocket;
-      var Backoff = backo2;
-      var eventemitter3_1 = eventemitter3.exports;
-      var is_string_1 = isString$1;
-      var is_object_1 = isObject$1;
-      var printer_1 = require$$4;
-      var getOperationAST_1 = require$$5;
-      var symbol_observable_1 = require$$6;
-      var protocol_1 = protocol;
-      var defaults_1 = defaults;
-      var message_types_1 = messageTypes;
-      var SubscriptionClient = (function () {
-        function SubscriptionClient2(
-          url,
-          options,
-          webSocketImpl,
-          webSocketProtocols
-        ) {
-          var _a2 = options || {},
-            _b = _a2.connectionCallback,
-            connectionCallback = _b === void 0 ? void 0 : _b,
-            _c = _a2.connectionParams,
-            connectionParams = _c === void 0 ? {} : _c,
-            _d = _a2.minTimeout,
-            minTimeout = _d === void 0 ? defaults_1.MIN_WS_TIMEOUT : _d,
-            _e = _a2.timeout,
-            timeout = _e === void 0 ? defaults_1.WS_TIMEOUT : _e,
-            _f = _a2.reconnect,
-            reconnect = _f === void 0 ? false : _f,
-            _g = _a2.reconnectionAttempts,
-            reconnectionAttempts = _g === void 0 ? Infinity : _g,
-            _h = _a2.lazy,
-            lazy = _h === void 0 ? false : _h,
-            _j = _a2.inactivityTimeout,
-            inactivityTimeout = _j === void 0 ? 0 : _j,
-            _k = _a2.wsOptionArguments,
-            wsOptionArguments = _k === void 0 ? [] : _k;
-          this.wsImpl = webSocketImpl || NativeWebSocket;
-          if (!this.wsImpl) {
-            throw new Error(
-              "Unable to find native implementation, or alternative implementation for WebSocket!"
-            );
-          }
-          this.wsProtocols = webSocketProtocols || protocol_1.GRAPHQL_WS;
-          this.connectionCallback = connectionCallback;
-          this.url = url;
-          this.operations = {};
-          this.nextOperationId = 0;
-          this.minWsTimeout = minTimeout;
-          this.wsTimeout = timeout;
-          this.unsentMessagesQueue = [];
-          this.reconnect = reconnect;
-          this.reconnecting = false;
-          this.reconnectionAttempts = reconnectionAttempts;
-          this.lazy = !!lazy;
-          this.inactivityTimeout = inactivityTimeout;
-          this.closedByUser = false;
-          this.backoff = new Backoff({ jitter: 0.5 });
-          this.eventEmitter = new eventemitter3_1.EventEmitter();
-          this.middlewares = [];
-          this.client = null;
-          this.maxConnectTimeGenerator = this.createMaxConnectTimeGenerator();
-          this.connectionParams = this.getConnectionParams(connectionParams);
-          this.wsOptionArguments = wsOptionArguments;
-          if (!this.lazy) {
-            this.connect();
-          }
-        }
-        Object.defineProperty(SubscriptionClient2.prototype, "status", {
-          get: function () {
-            if (this.client === null) {
-              return this.wsImpl.CLOSED;
-            }
-            return this.client.readyState;
-          },
-          enumerable: false,
-          configurable: true,
-        });
-        SubscriptionClient2.prototype.close = function (
-          isForced,
-          closedByUser
-        ) {
-          if (isForced === void 0) {
-            isForced = true;
-          }
-          if (closedByUser === void 0) {
-            closedByUser = true;
-          }
-          this.clearInactivityTimeout();
-          if (this.client !== null) {
-            this.closedByUser = closedByUser;
-            if (isForced) {
-              this.clearCheckConnectionInterval();
-              this.clearMaxConnectTimeout();
-              this.clearTryReconnectTimeout();
-              this.unsubscribeAll();
-              this.sendMessage(
-                void 0,
-                message_types_1.default.GQL_CONNECTION_TERMINATE,
-                null
-              );
-            }
-            this.client.close();
-            this.client.onopen = null;
-            this.client.onclose = null;
-            this.client.onerror = null;
-            this.client.onmessage = null;
-            this.client = null;
-            this.eventEmitter.emit("disconnected");
-            if (!isForced) {
-              this.tryReconnect();
-            }
-          }
-        };
-        SubscriptionClient2.prototype.request = function (request) {
-          var _a2;
-          var getObserver = this.getObserver.bind(this);
-          var executeOperation2 = this.executeOperation.bind(this);
-          var unsubscribe = this.unsubscribe.bind(this);
-          var opId;
-          this.clearInactivityTimeout();
-          return (
-            (_a2 = {}),
-            (_a2[symbol_observable_1.default] = function () {
-              return this;
-            }),
-            (_a2.subscribe = function (observerOrNext, onError, onComplete) {
-              var observer = getObserver(observerOrNext, onError, onComplete);
-              opId = executeOperation2(request, function (error2, result2) {
-                if (error2 === null && result2 === null) {
-                  if (observer.complete) {
-                    observer.complete();
-                  }
-                } else if (error2) {
-                  if (observer.error) {
-                    observer.error(error2[0]);
-                  }
-                } else {
-                  if (observer.next) {
-                    observer.next(result2);
-                  }
-                }
-              });
-              return {
-                unsubscribe: function () {
-                  if (opId) {
-                    unsubscribe(opId);
-                    opId = null;
-                  }
-                },
-              };
-            }),
-            _a2
-          );
-        };
-        SubscriptionClient2.prototype.on = function (
-          eventName,
-          callback,
-          context
-        ) {
-          var handler = this.eventEmitter.on(eventName, callback, context);
-          return function () {
-            handler.off(eventName, callback, context);
-          };
-        };
-        SubscriptionClient2.prototype.onConnected = function (
-          callback,
-          context
-        ) {
-          return this.on("connected", callback, context);
-        };
-        SubscriptionClient2.prototype.onConnecting = function (
-          callback,
-          context
-        ) {
-          return this.on("connecting", callback, context);
-        };
-        SubscriptionClient2.prototype.onDisconnected = function (
-          callback,
-          context
-        ) {
-          return this.on("disconnected", callback, context);
-        };
-        SubscriptionClient2.prototype.onReconnected = function (
-          callback,
-          context
-        ) {
-          return this.on("reconnected", callback, context);
-        };
-        SubscriptionClient2.prototype.onReconnecting = function (
-          callback,
-          context
-        ) {
-          return this.on("reconnecting", callback, context);
-        };
-        SubscriptionClient2.prototype.onError = function (callback, context) {
-          return this.on("error", callback, context);
-        };
-        SubscriptionClient2.prototype.unsubscribeAll = function () {
-          var _this = this;
-          Object.keys(this.operations).forEach(function (subId) {
-            _this.unsubscribe(subId);
-          });
-        };
-        SubscriptionClient2.prototype.applyMiddlewares = function (options) {
-          var _this = this;
-          return new Promise(function (resolve, reject2) {
-            var queue = function (funcs, scope) {
-              var next = function (error2) {
-                if (error2) {
-                  reject2(error2);
-                } else {
-                  if (funcs.length > 0) {
-                    var f = funcs.shift();
-                    if (f) {
-                      f.applyMiddleware.apply(scope, [options, next]);
-                    }
-                  } else {
-                    resolve(options);
-                  }
-                }
-              };
-              next();
-            };
-            queue(__spreadArray([], _this.middlewares, true), _this);
-          });
-        };
-        SubscriptionClient2.prototype.use = function (middlewares) {
-          var _this = this;
-          middlewares.map(function (middleware) {
-            if (typeof middleware.applyMiddleware === "function") {
-              _this.middlewares.push(middleware);
-            } else {
-              throw new Error(
-                "Middleware must implement the applyMiddleware function."
-              );
-            }
-          });
-          return this;
-        };
-        SubscriptionClient2.prototype.getConnectionParams = function (
-          connectionParams
-        ) {
-          return function () {
-            return new Promise(function (resolve, reject2) {
-              if (typeof connectionParams === "function") {
-                try {
-                  return resolve(connectionParams.call(null));
-                } catch (error2) {
-                  return reject2(error2);
-                }
-              }
-              resolve(connectionParams);
-            });
-          };
-        };
-        SubscriptionClient2.prototype.executeOperation = function (
-          options,
-          handler
-        ) {
-          var _this = this;
-          if (this.client === null) {
-            this.connect();
-          }
-          var opId = this.generateOperationId();
-          this.operations[opId] = { options, handler };
-          this.applyMiddlewares(options)
-            .then(function (processedOptions) {
-              _this.checkOperationOptions(processedOptions, handler);
-              if (_this.operations[opId]) {
-                _this.operations[opId] = { options: processedOptions, handler };
-                _this.sendMessage(
-                  opId,
-                  message_types_1.default.GQL_START,
-                  processedOptions
-                );
-              }
-            })
-            .catch(function (error2) {
-              _this.unsubscribe(opId);
-              handler(_this.formatErrors(error2));
-            });
-          return opId;
-        };
-        SubscriptionClient2.prototype.getObserver = function (
-          observerOrNext,
-          error2,
-          complete
-        ) {
-          if (typeof observerOrNext === "function") {
-            return {
-              next: function (v2) {
-                return observerOrNext(v2);
-              },
-              error: function (e) {
-                return error2 && error2(e);
-              },
-              complete: function () {
-                return complete && complete();
-              },
-            };
-          }
-          return observerOrNext;
-        };
-        SubscriptionClient2.prototype.createMaxConnectTimeGenerator =
-          function () {
-            var minValue = this.minWsTimeout;
-            var maxValue = this.wsTimeout;
-            return new Backoff({
-              min: minValue,
-              max: maxValue,
-              factor: 1.2,
-            });
-          };
-        SubscriptionClient2.prototype.clearCheckConnectionInterval =
-          function () {
-            if (this.checkConnectionIntervalId) {
-              clearInterval(this.checkConnectionIntervalId);
-              this.checkConnectionIntervalId = null;
-            }
-          };
-        SubscriptionClient2.prototype.clearMaxConnectTimeout = function () {
-          if (this.maxConnectTimeoutId) {
-            clearTimeout(this.maxConnectTimeoutId);
-            this.maxConnectTimeoutId = null;
-          }
-        };
-        SubscriptionClient2.prototype.clearTryReconnectTimeout = function () {
-          if (this.tryReconnectTimeoutId) {
-            clearTimeout(this.tryReconnectTimeoutId);
-            this.tryReconnectTimeoutId = null;
-          }
-        };
-        SubscriptionClient2.prototype.clearInactivityTimeout = function () {
-          if (this.inactivityTimeoutId) {
-            clearTimeout(this.inactivityTimeoutId);
-            this.inactivityTimeoutId = null;
-          }
-        };
-        SubscriptionClient2.prototype.setInactivityTimeout = function () {
-          var _this = this;
-          if (
-            this.inactivityTimeout > 0 &&
-            Object.keys(this.operations).length === 0
-          ) {
-            this.inactivityTimeoutId = setTimeout(function () {
-              if (Object.keys(_this.operations).length === 0) {
-                _this.close();
-              }
-            }, this.inactivityTimeout);
-          }
-        };
-        SubscriptionClient2.prototype.checkOperationOptions = function (
-          options,
-          handler
-        ) {
-          var query = options.query,
-            variables = options.variables,
-            operationName = options.operationName;
-          if (!query) {
-            throw new Error("Must provide a query.");
-          }
-          if (!handler) {
-            throw new Error("Must provide an handler.");
-          }
-          if (
-            (!(0, is_string_1.default)(query) &&
-              !(0, getOperationAST_1.getOperationAST)(query, operationName)) ||
-            (operationName && !(0, is_string_1.default)(operationName)) ||
-            (variables && !(0, is_object_1.default)(variables))
-          ) {
-            throw new Error(
-              "Incorrect option types. query must be a string or a document,`operationName` must be a string, and `variables` must be an object."
-            );
-          }
-        };
-        SubscriptionClient2.prototype.buildMessage = function (
-          id2,
-          type2,
-          payload
-        ) {
-          var payloadToReturn =
-            payload && payload.query
-              ? __assign(__assign({}, payload), {
-                  query:
-                    typeof payload.query === "string"
-                      ? payload.query
-                      : (0, printer_1.print)(payload.query),
-                })
-              : payload;
-          return {
-            id: id2,
-            type: type2,
-            payload: payloadToReturn,
-          };
-        };
-        SubscriptionClient2.prototype.formatErrors = function (errors2) {
-          if (Array.isArray(errors2)) {
-            return errors2;
-          }
-          if (errors2 && errors2.errors) {
-            return this.formatErrors(errors2.errors);
-          }
-          if (errors2 && errors2.message) {
-            return [errors2];
-          }
-          return [
-            {
-              name: "FormatedError",
-              message: "Unknown error",
-              originalError: errors2,
-            },
-          ];
-        };
-        SubscriptionClient2.prototype.sendMessage = function (
-          id2,
-          type2,
-          payload
-        ) {
-          this.sendMessageRaw(this.buildMessage(id2, type2, payload));
-        };
-        SubscriptionClient2.prototype.sendMessageRaw = function (message) {
-          switch (this.status) {
-            case this.wsImpl.OPEN:
-              var serializedMessage = JSON.stringify(message);
-              try {
-                JSON.parse(serializedMessage);
-              } catch (e) {
-                this.eventEmitter.emit(
-                  "error",
-                  new Error(
-                    "Message must be JSON-serializable. Got: " + message
-                  )
-                );
-              }
-              this.client.send(serializedMessage);
-              break;
-            case this.wsImpl.CONNECTING:
-              this.unsentMessagesQueue.push(message);
-              break;
-            default:
-              if (!this.reconnecting) {
-                this.eventEmitter.emit(
-                  "error",
-                  new Error(
-                    "A message was not sent because socket is not connected, is closing or is already closed. Message was: " +
-                      JSON.stringify(message)
-                  )
-                );
-              }
-          }
-        };
-        SubscriptionClient2.prototype.generateOperationId = function () {
-          return String(++this.nextOperationId);
-        };
-        SubscriptionClient2.prototype.tryReconnect = function () {
-          var _this = this;
-          if (
-            !this.reconnect ||
-            this.backoff.attempts >= this.reconnectionAttempts
-          ) {
-            return;
-          }
-          if (!this.reconnecting) {
-            Object.keys(this.operations).forEach(function (key) {
-              _this.unsentMessagesQueue.push(
-                _this.buildMessage(
-                  key,
-                  message_types_1.default.GQL_START,
-                  _this.operations[key].options
-                )
-              );
-            });
-            this.reconnecting = true;
-          }
-          this.clearTryReconnectTimeout();
-          var delay = this.backoff.duration();
-          this.tryReconnectTimeoutId = setTimeout(function () {
-            _this.connect();
-          }, delay);
-        };
-        SubscriptionClient2.prototype.flushUnsentMessagesQueue = function () {
-          var _this = this;
-          this.unsentMessagesQueue.forEach(function (message) {
-            _this.sendMessageRaw(message);
-          });
-          this.unsentMessagesQueue = [];
-        };
-        SubscriptionClient2.prototype.checkConnection = function () {
-          if (this.wasKeepAliveReceived) {
-            this.wasKeepAliveReceived = false;
-            return;
-          }
-          if (!this.reconnecting) {
-            this.close(false, true);
-          }
-        };
-        SubscriptionClient2.prototype.checkMaxConnectTimeout = function () {
-          var _this = this;
-          this.clearMaxConnectTimeout();
-          this.maxConnectTimeoutId = setTimeout(function () {
-            if (_this.status !== _this.wsImpl.OPEN) {
-              _this.reconnecting = true;
-              _this.close(false, true);
-            }
-          }, this.maxConnectTimeGenerator.duration());
-        };
-        SubscriptionClient2.prototype.connect = function () {
-          var _a2;
-          var _this = this;
-          this.client = new ((_a2 = this.wsImpl).bind.apply(
-            _a2,
-            __spreadArray(
-              [void 0, this.url, this.wsProtocols],
-              this.wsOptionArguments,
-              false
-            )
-          ))();
-          this.checkMaxConnectTimeout();
-          this.client.onopen = function () {
-            return __awaiter(_this, void 0, void 0, function () {
-              var connectionParams, error_1;
-              return __generator(this, function (_a3) {
-                switch (_a3.label) {
-                  case 0:
-                    if (!(this.status === this.wsImpl.OPEN)) return [3, 4];
-                    this.clearMaxConnectTimeout();
-                    this.closedByUser = false;
-                    this.eventEmitter.emit(
-                      this.reconnecting ? "reconnecting" : "connecting"
-                    );
-                    _a3.label = 1;
-                  case 1:
-                    _a3.trys.push([1, 3, , 4]);
-                    return [4, this.connectionParams()];
-                  case 2:
-                    connectionParams = _a3.sent();
-                    this.sendMessage(
-                      void 0,
-                      message_types_1.default.GQL_CONNECTION_INIT,
-                      connectionParams
-                    );
-                    this.flushUnsentMessagesQueue();
-                    return [3, 4];
-                  case 3:
-                    error_1 = _a3.sent();
-                    this.sendMessage(
-                      void 0,
-                      message_types_1.default.GQL_CONNECTION_ERROR,
-                      error_1
-                    );
-                    this.flushUnsentMessagesQueue();
-                    return [3, 4];
-                  case 4:
-                    return [2];
-                }
-              });
-            });
-          };
-          this.client.onclose = function () {
-            if (!_this.closedByUser) {
-              _this.close(false, false);
-            }
-          };
-          this.client.onerror = function (err) {
-            _this.eventEmitter.emit("error", err);
-          };
-          this.client.onmessage = function (_a3) {
-            var data = _a3.data;
-            _this.processReceivedData(data);
-          };
-        };
-        SubscriptionClient2.prototype.processReceivedData = function (
-          receivedData
-        ) {
-          var parsedMessage;
-          var opId;
-          try {
-            parsedMessage = JSON.parse(receivedData);
-            opId = parsedMessage.id;
-          } catch (e) {
-            throw new Error(
-              "Message must be JSON-parseable. Got: " + receivedData
-            );
-          }
-          if (
-            [
-              message_types_1.default.GQL_DATA,
-              message_types_1.default.GQL_COMPLETE,
-              message_types_1.default.GQL_ERROR,
-            ].indexOf(parsedMessage.type) !== -1 &&
-            !this.operations[opId]
-          ) {
-            this.unsubscribe(opId);
-            return;
-          }
-          switch (parsedMessage.type) {
-            case message_types_1.default.GQL_CONNECTION_ERROR:
-              if (this.connectionCallback) {
-                this.connectionCallback(parsedMessage.payload);
-              }
-              break;
-            case message_types_1.default.GQL_CONNECTION_ACK:
-              this.eventEmitter.emit(
-                this.reconnecting ? "reconnected" : "connected",
-                parsedMessage.payload
-              );
-              this.reconnecting = false;
-              this.backoff.reset();
-              this.maxConnectTimeGenerator.reset();
-              if (this.connectionCallback) {
-                this.connectionCallback();
-              }
-              break;
-            case message_types_1.default.GQL_COMPLETE:
-              var handler = this.operations[opId].handler;
-              delete this.operations[opId];
-              handler.call(this, null, null);
-              break;
-            case message_types_1.default.GQL_ERROR:
-              this.operations[opId].handler(
-                this.formatErrors(parsedMessage.payload),
-                null
-              );
-              delete this.operations[opId];
-              break;
-            case message_types_1.default.GQL_DATA:
-              var parsedPayload = !parsedMessage.payload.errors
-                ? parsedMessage.payload
-                : __assign(__assign({}, parsedMessage.payload), {
-                    errors: this.formatErrors(parsedMessage.payload.errors),
-                  });
-              this.operations[opId].handler(null, parsedPayload);
-              break;
-            case message_types_1.default.GQL_CONNECTION_KEEP_ALIVE:
-              var firstKA = typeof this.wasKeepAliveReceived === "undefined";
-              this.wasKeepAliveReceived = true;
-              if (firstKA) {
-                this.checkConnection();
-              }
-              if (this.checkConnectionIntervalId) {
-                clearInterval(this.checkConnectionIntervalId);
-                this.checkConnection();
-              }
-              this.checkConnectionIntervalId = setInterval(
-                this.checkConnection.bind(this),
-                this.wsTimeout
-              );
-              break;
-            default:
-              throw new Error("Invalid message type!");
-          }
-        };
-        SubscriptionClient2.prototype.unsubscribe = function (opId) {
-          if (this.operations[opId]) {
-            delete this.operations[opId];
-            this.setInactivityTimeout();
-            this.sendMessage(opId, message_types_1.default.GQL_STOP, void 0);
-          }
-        };
-        return SubscriptionClient2;
-      })();
-      SubscriptionClient_1 = client.SubscriptionClient = SubscriptionClient;
-      const GraphQLLiveDirective = new GraphQLDirective({
-        name: "live",
-        description:
-          "Instruction for establishing a live connection that is updated once the underlying data changes.",
-        locations: [DirectiveLocation.QUERY],
-        args: {
-          if: {
-            type: GraphQLBoolean,
-            defaultValue: true,
-            description: "Whether the query should be live or not.",
-          },
-          throttle: {
-            type: GraphQLInt,
-            description:
-              'Propose a desired throttle interval ot the server in order to receive updates to at most once per "throttle" milliseconds. The server must not accept this value.',
-          },
-        },
-      });
-      const isNone = (input) => input == null;
-      const getLiveDirectiveNode = (input) => {
-        var _a2;
-        if (
-          input.kind !== "OperationDefinition" ||
-          input.operation !== "query"
-        ) {
-          return null;
-        }
-        const liveDirective =
-          (_a2 = input.directives) === null || _a2 === void 0
-            ? void 0
-            : _a2.find((d) => d.name.value === "live");
-        if (isNone(liveDirective)) {
-          return null;
-        }
-        return liveDirective;
-      };
-      const getLiveDirectiveArgumentValues = (node, variableValues) => {
-        var _a2;
-        const values = getDirectiveValues$1(
-          GraphQLLiveDirective,
-          { directives: [node] },
-          variableValues
-        );
-        return {
-          isLive:
-            (values === null || values === void 0 ? void 0 : values["if"]) ===
-            true,
-          throttleValue:
-            (_a2 =
-              values === null || values === void 0
-                ? void 0
-                : values["throttle"]) !== null && _a2 !== void 0
-              ? _a2
-              : null,
-        };
-      };
-      const isLiveQueryOperationDefinitionNode = (input, variables) => {
-        const liveDirectiveNode = getLiveDirectiveNode(input);
-        if (isNone(liveDirectiveNode)) {
-          return false;
-        }
-        return getLiveDirectiveArgumentValues(liveDirectiveNode, variables)
-          .isLive;
-      };
-      var fetch$1 = globalThis.fetch;
-      var FormData = globalThis.FormData;
-      var AbortController$1 = globalThis.AbortController;
-      var File$1 = globalThis.File;
-      var buffer = {};
-      var base64Js = {};
-      base64Js.byteLength = byteLength;
-      base64Js.toByteArray = toByteArray;
-      base64Js.fromByteArray = fromByteArray;
-      var lookup = [];
-      var revLookup = [];
-      var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
-      var code$1 =
-        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-      for (var i = 0, len = code$1.length; i < len; ++i) {
-        lookup[i] = code$1[i];
-        revLookup[code$1.charCodeAt(i)] = i;
-      }
-      revLookup["-".charCodeAt(0)] = 62;
-      revLookup["_".charCodeAt(0)] = 63;
-      function getLens(b64) {
-        var len = b64.length;
-        if (len % 4 > 0) {
-          throw new Error("Invalid string. Length must be a multiple of 4");
-        }
-        var validLen = b64.indexOf("=");
-        if (validLen === -1) validLen = len;
-        var placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4);
-        return [validLen, placeHoldersLen];
-      }
-      function byteLength(b64) {
-        var lens = getLens(b64);
-        var validLen = lens[0];
-        var placeHoldersLen = lens[1];
-        return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
-      }
-      function _byteLength(b64, validLen, placeHoldersLen) {
-        return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
-      }
-      function toByteArray(b64) {
-        var tmp;
-        var lens = getLens(b64);
-        var validLen = lens[0];
-        var placeHoldersLen = lens[1];
-        var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
-        var curByte = 0;
-        var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
-        var i;
-        for (i = 0; i < len; i += 4) {
-          tmp =
-            (revLookup[b64.charCodeAt(i)] << 18) |
-            (revLookup[b64.charCodeAt(i + 1)] << 12) |
-            (revLookup[b64.charCodeAt(i + 2)] << 6) |
-            revLookup[b64.charCodeAt(i + 3)];
-          arr[curByte++] = (tmp >> 16) & 255;
-          arr[curByte++] = (tmp >> 8) & 255;
-          arr[curByte++] = tmp & 255;
-        }
-        if (placeHoldersLen === 2) {
-          tmp =
-            (revLookup[b64.charCodeAt(i)] << 2) |
-            (revLookup[b64.charCodeAt(i + 1)] >> 4);
-          arr[curByte++] = tmp & 255;
-        }
-        if (placeHoldersLen === 1) {
-          tmp =
-            (revLookup[b64.charCodeAt(i)] << 10) |
-            (revLookup[b64.charCodeAt(i + 1)] << 4) |
-            (revLookup[b64.charCodeAt(i + 2)] >> 2);
-          arr[curByte++] = (tmp >> 8) & 255;
-          arr[curByte++] = tmp & 255;
-        }
-        return arr;
-      }
-      function tripletToBase64(num2) {
-        return (
-          lookup[(num2 >> 18) & 63] +
-          lookup[(num2 >> 12) & 63] +
-          lookup[(num2 >> 6) & 63] +
-          lookup[num2 & 63]
-        );
-      }
-      function encodeChunk(uint8, start2, end2) {
-        var tmp;
-        var output = [];
-        for (var i = start2; i < end2; i += 3) {
-          tmp =
-            ((uint8[i] << 16) & 16711680) +
-            ((uint8[i + 1] << 8) & 65280) +
-            (uint8[i + 2] & 255);
-          output.push(tripletToBase64(tmp));
-        }
-        return output.join("");
-      }
-      function fromByteArray(uint8) {
-        var tmp;
-        var len = uint8.length;
-        var extraBytes = len % 3;
-        var parts = [];
-        var maxChunkLength = 16383;
-        for (
-          var i = 0, len2 = len - extraBytes;
-          i < len2;
-          i += maxChunkLength
-        ) {
-          parts.push(
-            encodeChunk(
-              uint8,
-              i,
-              i + maxChunkLength > len2 ? len2 : i + maxChunkLength
-            )
-          );
-        }
-        if (extraBytes === 1) {
-          tmp = uint8[len - 1];
-          parts.push(lookup[tmp >> 2] + lookup[(tmp << 4) & 63] + "==");
-        } else if (extraBytes === 2) {
-          tmp = (uint8[len - 2] << 8) + uint8[len - 1];
-          parts.push(
-            lookup[tmp >> 10] +
-              lookup[(tmp >> 4) & 63] +
-              lookup[(tmp << 2) & 63] +
-              "="
-          );
-        }
-        return parts.join("");
-      }
-      var ieee754 = {};
-      /*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
-      ieee754.read = function (buffer2, offset, isLE, mLen, nBytes) {
-        var e, m;
-        var eLen = nBytes * 8 - mLen - 1;
-        var eMax = (1 << eLen) - 1;
-        var eBias = eMax >> 1;
-        var nBits = -7;
-        var i = isLE ? nBytes - 1 : 0;
-        var d = isLE ? -1 : 1;
-        var s = buffer2[offset + i];
-        i += d;
-        e = s & ((1 << -nBits) - 1);
-        s >>= -nBits;
-        nBits += eLen;
-        for (
-          ;
-          nBits > 0;
-          e = e * 256 + buffer2[offset + i], i += d, nBits -= 8
-        ) {}
-        m = e & ((1 << -nBits) - 1);
-        e >>= -nBits;
-        nBits += mLen;
-        for (
-          ;
-          nBits > 0;
-          m = m * 256 + buffer2[offset + i], i += d, nBits -= 8
-        ) {}
-        if (e === 0) {
-          e = 1 - eBias;
-        } else if (e === eMax) {
-          return m ? NaN : (s ? -1 : 1) * Infinity;
-        } else {
-          m = m + Math.pow(2, mLen);
-          e = e - eBias;
-        }
-        return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
-      };
-      ieee754.write = function (buffer2, value, offset, isLE, mLen, nBytes) {
-        var e, m, c;
-        var eLen = nBytes * 8 - mLen - 1;
-        var eMax = (1 << eLen) - 1;
-        var eBias = eMax >> 1;
-        var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
-        var i = isLE ? 0 : nBytes - 1;
-        var d = isLE ? 1 : -1;
-        var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
-        value = Math.abs(value);
-        if (isNaN(value) || value === Infinity) {
-          m = isNaN(value) ? 1 : 0;
-          e = eMax;
-        } else {
-          e = Math.floor(Math.log(value) / Math.LN2);
-          if (value * (c = Math.pow(2, -e)) < 1) {
-            e--;
-            c *= 2;
-          }
-          if (e + eBias >= 1) {
-            value += rt / c;
-          } else {
-            value += rt * Math.pow(2, 1 - eBias);
-          }
-          if (value * c >= 2) {
-            e++;
-            c /= 2;
-          }
-          if (e + eBias >= eMax) {
-            m = 0;
-            e = eMax;
-          } else if (e + eBias >= 1) {
-            m = (value * c - 1) * Math.pow(2, mLen);
-            e = e + eBias;
-          } else {
-            m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
-            e = 0;
-          }
-        }
-        for (
-          ;
-          mLen >= 8;
-          buffer2[offset + i] = m & 255, i += d, m /= 256, mLen -= 8
-        ) {}
-        e = (e << mLen) | m;
-        eLen += mLen;
-        for (
-          ;
-          eLen > 0;
-          buffer2[offset + i] = e & 255, i += d, e /= 256, eLen -= 8
-        ) {}
-        buffer2[offset + i - d] |= s * 128;
-      };
-      /*!
-       * The buffer module from node.js, for the browser.
-       *
-       * @author   Feross Aboukhadijeh <https://feross.org>
-       * @license  MIT
-       */
-      (function (exports) {
-        var base64 = base64Js;
-        var ieee754$1 = ieee754;
-        var customInspectSymbol =
-          typeof Symbol === "function" && typeof Symbol["for"] === "function"
-            ? Symbol["for"]("nodejs.util.inspect.custom")
-            : null;
-        exports.Buffer = Buffer2;
-        exports.SlowBuffer = SlowBuffer;
-        exports.INSPECT_MAX_BYTES = 50;
-        var K_MAX_LENGTH = 2147483647;
-        exports.kMaxLength = K_MAX_LENGTH;
-        Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
-        if (
-          !Buffer2.TYPED_ARRAY_SUPPORT &&
-          typeof console !== "undefined" &&
-          typeof console.error === "function"
-        ) {
-          console.error(
-            "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
-          );
-        }
-        function typedArraySupport() {
-          try {
-            var arr = new Uint8Array(1);
-            var proto = {
-              foo: function () {
-                return 42;
-              },
-            };
-            Object.setPrototypeOf(proto, Uint8Array.prototype);
-            Object.setPrototypeOf(arr, proto);
-            return arr.foo() === 42;
-          } catch (e) {
-            return false;
-          }
-        }
-        Object.defineProperty(Buffer2.prototype, "parent", {
-          enumerable: true,
-          get: function () {
-            if (!Buffer2.isBuffer(this)) return void 0;
-            return this.buffer;
-          },
-        });
-        Object.defineProperty(Buffer2.prototype, "offset", {
-          enumerable: true,
-          get: function () {
-            if (!Buffer2.isBuffer(this)) return void 0;
-            return this.byteOffset;
-          },
-        });
-        function createBuffer(length) {
-          if (length > K_MAX_LENGTH) {
-            throw new RangeError(
-              'The value "' + length + '" is invalid for option "size"'
-            );
-          }
-          var buf = new Uint8Array(length);
-          Object.setPrototypeOf(buf, Buffer2.prototype);
-          return buf;
-        }
-        function Buffer2(arg, encodingOrOffset, length) {
-          if (typeof arg === "number") {
-            if (typeof encodingOrOffset === "string") {
-              throw new TypeError(
-                'The "string" argument must be of type string. Received type number'
-              );
-            }
-            return allocUnsafe(arg);
-          }
-          return from(arg, encodingOrOffset, length);
-        }
-        Buffer2.poolSize = 8192;
-        function from(value, encodingOrOffset, length) {
-          if (typeof value === "string") {
-            return fromString(value, encodingOrOffset);
-          }
-          if (ArrayBuffer.isView(value)) {
-            return fromArrayView(value);
-          }
-          if (value == null) {
-            throw new TypeError(
-              "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " +
-                typeof value
-            );
-          }
-          if (
-            isInstance(value, ArrayBuffer) ||
-            (value && isInstance(value.buffer, ArrayBuffer))
-          ) {
-            return fromArrayBuffer(value, encodingOrOffset, length);
-          }
-          if (
-            typeof SharedArrayBuffer !== "undefined" &&
-            (isInstance(value, SharedArrayBuffer) ||
-              (value && isInstance(value.buffer, SharedArrayBuffer)))
-          ) {
-            return fromArrayBuffer(value, encodingOrOffset, length);
-          }
-          if (typeof value === "number") {
-            throw new TypeError(
-              'The "value" argument must not be of type number. Received type number'
-            );
-          }
-          var valueOf = value.valueOf && value.valueOf();
-          if (valueOf != null && valueOf !== value) {
-            return Buffer2.from(valueOf, encodingOrOffset, length);
-          }
-          var b = fromObject(value);
-          if (b) return b;
-          if (
-            typeof Symbol !== "undefined" &&
-            Symbol.toPrimitive != null &&
-            typeof value[Symbol.toPrimitive] === "function"
-          ) {
-            return Buffer2.from(
-              value[Symbol.toPrimitive]("string"),
-              encodingOrOffset,
-              length
-            );
-          }
-          throw new TypeError(
-            "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " +
-              typeof value
-          );
-        }
-        Buffer2.from = function (value, encodingOrOffset, length) {
-          return from(value, encodingOrOffset, length);
-        };
-        Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
-        Object.setPrototypeOf(Buffer2, Uint8Array);
-        function assertSize(size) {
-          if (typeof size !== "number") {
-            throw new TypeError('"size" argument must be of type number');
-          } else if (size < 0) {
-            throw new RangeError(
-              'The value "' + size + '" is invalid for option "size"'
-            );
-          }
-        }
-        function alloc(size, fill, encoding) {
-          assertSize(size);
-          if (size <= 0) {
-            return createBuffer(size);
-          }
-          if (fill !== void 0) {
-            return typeof encoding === "string"
-              ? createBuffer(size).fill(fill, encoding)
-              : createBuffer(size).fill(fill);
-          }
-          return createBuffer(size);
-        }
-        Buffer2.alloc = function (size, fill, encoding) {
-          return alloc(size, fill, encoding);
-        };
-        function allocUnsafe(size) {
-          assertSize(size);
-          return createBuffer(size < 0 ? 0 : checked(size) | 0);
-        }
-        Buffer2.allocUnsafe = function (size) {
-          return allocUnsafe(size);
-        };
-        Buffer2.allocUnsafeSlow = function (size) {
-          return allocUnsafe(size);
-        };
-        function fromString(string2, encoding) {
-          if (typeof encoding !== "string" || encoding === "") {
-            encoding = "utf8";
-          }
-          if (!Buffer2.isEncoding(encoding)) {
-            throw new TypeError("Unknown encoding: " + encoding);
-          }
-          var length = byteLength2(string2, encoding) | 0;
-          var buf = createBuffer(length);
-          var actual = buf.write(string2, encoding);
-          if (actual !== length) {
-            buf = buf.slice(0, actual);
-          }
-          return buf;
-        }
-        function fromArrayLike(array) {
-          var length = array.length < 0 ? 0 : checked(array.length) | 0;
-          var buf = createBuffer(length);
-          for (var i = 0; i < length; i += 1) {
-            buf[i] = array[i] & 255;
-          }
-          return buf;
-        }
-        function fromArrayView(arrayView) {
-          if (isInstance(arrayView, Uint8Array)) {
-            var copy2 = new Uint8Array(arrayView);
-            return fromArrayBuffer(
-              copy2.buffer,
-              copy2.byteOffset,
-              copy2.byteLength
-            );
-          }
-          return fromArrayLike(arrayView);
-        }
-        function fromArrayBuffer(array, byteOffset, length) {
-          if (byteOffset < 0 || array.byteLength < byteOffset) {
-            throw new RangeError('"offset" is outside of buffer bounds');
-          }
-          if (array.byteLength < byteOffset + (length || 0)) {
-            throw new RangeError('"length" is outside of buffer bounds');
-          }
-          var buf;
-          if (byteOffset === void 0 && length === void 0) {
-            buf = new Uint8Array(array);
-          } else if (length === void 0) {
-            buf = new Uint8Array(array, byteOffset);
-          } else {
-            buf = new Uint8Array(array, byteOffset, length);
-          }
-          Object.setPrototypeOf(buf, Buffer2.prototype);
-          return buf;
-        }
-        function fromObject(obj) {
-          if (Buffer2.isBuffer(obj)) {
-            var len = checked(obj.length) | 0;
-            var buf = createBuffer(len);
-            if (buf.length === 0) {
-              return buf;
-            }
-            obj.copy(buf, 0, 0, len);
-            return buf;
-          }
-          if (obj.length !== void 0) {
-            if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
-              return createBuffer(0);
-            }
-            return fromArrayLike(obj);
-          }
-          if (obj.type === "Buffer" && Array.isArray(obj.data)) {
-            return fromArrayLike(obj.data);
-          }
-        }
-        function checked(length) {
-          if (length >= K_MAX_LENGTH) {
-            throw new RangeError(
-              "Attempt to allocate Buffer larger than maximum size: 0x" +
-                K_MAX_LENGTH.toString(16) +
-                " bytes"
-            );
-          }
-          return length | 0;
-        }
-        function SlowBuffer(length) {
-          if (+length != length) {
-            length = 0;
-          }
-          return Buffer2.alloc(+length);
-        }
-        Buffer2.isBuffer = function isBuffer(b) {
-          return b != null && b._isBuffer === true && b !== Buffer2.prototype;
-        };
-        Buffer2.compare = function compare(a, b) {
-          if (isInstance(a, Uint8Array))
-            a = Buffer2.from(a, a.offset, a.byteLength);
-          if (isInstance(b, Uint8Array))
-            b = Buffer2.from(b, b.offset, b.byteLength);
-          if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
-            throw new TypeError(
-              'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
-            );
-          }
-          if (a === b) return 0;
-          var x2 = a.length;
-          var y2 = b.length;
-          for (var i = 0, len = Math.min(x2, y2); i < len; ++i) {
-            if (a[i] !== b[i]) {
-              x2 = a[i];
-              y2 = b[i];
-              break;
-            }
-          }
-          if (x2 < y2) return -1;
-          if (y2 < x2) return 1;
-          return 0;
-        };
-        Buffer2.isEncoding = function isEncoding(encoding) {
-          switch (String(encoding).toLowerCase()) {
-            case "hex":
-            case "utf8":
-            case "utf-8":
-            case "ascii":
-            case "latin1":
-            case "binary":
-            case "base64":
-            case "ucs2":
-            case "ucs-2":
-            case "utf16le":
-            case "utf-16le":
-              return true;
-            default:
-              return false;
-          }
-        };
-        Buffer2.concat = function concat2(list3, length) {
-          if (!Array.isArray(list3)) {
-            throw new TypeError('"list" argument must be an Array of Buffers');
-          }
-          if (list3.length === 0) {
-            return Buffer2.alloc(0);
-          }
-          var i;
-          if (length === void 0) {
-            length = 0;
-            for (i = 0; i < list3.length; ++i) {
-              length += list3[i].length;
-            }
-          }
-          var buffer2 = Buffer2.allocUnsafe(length);
-          var pos = 0;
-          for (i = 0; i < list3.length; ++i) {
-            var buf = list3[i];
-            if (isInstance(buf, Uint8Array)) {
-              if (pos + buf.length > buffer2.length) {
-                Buffer2.from(buf).copy(buffer2, pos);
-              } else {
-                Uint8Array.prototype.set.call(buffer2, buf, pos);
-              }
-            } else if (!Buffer2.isBuffer(buf)) {
-              throw new TypeError(
-                '"list" argument must be an Array of Buffers'
-              );
-            } else {
-              buf.copy(buffer2, pos);
-            }
-            pos += buf.length;
-          }
-          return buffer2;
-        };
-        function byteLength2(string2, encoding) {
-          if (Buffer2.isBuffer(string2)) {
-            return string2.length;
-          }
-          if (ArrayBuffer.isView(string2) || isInstance(string2, ArrayBuffer)) {
-            return string2.byteLength;
-          }
-          if (typeof string2 !== "string") {
-            throw new TypeError(
-              'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' +
-                typeof string2
-            );
-          }
-          var len = string2.length;
-          var mustMatch = arguments.length > 2 && arguments[2] === true;
-          if (!mustMatch && len === 0) return 0;
-          var loweredCase = false;
-          for (;;) {
-            switch (encoding) {
-              case "ascii":
-              case "latin1":
-              case "binary":
-                return len;
-              case "utf8":
-              case "utf-8":
-                return utf8ToBytes(string2).length;
-              case "ucs2":
-              case "ucs-2":
-              case "utf16le":
-              case "utf-16le":
-                return len * 2;
-              case "hex":
-                return len >>> 1;
-              case "base64":
-                return base64ToBytes(string2).length;
-              default:
-                if (loweredCase) {
-                  return mustMatch ? -1 : utf8ToBytes(string2).length;
-                }
-                encoding = ("" + encoding).toLowerCase();
-                loweredCase = true;
-            }
-          }
-        }
-        Buffer2.byteLength = byteLength2;
-        function slowToString(encoding, start2, end2) {
-          var loweredCase = false;
-          if (start2 === void 0 || start2 < 0) {
-            start2 = 0;
-          }
-          if (start2 > this.length) {
-            return "";
-          }
-          if (end2 === void 0 || end2 > this.length) {
-            end2 = this.length;
-          }
-          if (end2 <= 0) {
-            return "";
-          }
-          end2 >>>= 0;
-          start2 >>>= 0;
-          if (end2 <= start2) {
-            return "";
-          }
-          if (!encoding) encoding = "utf8";
-          while (true) {
-            switch (encoding) {
-              case "hex":
-                return hexSlice(this, start2, end2);
-              case "utf8":
-              case "utf-8":
-                return utf8Slice(this, start2, end2);
-              case "ascii":
-                return asciiSlice(this, start2, end2);
-              case "latin1":
-              case "binary":
-                return latin1Slice(this, start2, end2);
-              case "base64":
-                return base64Slice(this, start2, end2);
-              case "ucs2":
-              case "ucs-2":
-              case "utf16le":
-              case "utf-16le":
-                return utf16leSlice(this, start2, end2);
-              default:
-                if (loweredCase)
-                  throw new TypeError("Unknown encoding: " + encoding);
-                encoding = (encoding + "").toLowerCase();
-                loweredCase = true;
-            }
-          }
-        }
-        Buffer2.prototype._isBuffer = true;
-        function swap(b, n2, m) {
-          var i = b[n2];
-          b[n2] = b[m];
-          b[m] = i;
-        }
-        Buffer2.prototype.swap16 = function swap16() {
-          var len = this.length;
-          if (len % 2 !== 0) {
-            throw new RangeError("Buffer size must be a multiple of 16-bits");
-          }
-          for (var i = 0; i < len; i += 2) {
-            swap(this, i, i + 1);
-          }
-          return this;
-        };
-        Buffer2.prototype.swap32 = function swap32() {
-          var len = this.length;
-          if (len % 4 !== 0) {
-            throw new RangeError("Buffer size must be a multiple of 32-bits");
-          }
-          for (var i = 0; i < len; i += 4) {
-            swap(this, i, i + 3);
-            swap(this, i + 1, i + 2);
-          }
-          return this;
-        };
-        Buffer2.prototype.swap64 = function swap64() {
-          var len = this.length;
-          if (len % 8 !== 0) {
-            throw new RangeError("Buffer size must be a multiple of 64-bits");
-          }
-          for (var i = 0; i < len; i += 8) {
-            swap(this, i, i + 7);
-            swap(this, i + 1, i + 6);
-            swap(this, i + 2, i + 5);
-            swap(this, i + 3, i + 4);
-          }
-          return this;
-        };
-        Buffer2.prototype.toString = function toString() {
-          var length = this.length;
-          if (length === 0) return "";
-          if (arguments.length === 0) return utf8Slice(this, 0, length);
-          return slowToString.apply(this, arguments);
-        };
-        Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
-        Buffer2.prototype.equals = function equals2(b) {
-          if (!Buffer2.isBuffer(b))
-            throw new TypeError("Argument must be a Buffer");
-          if (this === b) return true;
-          return Buffer2.compare(this, b) === 0;
-        };
-        Buffer2.prototype.inspect = function inspect2() {
-          var str = "";
-          var max = exports.INSPECT_MAX_BYTES;
-          str = this.toString("hex", 0, max)
-            .replace(/(.{2})/g, "$1 ")
-            .trim();
-          if (this.length > max) str += " ... ";
-          return "<Buffer " + str + ">";
-        };
-        if (customInspectSymbol) {
-          Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
-        }
-        Buffer2.prototype.compare = function compare(
-          target2,
-          start2,
-          end2,
-          thisStart,
-          thisEnd
-        ) {
-          if (isInstance(target2, Uint8Array)) {
-            target2 = Buffer2.from(target2, target2.offset, target2.byteLength);
-          }
-          if (!Buffer2.isBuffer(target2)) {
-            throw new TypeError(
-              'The "target" argument must be one of type Buffer or Uint8Array. Received type ' +
-                typeof target2
-            );
-          }
-          if (start2 === void 0) {
-            start2 = 0;
-          }
-          if (end2 === void 0) {
-            end2 = target2 ? target2.length : 0;
-          }
-          if (thisStart === void 0) {
-            thisStart = 0;
-          }
-          if (thisEnd === void 0) {
-            thisEnd = this.length;
-          }
-          if (
-            start2 < 0 ||
-            end2 > target2.length ||
-            thisStart < 0 ||
-            thisEnd > this.length
-          ) {
-            throw new RangeError("out of range index");
-          }
-          if (thisStart >= thisEnd && start2 >= end2) {
-            return 0;
-          }
-          if (thisStart >= thisEnd) {
-            return -1;
-          }
-          if (start2 >= end2) {
-            return 1;
-          }
-          start2 >>>= 0;
-          end2 >>>= 0;
-          thisStart >>>= 0;
-          thisEnd >>>= 0;
-          if (this === target2) return 0;
-          var x2 = thisEnd - thisStart;
-          var y2 = end2 - start2;
-          var len = Math.min(x2, y2);
-          var thisCopy = this.slice(thisStart, thisEnd);
-          var targetCopy = target2.slice(start2, end2);
-          for (var i = 0; i < len; ++i) {
-            if (thisCopy[i] !== targetCopy[i]) {
-              x2 = thisCopy[i];
-              y2 = targetCopy[i];
-              break;
-            }
-          }
-          if (x2 < y2) return -1;
-          if (y2 < x2) return 1;
-          return 0;
-        };
-        function bidirectionalIndexOf(buffer2, val, byteOffset, encoding, dir) {
-          if (buffer2.length === 0) return -1;
-          if (typeof byteOffset === "string") {
-            encoding = byteOffset;
-            byteOffset = 0;
-          } else if (byteOffset > 2147483647) {
-            byteOffset = 2147483647;
-          } else if (byteOffset < -2147483648) {
-            byteOffset = -2147483648;
-          }
-          byteOffset = +byteOffset;
-          if (numberIsNaN(byteOffset)) {
-            byteOffset = dir ? 0 : buffer2.length - 1;
-          }
-          if (byteOffset < 0) byteOffset = buffer2.length + byteOffset;
-          if (byteOffset >= buffer2.length) {
-            if (dir) return -1;
-            else byteOffset = buffer2.length - 1;
-          } else if (byteOffset < 0) {
-            if (dir) byteOffset = 0;
-            else return -1;
-          }
-          if (typeof val === "string") {
-            val = Buffer2.from(val, encoding);
-          }
-          if (Buffer2.isBuffer(val)) {
-            if (val.length === 0) {
-              return -1;
-            }
-            return arrayIndexOf(buffer2, val, byteOffset, encoding, dir);
-          } else if (typeof val === "number") {
-            val = val & 255;
-            if (typeof Uint8Array.prototype.indexOf === "function") {
-              if (dir) {
-                return Uint8Array.prototype.indexOf.call(
-                  buffer2,
-                  val,
-                  byteOffset
-                );
-              } else {
-                return Uint8Array.prototype.lastIndexOf.call(
-                  buffer2,
-                  val,
-                  byteOffset
-                );
-              }
-            }
-            return arrayIndexOf(buffer2, [val], byteOffset, encoding, dir);
-          }
-          throw new TypeError("val must be string, number or Buffer");
-        }
-        function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
-          var indexSize = 1;
-          var arrLength = arr.length;
-          var valLength = val.length;
-          if (encoding !== void 0) {
-            encoding = String(encoding).toLowerCase();
-            if (
-              encoding === "ucs2" ||
-              encoding === "ucs-2" ||
-              encoding === "utf16le" ||
-              encoding === "utf-16le"
-            ) {
-              if (arr.length < 2 || val.length < 2) {
-                return -1;
-              }
-              indexSize = 2;
-              arrLength /= 2;
-              valLength /= 2;
-              byteOffset /= 2;
-            }
-          }
-          function read(buf, i2) {
-            if (indexSize === 1) {
-              return buf[i2];
-            } else {
-              return buf.readUInt16BE(i2 * indexSize);
-            }
-          }
-          var i;
-          if (dir) {
-            var foundIndex = -1;
-            for (i = byteOffset; i < arrLength; i++) {
-              if (
-                read(arr, i) ===
-                read(val, foundIndex === -1 ? 0 : i - foundIndex)
-              ) {
-                if (foundIndex === -1) foundIndex = i;
-                if (i - foundIndex + 1 === valLength)
-                  return foundIndex * indexSize;
-              } else {
-                if (foundIndex !== -1) i -= i - foundIndex;
-                foundIndex = -1;
-              }
-            }
-          } else {
-            if (byteOffset + valLength > arrLength)
-              byteOffset = arrLength - valLength;
-            for (i = byteOffset; i >= 0; i--) {
-              var found = true;
-              for (var j = 0; j < valLength; j++) {
-                if (read(arr, i + j) !== read(val, j)) {
-                  found = false;
-                  break;
-                }
-              }
-              if (found) return i;
-            }
-          }
-          return -1;
-        }
-        Buffer2.prototype.includes = function includes(
-          val,
-          byteOffset,
-          encoding
-        ) {
-          return this.indexOf(val, byteOffset, encoding) !== -1;
-        };
-        Buffer2.prototype.indexOf = function indexOf(
-          val,
-          byteOffset,
-          encoding
-        ) {
-          return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
-        };
-        Buffer2.prototype.lastIndexOf = function lastIndexOf(
-          val,
-          byteOffset,
-          encoding
-        ) {
-          return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
-        };
-        function hexWrite(buf, string2, offset, length) {
-          offset = Number(offset) || 0;
-          var remaining = buf.length - offset;
-          if (!length) {
-            length = remaining;
-          } else {
-            length = Number(length);
-            if (length > remaining) {
-              length = remaining;
-            }
-          }
-          var strLen2 = string2.length;
-          if (length > strLen2 / 2) {
-            length = strLen2 / 2;
-          }
-          for (var i = 0; i < length; ++i) {
-            var parsed = parseInt(string2.substr(i * 2, 2), 16);
-            if (numberIsNaN(parsed)) return i;
-            buf[offset + i] = parsed;
-          }
-          return i;
-        }
-        function utf8Write(buf, string2, offset, length) {
-          return blitBuffer(
-            utf8ToBytes(string2, buf.length - offset),
-            buf,
-            offset,
-            length
-          );
-        }
-        function asciiWrite(buf, string2, offset, length) {
-          return blitBuffer(asciiToBytes(string2), buf, offset, length);
-        }
-        function base64Write(buf, string2, offset, length) {
-          return blitBuffer(base64ToBytes(string2), buf, offset, length);
-        }
-        function ucs2Write(buf, string2, offset, length) {
-          return blitBuffer(
-            utf16leToBytes(string2, buf.length - offset),
-            buf,
-            offset,
-            length
-          );
-        }
-        Buffer2.prototype.write = function write(
-          string2,
-          offset,
-          length,
-          encoding
-        ) {
-          if (offset === void 0) {
-            encoding = "utf8";
-            length = this.length;
-            offset = 0;
-          } else if (length === void 0 && typeof offset === "string") {
-            encoding = offset;
-            length = this.length;
-            offset = 0;
-          } else if (isFinite(offset)) {
-            offset = offset >>> 0;
-            if (isFinite(length)) {
-              length = length >>> 0;
-              if (encoding === void 0) encoding = "utf8";
-            } else {
-              encoding = length;
-              length = void 0;
-            }
-          } else {
-            throw new Error(
-              "Buffer.write(string, encoding, offset[, length]) is no longer supported"
-            );
-          }
-          var remaining = this.length - offset;
-          if (length === void 0 || length > remaining) length = remaining;
-          if (
-            (string2.length > 0 && (length < 0 || offset < 0)) ||
-            offset > this.length
-          ) {
-            throw new RangeError("Attempt to write outside buffer bounds");
-          }
-          if (!encoding) encoding = "utf8";
-          var loweredCase = false;
-          for (;;) {
-            switch (encoding) {
-              case "hex":
-                return hexWrite(this, string2, offset, length);
-              case "utf8":
-              case "utf-8":
-                return utf8Write(this, string2, offset, length);
-              case "ascii":
-              case "latin1":
-              case "binary":
-                return asciiWrite(this, string2, offset, length);
-              case "base64":
-                return base64Write(this, string2, offset, length);
-              case "ucs2":
-              case "ucs-2":
-              case "utf16le":
-              case "utf-16le":
-                return ucs2Write(this, string2, offset, length);
-              default:
-                if (loweredCase)
-                  throw new TypeError("Unknown encoding: " + encoding);
-                encoding = ("" + encoding).toLowerCase();
-                loweredCase = true;
-            }
-          }
-        };
-        Buffer2.prototype.toJSON = function toJSON() {
-          return {
-            type: "Buffer",
-            data: Array.prototype.slice.call(this._arr || this, 0),
-          };
-        };
-        function base64Slice(buf, start2, end2) {
-          if (start2 === 0 && end2 === buf.length) {
-            return base64.fromByteArray(buf);
-          } else {
-            return base64.fromByteArray(buf.slice(start2, end2));
-          }
-        }
-        function utf8Slice(buf, start2, end2) {
-          end2 = Math.min(buf.length, end2);
-          var res = [];
-          var i = start2;
-          while (i < end2) {
-            var firstByte = buf[i];
-            var codePoint = null;
-            var bytesPerSequence =
-              firstByte > 239
-                ? 4
-                : firstByte > 223
-                ? 3
-                : firstByte > 191
-                ? 2
-                : 1;
-            if (i + bytesPerSequence <= end2) {
-              var secondByte, thirdByte, fourthByte, tempCodePoint;
-              switch (bytesPerSequence) {
-                case 1:
-                  if (firstByte < 128) {
-                    codePoint = firstByte;
-                  }
-                  break;
-                case 2:
-                  secondByte = buf[i + 1];
-                  if ((secondByte & 192) === 128) {
-                    tempCodePoint = ((firstByte & 31) << 6) | (secondByte & 63);
-                    if (tempCodePoint > 127) {
-                      codePoint = tempCodePoint;
-                    }
-                  }
-                  break;
-                case 3:
-                  secondByte = buf[i + 1];
-                  thirdByte = buf[i + 2];
-                  if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
-                    tempCodePoint =
-                      ((firstByte & 15) << 12) |
-                      ((secondByte & 63) << 6) |
-                      (thirdByte & 63);
-                    if (
-                      tempCodePoint > 2047 &&
-                      (tempCodePoint < 55296 || tempCodePoint > 57343)
-                    ) {
-                      codePoint = tempCodePoint;
-                    }
-                  }
-                  break;
-                case 4:
-                  secondByte = buf[i + 1];
-                  thirdByte = buf[i + 2];
-                  fourthByte = buf[i + 3];
-                  if (
-                    (secondByte & 192) === 128 &&
-                    (thirdByte & 192) === 128 &&
-                    (fourthByte & 192) === 128
-                  ) {
-                    tempCodePoint =
-                      ((firstByte & 15) << 18) |
-                      ((secondByte & 63) << 12) |
-                      ((thirdByte & 63) << 6) |
-                      (fourthByte & 63);
-                    if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
-                      codePoint = tempCodePoint;
-                    }
-                  }
-              }
-            }
-            if (codePoint === null) {
-              codePoint = 65533;
-              bytesPerSequence = 1;
-            } else if (codePoint > 65535) {
-              codePoint -= 65536;
-              res.push(((codePoint >>> 10) & 1023) | 55296);
-              codePoint = 56320 | (codePoint & 1023);
-            }
-            res.push(codePoint);
-            i += bytesPerSequence;
-          }
-          return decodeCodePointsArray(res);
-        }
-        var MAX_ARGUMENTS_LENGTH = 4096;
-        function decodeCodePointsArray(codePoints) {
-          var len = codePoints.length;
-          if (len <= MAX_ARGUMENTS_LENGTH) {
-            return String.fromCharCode.apply(String, codePoints);
-          }
-          var res = "";
-          var i = 0;
-          while (i < len) {
-            res += String.fromCharCode.apply(
-              String,
-              codePoints.slice(i, (i += MAX_ARGUMENTS_LENGTH))
-            );
-          }
-          return res;
-        }
-        function asciiSlice(buf, start2, end2) {
-          var ret = "";
-          end2 = Math.min(buf.length, end2);
-          for (var i = start2; i < end2; ++i) {
-            ret += String.fromCharCode(buf[i] & 127);
-          }
-          return ret;
-        }
-        function latin1Slice(buf, start2, end2) {
-          var ret = "";
-          end2 = Math.min(buf.length, end2);
-          for (var i = start2; i < end2; ++i) {
-            ret += String.fromCharCode(buf[i]);
-          }
-          return ret;
-        }
-        function hexSlice(buf, start2, end2) {
-          var len = buf.length;
-          if (!start2 || start2 < 0) start2 = 0;
-          if (!end2 || end2 < 0 || end2 > len) end2 = len;
-          var out = "";
-          for (var i = start2; i < end2; ++i) {
-            out += hexSliceLookupTable[buf[i]];
-          }
-          return out;
-        }
-        function utf16leSlice(buf, start2, end2) {
-          var bytes = buf.slice(start2, end2);
-          var res = "";
-          for (var i = 0; i < bytes.length - 1; i += 2) {
-            res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
-          }
-          return res;
-        }
-        Buffer2.prototype.slice = function slice(start2, end2) {
-          var len = this.length;
-          start2 = ~~start2;
-          end2 = end2 === void 0 ? len : ~~end2;
-          if (start2 < 0) {
-            start2 += len;
-            if (start2 < 0) start2 = 0;
-          } else if (start2 > len) {
-            start2 = len;
-          }
-          if (end2 < 0) {
-            end2 += len;
-            if (end2 < 0) end2 = 0;
-          } else if (end2 > len) {
-            end2 = len;
-          }
-          if (end2 < start2) end2 = start2;
-          var newBuf = this.subarray(start2, end2);
-          Object.setPrototypeOf(newBuf, Buffer2.prototype);
-          return newBuf;
-        };
-        function checkOffset(offset, ext, length) {
-          if (offset % 1 !== 0 || offset < 0)
-            throw new RangeError("offset is not uint");
-          if (offset + ext > length)
-            throw new RangeError("Trying to access beyond buffer length");
-        }
-        Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE =
-          function readUIntLE(offset, byteLength3, noAssert) {
-            offset = offset >>> 0;
-            byteLength3 = byteLength3 >>> 0;
-            if (!noAssert) checkOffset(offset, byteLength3, this.length);
-            var val = this[offset];
-            var mul = 1;
-            var i = 0;
-            while (++i < byteLength3 && (mul *= 256)) {
-              val += this[offset + i] * mul;
-            }
-            return val;
-          };
-        Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE =
-          function readUIntBE(offset, byteLength3, noAssert) {
-            offset = offset >>> 0;
-            byteLength3 = byteLength3 >>> 0;
-            if (!noAssert) {
-              checkOffset(offset, byteLength3, this.length);
-            }
-            var val = this[offset + --byteLength3];
-            var mul = 1;
-            while (byteLength3 > 0 && (mul *= 256)) {
-              val += this[offset + --byteLength3] * mul;
-            }
-            return val;
-          };
-        Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 =
-          function readUInt8(offset, noAssert) {
-            offset = offset >>> 0;
-            if (!noAssert) checkOffset(offset, 1, this.length);
-            return this[offset];
-          };
-        Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE =
-          function readUInt16LE(offset, noAssert) {
-            offset = offset >>> 0;
-            if (!noAssert) checkOffset(offset, 2, this.length);
-            return this[offset] | (this[offset + 1] << 8);
-          };
-        Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE =
-          function readUInt16BE(offset, noAssert) {
-            offset = offset >>> 0;
-            if (!noAssert) checkOffset(offset, 2, this.length);
-            return (this[offset] << 8) | this[offset + 1];
-          };
-        Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE =
-          function readUInt32LE(offset, noAssert) {
-            offset = offset >>> 0;
-            if (!noAssert) checkOffset(offset, 4, this.length);
-            return (
-              (this[offset] |
-                (this[offset + 1] << 8) |
-                (this[offset + 2] << 16)) +
-              this[offset + 3] * 16777216
-            );
-          };
-        Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE =
-          function readUInt32BE(offset, noAssert) {
-            offset = offset >>> 0;
-            if (!noAssert) checkOffset(offset, 4, this.length);
-            return (
-              this[offset] * 16777216 +
-              ((this[offset + 1] << 16) |
-                (this[offset + 2] << 8) |
-                this[offset + 3])
-            );
-          };
-        Buffer2.prototype.readIntLE = function readIntLE(
-          offset,
-          byteLength3,
-          noAssert
-        ) {
-          offset = offset >>> 0;
-          byteLength3 = byteLength3 >>> 0;
-          if (!noAssert) checkOffset(offset, byteLength3, this.length);
-          var val = this[offset];
-          var mul = 1;
-          var i = 0;
-          while (++i < byteLength3 && (mul *= 256)) {
-            val += this[offset + i] * mul;
-          }
-          mul *= 128;
-          if (val >= mul) val -= Math.pow(2, 8 * byteLength3);
-          return val;
-        };
-        Buffer2.prototype.readIntBE = function readIntBE(
-          offset,
-          byteLength3,
-          noAssert
-        ) {
-          offset = offset >>> 0;
-          byteLength3 = byteLength3 >>> 0;
-          if (!noAssert) checkOffset(offset, byteLength3, this.length);
-          var i = byteLength3;
-          var mul = 1;
-          var val = this[offset + --i];
-          while (i > 0 && (mul *= 256)) {
-            val += this[offset + --i] * mul;
-          }
-          mul *= 128;
-          if (val >= mul) val -= Math.pow(2, 8 * byteLength3);
-          return val;
-        };
-        Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {
-          offset = offset >>> 0;
-          if (!noAssert) checkOffset(offset, 1, this.length);
-          if (!(this[offset] & 128)) return this[offset];
-          return (255 - this[offset] + 1) * -1;
-        };
-        Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
-          offset = offset >>> 0;
-          if (!noAssert) checkOffset(offset, 2, this.length);
-          var val = this[offset] | (this[offset + 1] << 8);
-          return val & 32768 ? val | 4294901760 : val;
-        };
-        Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
-          offset = offset >>> 0;
-          if (!noAssert) checkOffset(offset, 2, this.length);
-          var val = this[offset + 1] | (this[offset] << 8);
-          return val & 32768 ? val | 4294901760 : val;
-        };
-        Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
-          offset = offset >>> 0;
-          if (!noAssert) checkOffset(offset, 4, this.length);
-          return (
-            this[offset] |
-            (this[offset + 1] << 8) |
-            (this[offset + 2] << 16) |
-            (this[offset + 3] << 24)
-          );
-        };
-        Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
-          offset = offset >>> 0;
-          if (!noAssert) checkOffset(offset, 4, this.length);
-          return (
-            (this[offset] << 24) |
-            (this[offset + 1] << 16) |
-            (this[offset + 2] << 8) |
-            this[offset + 3]
-          );
-        };
-        Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
-          offset = offset >>> 0;
-          if (!noAssert) checkOffset(offset, 4, this.length);
-          return ieee754$1.read(this, offset, true, 23, 4);
-        };
-        Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
-          offset = offset >>> 0;
-          if (!noAssert) checkOffset(offset, 4, this.length);
-          return ieee754$1.read(this, offset, false, 23, 4);
-        };
-        Buffer2.prototype.readDoubleLE = function readDoubleLE(
-          offset,
-          noAssert
-        ) {
-          offset = offset >>> 0;
-          if (!noAssert) checkOffset(offset, 8, this.length);
-          return ieee754$1.read(this, offset, true, 52, 8);
-        };
-        Buffer2.prototype.readDoubleBE = function readDoubleBE(
-          offset,
-          noAssert
-        ) {
-          offset = offset >>> 0;
-          if (!noAssert) checkOffset(offset, 8, this.length);
-          return ieee754$1.read(this, offset, false, 52, 8);
-        };
-        function checkInt(buf, value, offset, ext, max, min) {
-          if (!Buffer2.isBuffer(buf))
-            throw new TypeError('"buffer" argument must be a Buffer instance');
-          if (value > max || value < min)
-            throw new RangeError('"value" argument is out of bounds');
-          if (offset + ext > buf.length)
-            throw new RangeError("Index out of range");
-        }
-        Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE =
-          function writeUIntLE(value, offset, byteLength3, noAssert) {
-            value = +value;
-            offset = offset >>> 0;
-            byteLength3 = byteLength3 >>> 0;
-            if (!noAssert) {
-              var maxBytes = Math.pow(2, 8 * byteLength3) - 1;
-              checkInt(this, value, offset, byteLength3, maxBytes, 0);
-            }
-            var mul = 1;
-            var i = 0;
-            this[offset] = value & 255;
-            while (++i < byteLength3 && (mul *= 256)) {
-              this[offset + i] = (value / mul) & 255;
-            }
-            return offset + byteLength3;
-          };
-        Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE =
-          function writeUIntBE(value, offset, byteLength3, noAssert) {
-            value = +value;
-            offset = offset >>> 0;
-            byteLength3 = byteLength3 >>> 0;
-            if (!noAssert) {
-              var maxBytes = Math.pow(2, 8 * byteLength3) - 1;
-              checkInt(this, value, offset, byteLength3, maxBytes, 0);
-            }
-            var i = byteLength3 - 1;
-            var mul = 1;
-            this[offset + i] = value & 255;
-            while (--i >= 0 && (mul *= 256)) {
-              this[offset + i] = (value / mul) & 255;
-            }
-            return offset + byteLength3;
-          };
-        Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 =
-          function writeUInt8(value, offset, noAssert) {
-            value = +value;
-            offset = offset >>> 0;
-            if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
-            this[offset] = value & 255;
-            return offset + 1;
-          };
-        Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE =
-          function writeUInt16LE(value, offset, noAssert) {
-            value = +value;
-            offset = offset >>> 0;
-            if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
-            this[offset] = value & 255;
-            this[offset + 1] = value >>> 8;
-            return offset + 2;
-          };
-        Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE =
-          function writeUInt16BE(value, offset, noAssert) {
-            value = +value;
-            offset = offset >>> 0;
-            if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
-            this[offset] = value >>> 8;
-            this[offset + 1] = value & 255;
-            return offset + 2;
-          };
-        Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE =
-          function writeUInt32LE(value, offset, noAssert) {
-            value = +value;
-            offset = offset >>> 0;
-            if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
-            this[offset + 3] = value >>> 24;
-            this[offset + 2] = value >>> 16;
-            this[offset + 1] = value >>> 8;
-            this[offset] = value & 255;
-            return offset + 4;
-          };
-        Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE =
-          function writeUInt32BE(value, offset, noAssert) {
-            value = +value;
-            offset = offset >>> 0;
-            if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
-            this[offset] = value >>> 24;
-            this[offset + 1] = value >>> 16;
-            this[offset + 2] = value >>> 8;
-            this[offset + 3] = value & 255;
-            return offset + 4;
-          };
-        Buffer2.prototype.writeIntLE = function writeIntLE(
-          value,
-          offset,
-          byteLength3,
-          noAssert
-        ) {
-          value = +value;
-          offset = offset >>> 0;
-          if (!noAssert) {
-            var limit = Math.pow(2, 8 * byteLength3 - 1);
-            checkInt(this, value, offset, byteLength3, limit - 1, -limit);
-          }
-          var i = 0;
-          var mul = 1;
-          var sub2 = 0;
-          this[offset] = value & 255;
-          while (++i < byteLength3 && (mul *= 256)) {
-            if (value < 0 && sub2 === 0 && this[offset + i - 1] !== 0) {
-              sub2 = 1;
-            }
-            this[offset + i] = (((value / mul) >> 0) - sub2) & 255;
-          }
-          return offset + byteLength3;
-        };
-        Buffer2.prototype.writeIntBE = function writeIntBE(
-          value,
-          offset,
-          byteLength3,
-          noAssert
-        ) {
-          value = +value;
-          offset = offset >>> 0;
-          if (!noAssert) {
-            var limit = Math.pow(2, 8 * byteLength3 - 1);
-            checkInt(this, value, offset, byteLength3, limit - 1, -limit);
-          }
-          var i = byteLength3 - 1;
-          var mul = 1;
-          var sub2 = 0;
-          this[offset + i] = value & 255;
-          while (--i >= 0 && (mul *= 256)) {
-            if (value < 0 && sub2 === 0 && this[offset + i + 1] !== 0) {
-              sub2 = 1;
-            }
-            this[offset + i] = (((value / mul) >> 0) - sub2) & 255;
-          }
-          return offset + byteLength3;
-        };
-        Buffer2.prototype.writeInt8 = function writeInt8(
-          value,
-          offset,
-          noAssert
-        ) {
-          value = +value;
-          offset = offset >>> 0;
-          if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
-          if (value < 0) value = 255 + value + 1;
-          this[offset] = value & 255;
-          return offset + 1;
-        };
-        Buffer2.prototype.writeInt16LE = function writeInt16LE(
-          value,
-          offset,
-          noAssert
-        ) {
-          value = +value;
-          offset = offset >>> 0;
-          if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
-          this[offset] = value & 255;
-          this[offset + 1] = value >>> 8;
-          return offset + 2;
-        };
-        Buffer2.prototype.writeInt16BE = function writeInt16BE(
-          value,
-          offset,
-          noAssert
-        ) {
-          value = +value;
-          offset = offset >>> 0;
-          if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
-          this[offset] = value >>> 8;
-          this[offset + 1] = value & 255;
-          return offset + 2;
-        };
-        Buffer2.prototype.writeInt32LE = function writeInt32LE(
-          value,
-          offset,
-          noAssert
-        ) {
-          value = +value;
-          offset = offset >>> 0;
-          if (!noAssert)
-            checkInt(this, value, offset, 4, 2147483647, -2147483648);
-          this[offset] = value & 255;
-          this[offset + 1] = value >>> 8;
-          this[offset + 2] = value >>> 16;
-          this[offset + 3] = value >>> 24;
-          return offset + 4;
-        };
-        Buffer2.prototype.writeInt32BE = function writeInt32BE(
-          value,
-          offset,
-          noAssert
-        ) {
-          value = +value;
-          offset = offset >>> 0;
-          if (!noAssert)
-            checkInt(this, value, offset, 4, 2147483647, -2147483648);
-          if (value < 0) value = 4294967295 + value + 1;
-          this[offset] = value >>> 24;
-          this[offset + 1] = value >>> 16;
-          this[offset + 2] = value >>> 8;
-          this[offset + 3] = value & 255;
-          return offset + 4;
-        };
-        function checkIEEE754(buf, value, offset, ext, max, min) {
-          if (offset + ext > buf.length)
-            throw new RangeError("Index out of range");
-          if (offset < 0) throw new RangeError("Index out of range");
-        }
-        function writeFloat(buf, value, offset, littleEndian, noAssert) {
-          value = +value;
-          offset = offset >>> 0;
-          if (!noAssert) {
-            checkIEEE754(buf, value, offset, 4);
-          }
-          ieee754$1.write(buf, value, offset, littleEndian, 23, 4);
-          return offset + 4;
-        }
-        Buffer2.prototype.writeFloatLE = function writeFloatLE(
-          value,
-          offset,
-          noAssert
-        ) {
-          return writeFloat(this, value, offset, true, noAssert);
-        };
-        Buffer2.prototype.writeFloatBE = function writeFloatBE(
-          value,
-          offset,
-          noAssert
-        ) {
-          return writeFloat(this, value, offset, false, noAssert);
-        };
-        function writeDouble(buf, value, offset, littleEndian, noAssert) {
-          value = +value;
-          offset = offset >>> 0;
-          if (!noAssert) {
-            checkIEEE754(buf, value, offset, 8);
-          }
-          ieee754$1.write(buf, value, offset, littleEndian, 52, 8);
-          return offset + 8;
-        }
-        Buffer2.prototype.writeDoubleLE = function writeDoubleLE(
-          value,
-          offset,
-          noAssert
-        ) {
-          return writeDouble(this, value, offset, true, noAssert);
-        };
-        Buffer2.prototype.writeDoubleBE = function writeDoubleBE(
-          value,
-          offset,
-          noAssert
-        ) {
-          return writeDouble(this, value, offset, false, noAssert);
-        };
-        Buffer2.prototype.copy = function copy2(
-          target2,
-          targetStart,
-          start2,
-          end2
-        ) {
-          if (!Buffer2.isBuffer(target2))
-            throw new TypeError("argument should be a Buffer");
-          if (!start2) start2 = 0;
-          if (!end2 && end2 !== 0) end2 = this.length;
-          if (targetStart >= target2.length) targetStart = target2.length;
-          if (!targetStart) targetStart = 0;
-          if (end2 > 0 && end2 < start2) end2 = start2;
-          if (end2 === start2) return 0;
-          if (target2.length === 0 || this.length === 0) return 0;
-          if (targetStart < 0) {
-            throw new RangeError("targetStart out of bounds");
-          }
-          if (start2 < 0 || start2 >= this.length)
-            throw new RangeError("Index out of range");
-          if (end2 < 0) throw new RangeError("sourceEnd out of bounds");
-          if (end2 > this.length) end2 = this.length;
-          if (target2.length - targetStart < end2 - start2) {
-            end2 = target2.length - targetStart + start2;
-          }
-          var len = end2 - start2;
-          if (
-            this === target2 &&
-            typeof Uint8Array.prototype.copyWithin === "function"
-          ) {
-            this.copyWithin(targetStart, start2, end2);
-          } else {
-            Uint8Array.prototype.set.call(
-              target2,
-              this.subarray(start2, end2),
-              targetStart
-            );
-          }
-          return len;
-        };
-        Buffer2.prototype.fill = function fill(val, start2, end2, encoding) {
-          if (typeof val === "string") {
-            if (typeof start2 === "string") {
-              encoding = start2;
-              start2 = 0;
-              end2 = this.length;
-            } else if (typeof end2 === "string") {
-              encoding = end2;
-              end2 = this.length;
-            }
-            if (encoding !== void 0 && typeof encoding !== "string") {
-              throw new TypeError("encoding must be a string");
-            }
-            if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
-              throw new TypeError("Unknown encoding: " + encoding);
-            }
-            if (val.length === 1) {
-              var code3 = val.charCodeAt(0);
-              if (
-                (encoding === "utf8" && code3 < 128) ||
-                encoding === "latin1"
-              ) {
-                val = code3;
-              }
-            }
-          } else if (typeof val === "number") {
-            val = val & 255;
-          } else if (typeof val === "boolean") {
-            val = Number(val);
-          }
-          if (start2 < 0 || this.length < start2 || this.length < end2) {
-            throw new RangeError("Out of range index");
-          }
-          if (end2 <= start2) {
-            return this;
-          }
-          start2 = start2 >>> 0;
-          end2 = end2 === void 0 ? this.length : end2 >>> 0;
-          if (!val) val = 0;
-          var i;
-          if (typeof val === "number") {
-            for (i = start2; i < end2; ++i) {
-              this[i] = val;
-            }
-          } else {
-            var bytes = Buffer2.isBuffer(val)
-              ? val
-              : Buffer2.from(val, encoding);
-            var len = bytes.length;
-            if (len === 0) {
-              throw new TypeError(
-                'The value "' + val + '" is invalid for argument "value"'
-              );
-            }
-            for (i = 0; i < end2 - start2; ++i) {
-              this[i + start2] = bytes[i % len];
-            }
-          }
-          return this;
-        };
-        var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
-        function base64clean(str) {
-          str = str.split("=")[0];
-          str = str.trim().replace(INVALID_BASE64_RE, "");
-          if (str.length < 2) return "";
-          while (str.length % 4 !== 0) {
-            str = str + "=";
-          }
-          return str;
-        }
-        function utf8ToBytes(string2, units) {
-          units = units || Infinity;
-          var codePoint;
-          var length = string2.length;
-          var leadSurrogate = null;
-          var bytes = [];
-          for (var i = 0; i < length; ++i) {
-            codePoint = string2.charCodeAt(i);
-            if (codePoint > 55295 && codePoint < 57344) {
-              if (!leadSurrogate) {
-                if (codePoint > 56319) {
-                  if ((units -= 3) > -1) bytes.push(239, 191, 189);
-                  continue;
-                } else if (i + 1 === length) {
-                  if ((units -= 3) > -1) bytes.push(239, 191, 189);
-                  continue;
-                }
-                leadSurrogate = codePoint;
-                continue;
-              }
-              if (codePoint < 56320) {
-                if ((units -= 3) > -1) bytes.push(239, 191, 189);
-                leadSurrogate = codePoint;
-                continue;
-              }
-              codePoint =
-                (((leadSurrogate - 55296) << 10) | (codePoint - 56320)) + 65536;
-            } else if (leadSurrogate) {
-              if ((units -= 3) > -1) bytes.push(239, 191, 189);
-            }
-            leadSurrogate = null;
-            if (codePoint < 128) {
-              if ((units -= 1) < 0) break;
-              bytes.push(codePoint);
-            } else if (codePoint < 2048) {
-              if ((units -= 2) < 0) break;
-              bytes.push((codePoint >> 6) | 192, (codePoint & 63) | 128);
-            } else if (codePoint < 65536) {
-              if ((units -= 3) < 0) break;
-              bytes.push(
-                (codePoint >> 12) | 224,
-                ((codePoint >> 6) & 63) | 128,
-                (codePoint & 63) | 128
-              );
-            } else if (codePoint < 1114112) {
-              if ((units -= 4) < 0) break;
-              bytes.push(
-                (codePoint >> 18) | 240,
-                ((codePoint >> 12) & 63) | 128,
-                ((codePoint >> 6) & 63) | 128,
-                (codePoint & 63) | 128
-              );
-            } else {
-              throw new Error("Invalid code point");
-            }
-          }
-          return bytes;
-        }
-        function asciiToBytes(str) {
-          var byteArray = [];
-          for (var i = 0; i < str.length; ++i) {
-            byteArray.push(str.charCodeAt(i) & 255);
-          }
-          return byteArray;
-        }
-        function utf16leToBytes(str, units) {
-          var c, hi2, lo;
-          var byteArray = [];
-          for (var i = 0; i < str.length; ++i) {
-            if ((units -= 2) < 0) break;
-            c = str.charCodeAt(i);
-            hi2 = c >> 8;
-            lo = c % 256;
-            byteArray.push(lo);
-            byteArray.push(hi2);
-          }
-          return byteArray;
-        }
-        function base64ToBytes(str) {
-          return base64.toByteArray(base64clean(str));
-        }
-        function blitBuffer(src, dst, offset, length) {
-          for (var i = 0; i < length; ++i) {
-            if (i + offset >= dst.length || i >= src.length) break;
-            dst[i + offset] = src[i];
-          }
-          return i;
-        }
-        function isInstance(obj, type2) {
-          return (
-            obj instanceof type2 ||
-            (obj != null &&
-              obj.constructor != null &&
-              obj.constructor.name != null &&
-              obj.constructor.name === type2.name)
-          );
-        }
-        function numberIsNaN(obj) {
-          return obj !== obj;
-        }
-        var hexSliceLookupTable = (function () {
-          var alphabet = "0123456789abcdef";
-          var table3 = new Array(256);
-          for (var i = 0; i < 16; ++i) {
-            var i16 = i * 16;
-            for (var j = 0; j < 16; ++j) {
-              table3[i16 + j] = alphabet[i] + alphabet[j];
-            }
-          }
-          return table3;
-        })();
-      })(buffer);
-      const { Buffer: Buffer$1 } = buffer;
-      function syncFetch(...args) {
-        const [url, opts] = parseArgs(...args);
-        const xhr = new XMLHttpRequest();
-        xhr.withCredentials = opts.credentials === "include";
-        xhr.timeout = opts.timeout;
-        xhr.open(opts.method || "GET", url, false);
-        try {
-          xhr.responseType = "arraybuffer";
-        } catch (e) {}
-        for (const header of opts.headers) {
-          xhr.setRequestHeader(...header);
-        }
-        xhr.send(opts.body || null);
-        let headers = xhr.getAllResponseHeaders();
-        headers =
-          headers &&
-          headers
-            .split("\r\n")
-            .filter(Boolean)
-            .map((header) => header.split(": ", 2));
-        return new syncFetch.Response(xhr.response, {
-          url: xhr.responseURL,
-          status: xhr.status,
-          statusText: xhr.statusText,
-          headers,
-          redirected: xhr.responseURL !== url,
-        });
-      }
-      function parseArgs(resource, init) {
-        const request = [];
-        if (resource instanceof syncFetch.Request) {
-          request.push(resource.url);
-          request.push({
-            method: resource.method,
-            headers: resource.headers,
-            body: resource.body,
-          });
-        } else {
-          request.push(resource, {});
-        }
-        Object.assign(request[1], init);
-        request[1].headers = new syncFetch.Headers(request[1].headers || {});
-        return request;
-      }
-      const INTERNALS = Symbol("SyncFetch Internals");
-      class SyncRequest extends Request {
-        constructor(resource, init = {}, body = init.body) {
-          super(resource, init);
-          this[INTERNALS] = {
-            body: body ? Buffer$1.from(body) : null,
-          };
-        }
-        clone() {
-          checkBody(this);
-          return new SyncRequest(this.url, this);
-        }
-      }
-      class SyncResponse extends Response {
-        constructor(body, init = {}) {
-          body = body ? Buffer$1.from(body) : null;
-          super(createStream(body), init);
-          this[INTERNALS] = {
-            url: init.url,
-            redirected: init.redirected,
-            body,
-          };
-        }
-        get url() {
-          return this[INTERNALS].url;
-        }
-        get redirected() {
-          return this[INTERNALS].redirected;
-        }
-        clone() {
-          checkBody(this);
-          return new SyncResponse(this[INTERNALS].body, {
-            url: this.url,
-            headers: this.headers,
-            status: this.status,
-            statusText: this.statusText,
-            redirected: this.redirected,
-          });
-        }
-      }
-      class Body {
-        constructor(body) {
-          this[INTERNALS] = {
-            body: Buffer$1.from(body),
-          };
-        }
-        static mixin(prototype) {
-          for (const name2 of Object.getOwnPropertyNames(Body.prototype)) {
-            if (name2 === "constructor") {
-              continue;
-            }
-            const desc = Object.getOwnPropertyDescriptor(Body.prototype, name2);
-            Object.defineProperty(
-              prototype,
-              name2,
-              __spreadProps(__spreadValues({}, desc), { enumerable: true })
-            );
-          }
-        }
-        arrayBuffer() {
-          checkBody(this);
-          const buffer2 = consumeBody(this);
-          return buffer2.buffer.slice(
-            buffer2.byteOffset,
-            buffer2.byteOffset + buffer2.byteLength
-          );
-        }
-        blob() {
-          checkBody(this);
-          const type2 = this.headers && this.headers.get("content-type");
-          return new Blob([consumeBody(this)], type2 && { type: type2 });
-        }
-        text() {
-          checkBody(this);
-          return consumeBody(this).toString();
-        }
-        json() {
-          checkBody(this);
-          try {
-            return JSON.parse(consumeBody(this).toString());
-          } catch (err) {
-            throw new TypeError(
-              `invalid json response body at ${this.url} reason: ${err.message}`,
-              "invalid-json"
-            );
-          }
-        }
-        buffer() {
-          checkBody(this);
-          return consumeBody(this).clone();
-        }
-      }
-      function checkBody(body) {
-        if (body.bodyUsed) {
-          throw new TypeError(`body used already for: ${body.url}`);
-        }
-      }
-      function consumeBody(body) {
-        _super(body, "arrayBuffer")();
-        return body[INTERNALS].body || Buffer$1.alloc(0);
-      }
-      function _super(self2, method) {
-        return Object.getPrototypeOf(Object.getPrototypeOf(self2))[method].bind(
-          self2
-        );
-      }
-      function createStream(body) {
-        return new ReadableStream({
-          start(controller) {
-            controller.enqueue(body);
-            controller.close();
-          },
-        });
-      }
-      Body.mixin(SyncRequest.prototype);
-      Body.mixin(SyncResponse.prototype);
-      syncFetch.Headers = self.Headers;
-      syncFetch.Request = SyncRequest;
-      syncFetch.Response = SyncResponse;
-      var browser = syncFetch;
-      const separator$1 = "\r\n\r\n";
-      async function* generate$1(stream, boundary, options) {
-        const len_boundary = Buffer.byteLength(boundary),
-          is_eager = !options || !options.multiple;
-        let buffer2 = Buffer.alloc(0),
-          is_preamble = true,
-          payloads = [];
-        outer: for await (const chunk of stream) {
-          let idx_boundary = buffer2.byteLength;
-          buffer2 = Buffer.concat([buffer2, chunk]);
-          const idx_chunk = chunk.indexOf(boundary);
-          if (!!~idx_chunk) {
-            idx_boundary += idx_chunk;
-          } else {
-            idx_boundary = buffer2.indexOf(boundary);
-          }
-          payloads = [];
-          while (!!~idx_boundary) {
-            const current = buffer2.slice(0, idx_boundary);
-            const next = buffer2.slice(idx_boundary + len_boundary);
-            if (is_preamble) {
-              is_preamble = false;
-            } else {
-              const headers = {};
-              const idx_headers = current.indexOf(separator$1);
-              const arr_headers = buffer2
-                .slice(0, idx_headers)
-                .toString()
-                .trim()
-                .split(/\r\n/);
-              let tmp;
-              while ((tmp = arr_headers.shift())) {
-                tmp = tmp.split(": ");
-                headers[tmp.shift().toLowerCase()] = tmp.join(": ");
-              }
-              let body = current.slice(
-                idx_headers + separator$1.length,
-                current.lastIndexOf("\r\n")
-              );
-              let is_json = false;
-              tmp = headers["content-type"];
-              if (tmp && !!~tmp.indexOf("application/json")) {
-                try {
-                  body = JSON.parse(body.toString());
-                  is_json = true;
-                } catch (_) {}
-              }
-              tmp = { headers, body, json: is_json };
-              is_eager ? yield tmp : payloads.push(tmp);
-              if (next.slice(0, 2).toString() === "--") break outer;
-            }
-            buffer2 = next;
-            idx_boundary = buffer2.indexOf(boundary);
-          }
-          if (payloads.length) yield payloads;
-        }
-        if (payloads.length) yield payloads;
-      }
-      async function meros$1(response, options) {
-        const ctype = response.headers["content-type"];
-        if (!ctype || !~ctype.indexOf("multipart/mixed")) return response;
-        const idx_boundary = ctype.indexOf("boundary=");
-        return generate$1(
-          response,
-          `--${
-            !!~idx_boundary
-              ? ctype
-                  .substring(idx_boundary + 9)
-                  .trim()
-                  .replace(/['"]/g, "")
-              : "-"
-          }`,
-          options
-        );
-      }
-      const separator = "\r\n\r\n";
-      const decoder = new TextDecoder();
-      async function* generate(stream, boundary, options) {
-        const reader = stream.getReader(),
-          is_eager = !options || !options.multiple;
-        let buffer2 = "",
-          is_preamble = true,
-          payloads = [];
-        try {
-          let result2;
-          outer: while (!(result2 = await reader.read()).done) {
-            const chunk = decoder.decode(result2.value);
-            const idx_chunk = chunk.indexOf(boundary);
-            let idx_boundary = buffer2.length;
-            buffer2 += chunk;
-            if (!!~idx_chunk) {
-              idx_boundary += idx_chunk;
-            } else {
-              idx_boundary = buffer2.indexOf(boundary);
-            }
-            payloads = [];
-            while (!!~idx_boundary) {
-              const current = buffer2.substring(0, idx_boundary);
-              const next = buffer2.substring(idx_boundary + boundary.length);
-              if (is_preamble) {
-                is_preamble = false;
-              } else {
-                const headers = {};
-                const idx_headers = current.indexOf(separator);
-                const arr_headers = buffer2
-                  .slice(0, idx_headers)
-                  .toString()
-                  .trim()
-                  .split(/\r\n/);
-                let tmp;
-                while ((tmp = arr_headers.shift())) {
-                  tmp = tmp.split(": ");
-                  headers[tmp.shift().toLowerCase()] = tmp.join(": ");
-                }
-                let body = current.substring(
-                  idx_headers + separator.length,
-                  current.lastIndexOf("\r\n")
-                );
-                let is_json = false;
-                tmp = headers["content-type"];
-                if (tmp && !!~tmp.indexOf("application/json")) {
-                  try {
-                    body = JSON.parse(body);
-                    is_json = true;
-                  } catch (_) {}
-                }
-                tmp = { headers, body, json: is_json };
-                is_eager ? yield tmp : payloads.push(tmp);
-                if (next.substring(0, 2) === "--") break outer;
-              }
-              buffer2 = next;
-              idx_boundary = buffer2.indexOf(boundary);
-            }
-            if (payloads.length) yield payloads;
-          }
-        } finally {
-          if (payloads.length) yield payloads;
-          reader.releaseLock();
-        }
-      }
-      async function meros(response, options) {
-        if (!response.ok || !response.body || response.bodyUsed)
-          return response;
-        const ctype = response.headers.get("content-type");
-        if (!ctype || !~ctype.indexOf("multipart/mixed")) return response;
-        const idx_boundary = ctype.indexOf("boundary=");
-        return generate(
-          response.body,
-          `--${
-            !!~idx_boundary
-              ? ctype
-                  .substring(idx_boundary + 9)
-                  .trim()
-                  .replace(/['"]/g, "")
-              : "-"
-          }`,
-          options
-        );
-      }
-      function merge(a, b, k) {
-        if (typeof a === "object" && typeof b === "object") {
-          if (Array.isArray(a) && Array.isArray(b)) {
-            for (k = 0; k < b.length; k++) {
-              a[k] = merge(a[k], b[k]);
-            }
-          } else {
-            for (k in b) {
-              a[k] = merge(a[k], b[k]);
-            }
-          }
-          return a;
-        }
-        return b;
-      }
-      function dset(obj, keys, val) {
-        keys.split && (keys = keys.split("."));
-        var i = 0,
-          l2 = keys.length,
-          t2 = obj,
-          x2,
-          k;
-        while (i < l2) {
-          k = keys[i++];
-          if (k === "__proto__" || k === "constructor" || k === "prototype")
-            break;
-          t2 = t2[k] =
-            i === l2
-              ? merge(t2[k], val)
-              : typeof (x2 = t2[k]) === typeof keys
-              ? x2
-              : keys[i] * 0 !== 0 || !!~("" + keys[i]).indexOf(".")
-              ? {}
-              : [];
-        }
-      }
-      const defaultAsyncFetch = async (input, init) => {
-        return fetch$1(input, init);
-      };
-      const defaultSyncFetch = (input, init) => {
-        if (typeof input === "string") {
-          init === null || init === void 0 ? true : delete init.signal;
-        } else {
-          delete input.signal;
-        }
-        return browser(input, init);
-      };
-      function isIncomingMessage(body) {
-        return body != null && typeof body === "object" && "pipe" in body;
-      }
-      async function handleMultipartMixedResponse(response) {
-        const body = await response.body;
-        const contentType = response.headers.get("content-type") || "";
-        let asyncIterator;
-        if (isIncomingMessage(body)) {
-          body.headers = {
-            "content-type": contentType,
-          };
-          asyncIterator = await meros$1(body);
-        } else {
-          asyncIterator = await meros(response);
-        }
-        const executionResult = {};
-        return mapAsyncIterator(asyncIterator, (part2) => {
-          if (part2.json) {
-            const chunk = part2.body;
-            if (chunk.path) {
-              if (chunk.data) {
-                const path = ["data"];
-                dset(executionResult, path.concat(chunk.path), chunk.data);
-              }
-              if (chunk.errors) {
-                executionResult.errors = (executionResult.errors || []).concat(
-                  chunk.errors
-                );
-              }
-            } else {
-              if (chunk.data) {
-                executionResult.data = chunk.data;
-              }
-              if (chunk.errors) {
-                executionResult.errors = chunk.errors;
-              }
-            }
-            return executionResult;
-          }
-        });
-      }
-      async function* handleReadable(readable) {
-        const decoder2 = new TextDecoder();
-        outer: for await (const chunk of readable) {
-          const chunkStr =
-            typeof chunk === "string" ? chunk : decoder2.decode(chunk);
-          for (const part2 of chunkStr.split("\n\n")) {
-            if (part2) {
-              const eventStr = part2.split("event: ")[1];
-              const dataStr = part2.split("data: ")[1];
-              if (eventStr === "complete") {
-                break outer;
-              }
-              if (dataStr) {
-                const data = JSON.parse(dataStr);
-                yield data.payload || data;
-              }
-            }
-          }
-        }
-      }
-      async function* handleReadableStream(stream) {
-        const decoder2 = new TextDecoder();
-        const reader = stream.getReader();
-        let buffer2;
-        let position = 0;
-        let fieldLength = -1;
-        let discardTrailingNewline = false;
-        try {
-          let result2;
-          let message = {
-            data: "",
-            event: "",
-            id: "",
-            retry: void 0,
-          };
-          while (!(result2 = await reader.read()).done) {
-            const arr = result2.value;
-            if (buffer2 === void 0) {
-              buffer2 = arr;
-              position = 0;
-              fieldLength = -1;
-            } else {
-              buffer2 = concat(buffer2, arr);
-            }
-            const bufLength = buffer2.length;
-            let lineStart = 0;
-            while (position < bufLength) {
-              if (discardTrailingNewline) {
-                if (buffer2[position] === 10) {
-                  lineStart = ++position;
-                }
-                discardTrailingNewline = false;
-              }
-              let lineEnd = -1;
-              for (; position < bufLength && lineEnd === -1; ++position) {
-                switch (buffer2[position]) {
-                  case 58: {
-                    if (fieldLength === -1) {
-                      fieldLength = position - lineStart;
-                    }
-                    break;
-                  }
-                  case 13: {
-                    discardTrailingNewline = true;
-                    break;
-                  }
-                  case 10: {
-                    lineEnd = position;
-                    break;
-                  }
-                }
-              }
-              if (lineEnd === -1) {
-                break;
-              }
-              const line = buffer2.subarray(lineStart, lineEnd);
-              if (line.length === 0) {
-                if (message.event || message.data) {
-                  yield JSON.parse(message.data);
-                  message = {
-                    data: "",
-                    event: "",
-                    id: "",
-                    retry: void 0,
-                  };
-                }
-              } else if (fieldLength > 0) {
-                const field = decoder2.decode(line.subarray(0, fieldLength));
-                const valueOffset =
-                  fieldLength + (line[fieldLength + 1] === 32 ? 2 : 1);
-                const value = decoder2.decode(line.subarray(valueOffset));
-                switch (field) {
-                  case "data":
-                    message.data = message.data
-                      ? message.data + "\n" + value
-                      : value;
-                    break;
-                  case "event":
-                    message.event = value;
-                    break;
-                  case "id":
-                    message.id = value;
-                    break;
-                  case "retry": {
-                    const retry = parseInt(value, 10);
-                    message.retry = retry;
-                    break;
-                  }
-                }
-              }
-              lineStart = position;
-              fieldLength = -1;
-            }
-            if (lineStart === bufLength) {
-              buffer2 = void 0;
-            } else if (lineStart !== 0) {
-              buffer2 = buffer2.subarray(lineStart);
-              position -= lineStart;
-            }
-          }
-        } finally {
-          reader.releaseLock();
-        }
-      }
-      function concat(a, b) {
-        const res = new Uint8Array(a.length + b.length);
-        res.set(a);
-        res.set(b, a.length);
-        return res;
-      }
-      async function handleEventStreamResponse(response) {
-        const body = await response.body;
-        if (body) {
-          if (isAsyncIterable$1(body)) {
-            return handleReadable(body);
-          }
-          return handleReadableStream(body);
-        }
-        throw new Error(
-          "Response body is expected to be a readable stream but got; " +
-            inspect$1(body)
-        );
-      }
-      function addCancelToResponseStream(resultStream, controller) {
-        return getAsyncIterableWithCancel(resultStream, () => {
-          if (!controller.signal.aborted) {
-            controller.abort();
-          }
-        });
-      }
-      function isBlob(obj) {
-        return typeof obj.arrayBuffer === "function";
-      }
-      function isGraphQLUpload(upload) {
-        return typeof upload.createReadStream === "function";
-      }
-      function isPromiseLike(obj) {
-        return typeof obj.then === "function";
-      }
-      const asyncImport = (moduleName) => import(moduleName);
-      const syncImport = (moduleName) => require(moduleName);
-      var SubscriptionProtocol;
-      (function (SubscriptionProtocol2) {
-        SubscriptionProtocol2["WS"] = "WS";
-        SubscriptionProtocol2["LEGACY_WS"] = "LEGACY_WS";
-        SubscriptionProtocol2["SSE"] = "SSE";
-        SubscriptionProtocol2["GRAPHQL_SSE"] = "GRAPHQL_SSE";
-      })(SubscriptionProtocol || (SubscriptionProtocol = {}));
-      function isCompatibleUri(uri) {
-        try {
-          new URL(uri);
-          return true;
-        } catch (_a2) {
-          return false;
-        }
-      }
-      class UrlLoader {
-        createFormDataFromVariables({
-          query,
-          variables,
-          operationName,
-          extensions,
-        }) {
-          const vars = Object.assign({}, variables);
-          const { clone, files } = extractFiles$1(
-            vars,
-            "variables",
-            (v2) =>
-              isExtractableFile$1(v2) ||
-              (v2 === null || v2 === void 0 ? void 0 : v2.promise) ||
-              isAsyncIterable$1(v2) ||
-              (v2 === null || v2 === void 0 ? void 0 : v2.then) ||
-              typeof (v2 === null || v2 === void 0
-                ? void 0
-                : v2.arrayBuffer) === "function"
-          );
-          const map2 = {};
-          const uploads = [];
-          let currIndex = 0;
-          for (const [file, curr] of files) {
-            map2[currIndex] = curr;
-            uploads[currIndex] = file;
-            currIndex++;
-          }
-          const form = new FormData();
-          form.append(
-            "operations",
-            JSON.stringify({
-              query,
-              variables: clone,
-              operationName,
-              extensions,
-            })
-          );
-          form.append("map", JSON.stringify(map2));
-          function handleUpload(upload, i) {
-            const indexStr = i.toString();
-            if (upload != null) {
-              const filename =
-                upload.filename ||
-                upload.name ||
-                upload.path ||
-                `blob-${indexStr}`;
-              if (isPromiseLike(upload)) {
-                return upload.then((resolvedUpload) =>
-                  handleUpload(resolvedUpload, i)
-                );
-              } else if (isBlob(upload)) {
-                return upload.arrayBuffer().then((arrayBuffer) => {
-                  form.append(
-                    indexStr,
-                    new File$1([arrayBuffer], filename, { type: upload.type }),
-                    filename
-                  );
-                });
-              } else if (isGraphQLUpload(upload)) {
-                const stream = upload.createReadStream();
-                const chunks = [];
-                return Promise.resolve().then(async () => {
-                  for await (const chunk of stream) {
-                    if (chunk) {
-                      chunks.push(...chunk);
-                    }
-                  }
-                  const blobPart = new Uint8Array(chunks);
-                  form.append(
-                    indexStr,
-                    new File$1([blobPart], filename, { type: upload.mimetype }),
-                    filename
-                  );
-                });
-              } else {
-                form.append(indexStr, new File$1([upload], filename), filename);
-              }
-            }
-          }
-          return ValueOrPromise.all(
-            uploads.map(
-              (upload, i) => new ValueOrPromise(() => handleUpload(upload, i))
-            )
-          )
-            .then(() => form)
-            .resolve();
-        }
-        prepareGETUrl({
-          baseUrl,
-          query,
-          variables,
-          operationName,
-          extensions,
-        }) {
-          const HTTP_URL = switchProtocols(baseUrl, {
-            wss: "https",
-            ws: "http",
-          });
-          const dummyHostname = "https://dummyhostname.com";
-          const validUrl = HTTP_URL.startsWith("http")
-            ? HTTP_URL
-            : HTTP_URL.startsWith("/")
-            ? `${dummyHostname}${HTTP_URL}`
-            : `${dummyHostname}/${HTTP_URL}`;
-          const urlObj = new URL(validUrl);
-          urlObj.searchParams.set("query", query);
-          if (variables && Object.keys(variables).length > 0) {
-            urlObj.searchParams.set("variables", JSON.stringify(variables));
-          }
-          if (operationName) {
-            urlObj.searchParams.set("operationName", operationName);
-          }
-          if (extensions) {
-            urlObj.searchParams.set("extensions", JSON.stringify(extensions));
-          }
-          const finalUrl = urlObj.toString().replace(dummyHostname, "");
-          return finalUrl;
-        }
-        buildHTTPExecutor(initialEndpoint, fetch2, options) {
-          const defaultMethod = this.getDefaultMethodFromOptions(
-            options === null || options === void 0 ? void 0 : options.method,
-            "POST"
-          );
-          const HTTP_URL = switchProtocols(initialEndpoint, {
-            wss: "https",
-            ws: "http",
-          });
-          const executor = (request) => {
-            var _a2, _b;
-            const controller = new AbortController$1();
-            let method = defaultMethod;
-            if (
-              options === null || options === void 0
-                ? void 0
-                : options.useGETForQueries
-            ) {
-              const operationAst = getOperationASTFromRequest(request);
-              const operationType = operationAst.operation;
-              if (operationType === "query") {
-                method = "GET";
-              }
-            }
-            const endpoint =
-              ((_a2 = request.extensions) === null || _a2 === void 0
-                ? void 0
-                : _a2.endpoint) || HTTP_URL;
-            const headers = Object.assign(
-              {},
-              options === null || options === void 0 ? void 0 : options.headers,
-              ((_b = request.extensions) === null || _b === void 0
-                ? void 0
-                : _b.headers) || {}
-            );
-            const acceptedProtocols = [`application/json`];
-            if (
-              method === "GET" &&
-              (options === null || options === void 0
-                ? void 0
-                : options.subscriptionsProtocol) === SubscriptionProtocol.SSE
-            ) {
-              acceptedProtocols.push("text/event-stream");
-            } else {
-              acceptedProtocols.push("multipart/mixed");
-            }
-            const accept = acceptedProtocols.join(", ");
-            const query = print(request.document);
-            const requestBody = {
-              query,
-              variables: request.variables,
-              operationName: request.operationName,
-              extensions: request.extensions,
-            };
-            let timeoutId;
-            if (
-              options === null || options === void 0 ? void 0 : options.timeout
-            ) {
-              timeoutId = setTimeout(() => {
-                if (!controller.signal.aborted) {
-                  controller.abort();
-                }
-              }, options.timeout);
-            }
-            const credentials =
-              (options === null || options === void 0
-                ? void 0
-                : options.credentials) || "same-origin";
-            return new ValueOrPromise(() => {
-              switch (method) {
-                case "GET":
-                  const finalUrl = this.prepareGETUrl(
-                    __spreadValues(
-                      {
-                        baseUrl: endpoint,
-                      },
-                      requestBody
-                    )
-                  );
-                  return fetch2(finalUrl, {
-                    method: "GET",
-                    credentials,
-                    headers: __spreadValues(
-                      {
-                        accept,
-                      },
-                      headers
-                    ),
-                    signal: controller.signal,
-                  });
-                case "POST":
-                  if (
-                    options === null || options === void 0
-                      ? void 0
-                      : options.multipart
-                  ) {
-                    return new ValueOrPromise(() =>
-                      this.createFormDataFromVariables(requestBody)
-                    )
-                      .then((form) =>
-                        fetch2(endpoint, {
-                          method: "POST",
-                          credentials,
-                          body: form,
-                          headers: __spreadValues(
-                            {
-                              accept,
-                            },
-                            headers
-                          ),
-                          signal: controller.signal,
-                        })
-                      )
-                      .resolve();
-                  } else {
-                    return fetch2(endpoint, {
-                      method: "POST",
-                      credentials,
-                      body: JSON.stringify(requestBody),
-                      headers: __spreadValues(
-                        {
-                          accept,
-                          "content-type": "application/json",
-                        },
-                        headers
-                      ),
-                      signal: controller.signal,
-                    });
-                  }
-              }
-            })
-              .then((fetchResult) => {
-                if (timeoutId != null) {
-                  clearTimeout(timeoutId);
-                }
-                if (
-                  (options === null || options === void 0
-                    ? void 0
-                    : options.retry) != null &&
-                  !fetchResult.status.toString().startsWith("2")
-                ) {
-                  throw new Error(
-                    fetchResult.statusText ||
-                      `HTTP Error: ${fetchResult.status}`
-                  );
-                }
-                const contentType = fetchResult.headers.get("content-type");
-                if (
-                  contentType === null || contentType === void 0
-                    ? void 0
-                    : contentType.includes("text/event-stream")
-                ) {
-                  return handleEventStreamResponse(fetchResult).then(
-                    (resultStream) =>
-                      addCancelToResponseStream(resultStream, controller)
-                  );
-                } else if (
-                  contentType === null || contentType === void 0
-                    ? void 0
-                    : contentType.includes("multipart/mixed")
-                ) {
-                  return handleMultipartMixedResponse(fetchResult).then(
-                    (resultStream) =>
-                      addCancelToResponseStream(resultStream, controller)
-                  );
-                }
-                return fetchResult.text();
-              })
-              .then((result2) => {
-                if (typeof result2 === "string") {
-                  return JSON.parse(result2);
-                } else {
-                  return result2;
-                }
-              })
-              .resolve();
-          };
-          if (
-            (options === null || options === void 0 ? void 0 : options.retry) !=
-            null
-          ) {
-            return function retryExecutor(request) {
-              let result2;
-              let error2;
-              let attempt = 0;
-              function retryAttempt() {
-                attempt++;
-                if (attempt > options.retry) {
-                  if (result2 != null) {
-                    return result2;
-                  }
-                  if (error2 != null) {
-                    throw error2;
-                  }
-                  throw new Error("No result");
-                }
-                return new ValueOrPromise(() => executor(request))
-                  .then((res) => {
-                    var _a2;
-                    result2 = res;
-                    if (
-                      (_a2 =
-                        result2 === null || result2 === void 0
-                          ? void 0
-                          : result2.errors) === null || _a2 === void 0
-                        ? void 0
-                        : _a2.length
-                    ) {
-                      return retryAttempt();
-                    }
-                    return result2;
-                  })
-                  .catch((e) => {
-                    error2 = e;
-                    return retryAttempt();
-                  })
-                  .resolve();
-              }
-              return retryAttempt();
-            };
-          }
-          return executor;
-        }
-        buildWSExecutor(
-          subscriptionsEndpoint,
-          webSocketImpl,
-          connectionParams
-        ) {
-          const WS_URL = switchProtocols(subscriptionsEndpoint, {
-            https: "wss",
-            http: "ws",
-          });
-          const subscriptionClient = createClient$1({
-            url: WS_URL,
-            webSocketImpl,
-            connectionParams,
-            lazy: true,
-          });
-          return ({
-            document: document2,
-            variables,
-            operationName,
-            extensions,
-          }) => {
-            const query = print(document2);
-            return observableToAsyncIterable({
-              subscribe: (observer) => {
-                const unsubscribe = subscriptionClient.subscribe(
-                  {
-                    query,
-                    variables,
-                    operationName,
-                    extensions,
-                  },
-                  observer
-                );
-                return {
-                  unsubscribe,
-                };
-              },
-            });
-          };
-        }
-        buildWSLegacyExecutor(
-          subscriptionsEndpoint,
-          webSocketImpl,
-          connectionParams
-        ) {
-          const WS_URL = switchProtocols(subscriptionsEndpoint, {
-            https: "wss",
-            http: "ws",
-          });
-          const subscriptionClient = new SubscriptionClient_1(
-            WS_URL,
-            {
-              connectionParams,
-              lazy: true,
-            },
-            webSocketImpl
-          );
-          return ({ document: document2, variables, operationName }) => {
-            return observableToAsyncIterable(
-              subscriptionClient.request({
-                query: document2,
-                variables,
-                operationName,
-              })
-            );
-          };
-        }
-        buildGraphQLSSEExecutor(endpoint, fetch2, options = {}) {
-          const { headers } = options;
-          const client2 = createClient(
-            __spreadProps(__spreadValues({}, options.graphqlSseOptions), {
-              url: endpoint,
-              fetchFn: fetch2,
-              abortControllerImpl: AbortController$1,
-              headers,
-            })
-          );
-          return async ({
-            document: document2,
-            variables,
-            operationName,
-            extensions,
-          }) => {
-            return observableToAsyncIterable({
-              subscribe: (observer) => {
-                const unsubscribe = client2.subscribe(
-                  {
-                    query: document2,
-                    variables,
-                    operationName,
-                    extensions,
-                  },
-                  observer
-                );
-                return {
-                  unsubscribe,
-                };
-              },
-            });
-          };
-        }
-        getFetch(customFetch, importFn) {
-          if (customFetch) {
-            if (typeof customFetch === "string") {
-              const [moduleName, fetchFnName] = customFetch.split("#");
-              return new ValueOrPromise(() => importFn(moduleName))
-                .then((module2) =>
-                  fetchFnName ? module2[fetchFnName] : module2
-                )
-                .resolve();
-            } else if (typeof customFetch === "function") {
-              return customFetch;
-            }
-          }
-          if (importFn === asyncImport) {
-            return defaultAsyncFetch;
-          } else {
-            return defaultSyncFetch;
-          }
-        }
-        getDefaultMethodFromOptions(method, defaultMethod) {
-          if (method) {
-            defaultMethod = method;
-          }
-          return defaultMethod;
-        }
-        getWebSocketImpl(importFn, options) {
-          if (
-            typeof (options === null || options === void 0
-              ? void 0
-              : options.webSocketImpl) === "string"
-          ) {
-            const [moduleName, webSocketImplName] =
-              options.webSocketImpl.split("#");
-            return new ValueOrPromise(() => importFn(moduleName))
-              .then((importedModule) =>
-                webSocketImplName
-                  ? importedModule[webSocketImplName]
-                  : importedModule
-              )
-              .resolve();
-          } else {
-            const websocketImpl =
-              (options === null || options === void 0
-                ? void 0
-                : options.webSocketImpl) || browser$1;
-            return websocketImpl;
-          }
-        }
-        buildSubscriptionExecutor(
-          subscriptionsEndpoint,
-          fetch2,
-          importFn,
-          options
-        ) {
-          if (
-            (options === null || options === void 0
-              ? void 0
-              : options.subscriptionsProtocol) === SubscriptionProtocol.SSE
-          ) {
-            return this.buildHTTPExecutor(
-              subscriptionsEndpoint,
-              fetch2,
-              __spreadProps(__spreadValues({}, options), {
-                method: "GET",
-              })
-            );
-          } else if (
-            (options === null || options === void 0
-              ? void 0
-              : options.subscriptionsProtocol) ===
-            SubscriptionProtocol.GRAPHQL_SSE
-          ) {
-            if (
-              !(options === null || options === void 0
-                ? void 0
-                : options.subscriptionsEndpoint)
-            ) {
-              subscriptionsEndpoint += "/stream";
-            }
-            return this.buildGraphQLSSEExecutor(
-              subscriptionsEndpoint,
-              fetch2,
-              options
-            );
-          } else {
-            const webSocketImpl$ = new ValueOrPromise(() =>
-              this.getWebSocketImpl(importFn, options)
-            );
-            const connectionParams = () => ({
-              headers:
-                options === null || options === void 0
-                  ? void 0
-                  : options.headers,
-            });
-            const executor$ = webSocketImpl$.then((webSocketImpl) => {
-              if (
-                (options === null || options === void 0
-                  ? void 0
-                  : options.subscriptionsProtocol) ===
-                SubscriptionProtocol.LEGACY_WS
-              ) {
-                return this.buildWSLegacyExecutor(
-                  subscriptionsEndpoint,
-                  webSocketImpl,
-                  connectionParams
-                );
-              } else {
-                return this.buildWSExecutor(
-                  subscriptionsEndpoint,
-                  webSocketImpl,
-                  connectionParams
-                );
-              }
-            });
-            return (request) =>
-              executor$.then((executor) => executor(request)).resolve();
-          }
-        }
-        getExecutor(endpoint, importFn, options) {
-          const fetch$ = new ValueOrPromise(() =>
-            this.getFetch(
-              options === null || options === void 0
-                ? void 0
-                : options.customFetch,
-              importFn
-            )
-          );
-          const httpExecutor$ = fetch$.then((fetch2) => {
-            return this.buildHTTPExecutor(endpoint, fetch2, options);
-          });
-          const subscriptionExecutor$ = fetch$.then((fetch2) => {
-            const subscriptionsEndpoint =
-              (options === null || options === void 0
-                ? void 0
-                : options.subscriptionsEndpoint) || endpoint;
-            return this.buildSubscriptionExecutor(
-              subscriptionsEndpoint,
-              fetch2,
-              importFn,
-              options
-            );
-          });
-          function getExecutorByRequest(request) {
-            const operationAst = getOperationASTFromRequest(request);
-            if (
-              operationAst.operation === "subscription" ||
-              isLiveQueryOperationDefinitionNode(
-                operationAst,
-                request.variables
-              )
-            ) {
-              return subscriptionExecutor$;
-            } else {
-              return httpExecutor$;
-            }
-          }
-          return (request) =>
-            getExecutorByRequest(request)
-              .then((executor) => executor(request))
-              .resolve();
-        }
-        getExecutorAsync(endpoint, options) {
-          return this.getExecutor(endpoint, asyncImport, options);
-        }
-        getExecutorSync(endpoint, options) {
-          return this.getExecutor(endpoint, syncImport, options);
-        }
-        handleSDL(pointer, fetch2, options) {
-          const defaultMethod = this.getDefaultMethodFromOptions(
-            options === null || options === void 0 ? void 0 : options.method,
-            "GET"
-          );
-          return new ValueOrPromise(() =>
-            fetch2(pointer, {
-              method: defaultMethod,
-              headers: options.headers,
-            })
-          )
-            .then((response) => response.text())
-            .then((schemaString) =>
-              parseGraphQLSDL(pointer, schemaString, options)
-            )
-            .resolve();
-        }
-        async load(pointer, options) {
-          if (!isCompatibleUri(pointer)) {
-            return [];
-          }
-          let source = {
-            location: pointer,
-          };
-          let executor;
-          if (
-            (options === null || options === void 0
-              ? void 0
-              : options.handleAsSDL) ||
-            pointer.endsWith(".graphql") ||
-            pointer.endsWith(".graphqls")
-          ) {
-            const fetch2 = await this.getFetch(
-              options === null || options === void 0
-                ? void 0
-                : options.customFetch,
-              asyncImport
-            );
-            source = await this.handleSDL(pointer, fetch2, options);
-            if (!source.schema && !source.document && !source.rawSDL) {
-              throw new Error(`Invalid SDL response`);
-            }
-            source.schema =
-              source.schema ||
-              (source.document
-                ? buildASTSchema(source.document, options)
-                : source.rawSDL
-                ? buildSchema(source.rawSDL, options)
-                : void 0);
-          } else {
-            executor = this.getExecutorAsync(pointer, options);
-            source.schema = await introspectSchema(executor, {}, options);
-          }
-          if (!source.schema) {
-            throw new Error(`Invalid introspected schema`);
-          }
-          if (
-            options === null || options === void 0 ? void 0 : options.endpoint
-          ) {
-            executor = this.getExecutorAsync(options.endpoint, options);
-          }
-          if (executor) {
-            source.schema = wrapSchema({
-              schema: source.schema,
-              executor,
-            });
-          }
-          return [source];
-        }
-        loadSync(pointer, options) {
-          if (!isCompatibleUri(pointer)) {
-            return [];
-          }
-          let source = {
-            location: pointer,
-          };
-          let executor;
-          if (
-            (options === null || options === void 0
-              ? void 0
-              : options.handleAsSDL) ||
-            pointer.endsWith(".graphql") ||
-            pointer.endsWith(".graphqls")
-          ) {
-            const fetch2 = this.getFetch(
-              options === null || options === void 0
-                ? void 0
-                : options.customFetch,
-              syncImport
-            );
-            source = this.handleSDL(pointer, fetch2, options);
-            if (!source.schema && !source.document && !source.rawSDL) {
-              throw new Error(`Invalid SDL response`);
-            }
-            source.schema =
-              source.schema ||
-              (source.document
-                ? buildASTSchema(source.document, options)
-                : source.rawSDL
-                ? buildSchema(source.rawSDL, options)
-                : void 0);
-          } else {
-            executor = this.getExecutorSync(pointer, options);
-            source.schema = introspectSchema(executor, {}, options);
-          }
-          if (!source.schema) {
-            throw new Error(`Invalid introspected schema`);
-          }
-          if (
-            options === null || options === void 0 ? void 0 : options.endpoint
-          ) {
-            executor = this.getExecutorSync(options.endpoint, options);
-          }
-          if (executor) {
-            source.schema = wrapSchema({
-              schema: source.schema,
-              executor,
-            });
-          }
-          return [source];
-        }
-      }
-      function switchProtocols(pointer, protocolMap) {
-        return Object.entries(protocolMap).reduce(
-          (prev, [source, target2]) =>
-            prev
-              .replace(`${source}://`, `${target2}://`)
-              .replace(`${source}:\\`, `${target2}:\\`),
-          pointer
-        );
-      }
-      var dist = {};
-      var Explorer$1 = {};
-      var require$$1$2 = /* @__PURE__ */ getAugmentedNamespace(graphql);
-      Object.defineProperty(Explorer$1, "__esModule", {
-        value: true,
-      });
-      var _typeof =
-        typeof Symbol === "function" && typeof Symbol.iterator === "symbol"
-          ? function (obj) {
-              return typeof obj;
-            }
-          : function (obj) {
-              return obj &&
-                typeof Symbol === "function" &&
-                obj.constructor === Symbol &&
-                obj !== Symbol.prototype
-                ? "symbol"
-                : typeof obj;
-            };
-      var _slicedToArray = (function () {
-        function sliceIterator(arr, i) {
-          var _arr = [];
-          var _n = true;
-          var _d = false;
-          var _e = void 0;
-          try {
-            for (
-              var _i = arr[Symbol.iterator](), _s;
-              !(_n = (_s = _i.next()).done);
-              _n = true
-            ) {
-              _arr.push(_s.value);
-              if (i && _arr.length === i) break;
-            }
-          } catch (err) {
-            _d = true;
-            _e = err;
-          } finally {
-            try {
-              if (!_n && _i["return"]) _i["return"]();
-            } finally {
-              if (_d) throw _e;
-            }
-          }
-          return _arr;
-        }
-        return function (arr, i) {
-          if (Array.isArray(arr)) {
-            return arr;
-          } else if (Symbol.iterator in Object(arr)) {
-            return sliceIterator(arr, i);
-          } else {
-            throw new TypeError(
-              "Invalid attempt to destructure non-iterable instance"
-            );
-          }
-        };
-      })();
-      var _extends =
-        Object.assign ||
-        function (target2) {
-          for (var i = 1; i < arguments.length; i++) {
-            var source = arguments[i];
-            for (var key in source) {
-              if (Object.prototype.hasOwnProperty.call(source, key)) {
-                target2[key] = source[key];
-              }
-            }
-          }
-          return target2;
-        };
-      var _createClass = (function () {
-        function defineProperties(target2, props) {
-          for (var i = 0; i < props.length; i++) {
-            var descriptor = props[i];
-            descriptor.enumerable = descriptor.enumerable || false;
-            descriptor.configurable = true;
-            if ("value" in descriptor) descriptor.writable = true;
-            Object.defineProperty(target2, descriptor.key, descriptor);
-          }
-        }
-        return function (Constructor, protoProps, staticProps) {
-          if (protoProps) defineProperties(Constructor.prototype, protoProps);
-          if (staticProps) defineProperties(Constructor, staticProps);
-          return Constructor;
-        };
-      })();
-      Explorer$1.defaultValue = defaultValue;
-      var _react = react.exports;
-      var React = _interopRequireWildcard(_react);
-      var _graphql = require$$1$2;
-      function _interopRequireWildcard(obj) {
-        if (obj && obj.__esModule) {
-          return obj;
-        } else {
-          var newObj = {};
-          if (obj != null) {
-            for (var key in obj) {
-              if (Object.prototype.hasOwnProperty.call(obj, key))
-                newObj[key] = obj[key];
-            }
-          }
-          newObj.default = obj;
-          return newObj;
-        }
-      }
-      function _defineProperty(obj, key, value) {
-        if (key in obj) {
-          Object.defineProperty(obj, key, {
-            value,
-            enumerable: true,
-            configurable: true,
-            writable: true,
-          });
-        } else {
-          obj[key] = value;
-        }
-        return obj;
-      }
-      function _toConsumableArray(arr) {
-        if (Array.isArray(arr)) {
-          for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) {
-            arr2[i] = arr[i];
-          }
-          return arr2;
-        } else {
-          return Array.from(arr);
-        }
-      }
-      function _classCallCheck(instance, Constructor) {
-        if (!(instance instanceof Constructor)) {
-          throw new TypeError("Cannot call a class as a function");
-        }
-      }
-      function _possibleConstructorReturn(self2, call) {
-        if (!self2) {
-          throw new ReferenceError(
-            "this hasn't been initialised - super() hasn't been called"
-          );
-        }
-        return call && (typeof call === "object" || typeof call === "function")
-          ? call
-          : self2;
-      }
-      function _inherits(subClass, superClass) {
-        if (typeof superClass !== "function" && superClass !== null) {
-          throw new TypeError(
-            "Super expression must either be null or a function, not " +
-              typeof superClass
-          );
-        }
-        subClass.prototype = Object.create(superClass && superClass.prototype, {
-          constructor: {
-            value: subClass,
-            enumerable: false,
-            writable: true,
-            configurable: true,
-          },
-        });
-        if (superClass)
-          Object.setPrototypeOf
-            ? Object.setPrototypeOf(subClass, superClass)
-            : (subClass.__proto__ = superClass);
-      }
-      function capitalize(string2) {
-        return string2.charAt(0).toUpperCase() + string2.slice(1);
-      }
-      var defaultColors = {
-        keyword: "#B11A04",
-        def: "#D2054E",
-        property: "#1F61A0",
-        qualifier: "#1C92A9",
-        attribute: "#8B2BB9",
-        number: "#2882F9",
-        string: "#D64292",
-        builtin: "#D47509",
-        string2: "#0B7FC7",
-        variable: "#397D13",
-        atom: "#CA9800",
-      };
-      var defaultArrowOpen = React.createElement(
-        "svg",
-        { width: "12", height: "9" },
-        React.createElement("path", {
-          fill: "#666",
-          d: "M 0 2 L 9 2 L 4.5 7.5 z",
-        })
-      );
-      var defaultArrowClosed = React.createElement(
-        "svg",
-        { width: "12", height: "9" },
-        React.createElement("path", {
-          fill: "#666",
-          d: "M 0 0 L 0 9 L 5.5 4.5 z",
-        })
-      );
-      var defaultCheckboxChecked = React.createElement(
-        "svg",
-        {
-          style: { marginRight: "3px", marginLeft: "-3px" },
-          width: "12",
-          height: "12",
-          viewBox: "0 0 18 18",
-          fill: "none",
-          xmlns: "http://www.w3.org/2000/svg",
-        },
-        React.createElement("path", {
-          d: "M16 0H2C0.9 0 0 0.9 0 2V16C0 17.1 0.9 18 2 18H16C17.1 18 18 17.1 18 16V2C18 0.9 17.1 0 16 0ZM16 16H2V2H16V16ZM14.99 6L13.58 4.58L6.99 11.17L4.41 8.6L2.99 10.01L6.99 14L14.99 6Z",
-          fill: "#666",
-        })
-      );
-      var defaultCheckboxUnchecked = React.createElement(
-        "svg",
-        {
-          style: { marginRight: "3px", marginLeft: "-3px" },
-          width: "12",
-          height: "12",
-          viewBox: "0 0 18 18",
-          fill: "none",
-          xmlns: "http://www.w3.org/2000/svg",
-        },
-        React.createElement("path", {
-          d: "M16 2V16H2V2H16ZM16 0H2C0.9 0 0 0.9 0 2V16C0 17.1 0.9 18 2 18H16C17.1 18 18 17.1 18 16V2C18 0.9 17.1 0 16 0Z",
-          fill: "#CCC",
-        })
-      );
-      function Checkbox(props) {
-        return props.checked
-          ? props.styleConfig.checkboxChecked
-          : props.styleConfig.checkboxUnchecked;
-      }
-      function defaultGetDefaultFieldNames(type2) {
-        var fields = type2.getFields();
-        if (fields["id"]) {
-          var res = ["id"];
-          if (fields["email"]) {
-            res.push("email");
-          } else if (fields["name"]) {
-            res.push("name");
-          }
-          return res;
-        }
-        if (fields["edges"]) {
-          return ["edges"];
-        }
-        if (fields["node"]) {
-          return ["node"];
-        }
-        if (fields["nodes"]) {
-          return ["nodes"];
-        }
-        var leafFieldNames = [];
-        Object.keys(fields).forEach(function (fieldName) {
-          if ((0, _graphql.isLeafType)(fields[fieldName].type)) {
-            leafFieldNames.push(fieldName);
-          }
-        });
-        if (!leafFieldNames.length) {
-          return ["__typename"];
-        }
-        return leafFieldNames.slice(0, 2);
-      }
-      function isRequiredArgument(arg) {
-        return (
-          (0, _graphql.isNonNullType)(arg.type) && arg.defaultValue === void 0
-        );
-      }
-      function unwrapOutputType(outputType) {
-        var unwrappedType = outputType;
-        while ((0, _graphql.isWrappingType)(unwrappedType)) {
-          unwrappedType = unwrappedType.ofType;
-        }
-        return unwrappedType;
-      }
-      function unwrapInputType(inputType) {
-        var unwrappedType = inputType;
-        while ((0, _graphql.isWrappingType)(unwrappedType)) {
-          unwrappedType = unwrappedType.ofType;
-        }
-        return unwrappedType;
-      }
-      function coerceArgValue(argType, value) {
-        if (typeof value !== "string" && value.kind === "VariableDefinition") {
-          return value.variable;
-        } else if ((0, _graphql.isScalarType)(argType)) {
-          try {
-            switch (argType.name) {
-              case "String":
-                return {
-                  kind: "StringValue",
-                  value: String(argType.parseValue(value)),
-                };
-              case "Float":
-                return {
-                  kind: "FloatValue",
-                  value: String(argType.parseValue(parseFloat(value))),
-                };
-              case "Int":
-                return {
-                  kind: "IntValue",
-                  value: String(argType.parseValue(parseInt(value, 10))),
-                };
-              case "Boolean":
-                try {
-                  var parsed = JSON.parse(value);
-                  if (typeof parsed === "boolean") {
-                    return { kind: "BooleanValue", value: parsed };
-                  } else {
-                    return { kind: "BooleanValue", value: false };
-                  }
-                } catch (e) {
-                  return {
-                    kind: "BooleanValue",
-                    value: false,
-                  };
-                }
-              default:
-                return {
-                  kind: "StringValue",
-                  value: String(argType.parseValue(value)),
-                };
-            }
-          } catch (e) {
-            console.error("error coercing arg value", e, value);
-            return { kind: "StringValue", value };
-          }
-        } else {
-          try {
-            var parsedValue = argType.parseValue(value);
-            if (parsedValue) {
-              return { kind: "EnumValue", value: String(parsedValue) };
-            } else {
-              return { kind: "EnumValue", value: argType.getValues()[0].name };
-            }
-          } catch (e) {
-            return { kind: "EnumValue", value: argType.getValues()[0].name };
-          }
-        }
-      }
-      var InputArgView = (function (_React$PureComponent) {
-        _inherits(InputArgView2, _React$PureComponent);
-        function InputArgView2() {
-          var _ref;
-          var _temp, _this, _ret;
-          _classCallCheck(this, InputArgView2);
-          for (
-            var _len = arguments.length, args = Array(_len), _key = 0;
-            _key < _len;
-            _key++
-          ) {
-            args[_key] = arguments[_key];
-          }
-          return (
-            (_ret =
-              ((_temp =
-                ((_this = _possibleConstructorReturn(
-                  this,
-                  (_ref =
-                    InputArgView2.__proto__ ||
-                    Object.getPrototypeOf(InputArgView2)).call.apply(
-                    _ref,
-                    [this].concat(args)
-                  )
-                )),
-                _this)),
-              (_this._getArgSelection = function () {
-                return _this.props.selection.fields.find(function (field) {
-                  return field.name.value === _this.props.arg.name;
-                });
-              }),
-              (_this._removeArg = function () {
-                var selection = _this.props.selection;
-                var argSelection = _this._getArgSelection();
-                _this._previousArgSelection = argSelection;
-                _this.props.modifyFields(
-                  selection.fields.filter(function (field) {
-                    return field !== argSelection;
-                  }),
-                  true
-                );
-              }),
-              (_this._addArg = function () {
-                var _this$props = _this.props,
-                  selection = _this$props.selection,
-                  arg = _this$props.arg,
-                  getDefaultScalarArgValue =
-                    _this$props.getDefaultScalarArgValue,
-                  parentField = _this$props.parentField,
-                  makeDefaultArg = _this$props.makeDefaultArg;
-                var argType = unwrapInputType(arg.type);
-                var argSelection = null;
-                if (_this._previousArgSelection) {
-                  argSelection = _this._previousArgSelection;
-                } else if ((0, _graphql.isInputObjectType)(argType)) {
-                  var _fields = argType.getFields();
-                  argSelection = {
-                    kind: "ObjectField",
-                    name: { kind: "Name", value: arg.name },
-                    value: {
-                      kind: "ObjectValue",
-                      fields: defaultInputObjectFields(
-                        getDefaultScalarArgValue,
-                        makeDefaultArg,
-                        parentField,
-                        Object.keys(_fields).map(function (k) {
-                          return _fields[k];
-                        })
-                      ),
-                    },
-                  };
-                } else if ((0, _graphql.isLeafType)(argType)) {
-                  argSelection = {
-                    kind: "ObjectField",
-                    name: { kind: "Name", value: arg.name },
-                    value: getDefaultScalarArgValue(parentField, arg, argType),
-                  };
-                }
-                if (!argSelection) {
-                  console.error("Unable to add arg for argType", argType);
-                } else {
-                  return _this.props.modifyFields(
-                    [].concat(_toConsumableArray(selection.fields || []), [
-                      argSelection,
-                    ]),
-                    true
-                  );
-                }
-              }),
-              (_this._setArgValue = function (event, options) {
-                var settingToNull = false;
-                var settingToVariable = false;
-                var settingToLiteralValue = false;
-                try {
-                  if (event.kind === "VariableDefinition") {
-                    settingToVariable = true;
-                  } else if (event === null || typeof event === "undefined") {
-                    settingToNull = true;
-                  } else if (typeof event.kind === "string") {
-                    settingToLiteralValue = true;
-                  }
-                } catch (e) {}
-                var selection = _this.props.selection;
-                var argSelection = _this._getArgSelection();
-                if (!argSelection) {
-                  console.error("missing arg selection when setting arg value");
-                  return;
-                }
-                var argType = unwrapInputType(_this.props.arg.type);
-                var handleable =
-                  (0, _graphql.isLeafType)(argType) ||
-                  settingToVariable ||
-                  settingToNull ||
-                  settingToLiteralValue;
-                if (!handleable) {
-                  console.warn(
-                    "Unable to handle non leaf types in InputArgView.setArgValue",
-                    event
-                  );
-                  return;
-                }
-                var targetValue = void 0;
-                var value = void 0;
-                if (event === null || typeof event === "undefined") {
-                  value = null;
-                } else if (
-                  !event.target &&
-                  !!event.kind &&
-                  event.kind === "VariableDefinition"
-                ) {
-                  targetValue = event;
-                  value = targetValue.variable;
-                } else if (typeof event.kind === "string") {
-                  value = event;
-                } else if (
-                  event.target &&
-                  typeof event.target.value === "string"
-                ) {
-                  targetValue = event.target.value;
-                  value = coerceArgValue(argType, targetValue);
-                }
-                var newDoc = _this.props.modifyFields(
-                  (selection.fields || []).map(function (field) {
-                    var isTarget = field === argSelection;
-                    var newField = isTarget
-                      ? _extends({}, field, {
-                          value,
-                        })
-                      : field;
-                    return newField;
-                  }),
-                  options
-                );
-                return newDoc;
-              }),
-              (_this._modifyChildFields = function (fields) {
-                return _this.props.modifyFields(
-                  _this.props.selection.fields.map(function (field) {
-                    return field.name.value === _this.props.arg.name
-                      ? _extends({}, field, {
-                          value: {
-                            kind: "ObjectValue",
-                            fields,
-                          },
-                        })
-                      : field;
-                  }),
-                  true
-                );
-              }),
-              _temp)),
-            _possibleConstructorReturn(_this, _ret)
-          );
-        }
-        _createClass(InputArgView2, [
-          {
-            key: "render",
-            value: function render() {
-              var _props = this.props,
-                arg = _props.arg,
-                parentField = _props.parentField;
-              var argSelection = this._getArgSelection();
-              return React.createElement(AbstractArgView, {
-                argValue: argSelection ? argSelection.value : null,
-                arg,
-                parentField,
-                addArg: this._addArg,
-                removeArg: this._removeArg,
-                setArgFields: this._modifyChildFields,
-                setArgValue: this._setArgValue,
-                getDefaultScalarArgValue: this.props.getDefaultScalarArgValue,
-                makeDefaultArg: this.props.makeDefaultArg,
-                onRunOperation: this.props.onRunOperation,
-                styleConfig: this.props.styleConfig,
-                onCommit: this.props.onCommit,
-                definition: this.props.definition,
-              });
-            },
-          },
-        ]);
-        return InputArgView2;
-      })(React.PureComponent);
-      function defaultValue(argType) {
-        if ((0, _graphql.isEnumType)(argType)) {
-          return { kind: "EnumValue", value: argType.getValues()[0].name };
-        } else {
-          switch (argType.name) {
-            case "String":
-              return { kind: "StringValue", value: "" };
-            case "Float":
-              return { kind: "FloatValue", value: "1.5" };
-            case "Int":
-              return { kind: "IntValue", value: "10" };
-            case "Boolean":
-              return { kind: "BooleanValue", value: false };
-            default:
-              return { kind: "StringValue", value: "" };
-          }
-        }
-      }
-      function defaultGetDefaultScalarArgValue(parentField, arg, argType) {
-        return defaultValue(argType);
-      }
-      var ArgView = (function (_React$PureComponent2) {
-        _inherits(ArgView2, _React$PureComponent2);
-        function ArgView2() {
-          var _ref2;
-          var _temp2, _this2, _ret2;
-          _classCallCheck(this, ArgView2);
-          for (
-            var _len2 = arguments.length, args = Array(_len2), _key2 = 0;
-            _key2 < _len2;
-            _key2++
-          ) {
-            args[_key2] = arguments[_key2];
-          }
-          return (
-            (_ret2 =
-              ((_temp2 =
-                ((_this2 = _possibleConstructorReturn(
-                  this,
-                  (_ref2 =
-                    ArgView2.__proto__ ||
-                    Object.getPrototypeOf(ArgView2)).call.apply(
-                    _ref2,
-                    [this].concat(args)
-                  )
-                )),
-                _this2)),
-              (_this2._getArgSelection = function () {
-                var selection = _this2.props.selection;
-                return (selection.arguments || []).find(function (arg) {
-                  return arg.name.value === _this2.props.arg.name;
-                });
-              }),
-              (_this2._removeArg = function (commit) {
-                var selection = _this2.props.selection;
-                var argSelection = _this2._getArgSelection();
-                _this2._previousArgSelection = argSelection;
-                return _this2.props.modifyArguments(
-                  (selection.arguments || []).filter(function (arg) {
-                    return arg !== argSelection;
-                  }),
-                  commit
-                );
-              }),
-              (_this2._addArg = function (commit) {
-                var _this2$props = _this2.props,
-                  selection = _this2$props.selection,
-                  getDefaultScalarArgValue =
-                    _this2$props.getDefaultScalarArgValue,
-                  makeDefaultArg = _this2$props.makeDefaultArg,
-                  parentField = _this2$props.parentField,
-                  arg = _this2$props.arg;
-                var argType = unwrapInputType(arg.type);
-                var argSelection = null;
-                if (_this2._previousArgSelection) {
-                  argSelection = _this2._previousArgSelection;
-                } else if ((0, _graphql.isInputObjectType)(argType)) {
-                  var _fields2 = argType.getFields();
-                  argSelection = {
-                    kind: "Argument",
-                    name: { kind: "Name", value: arg.name },
-                    value: {
-                      kind: "ObjectValue",
-                      fields: defaultInputObjectFields(
-                        getDefaultScalarArgValue,
-                        makeDefaultArg,
-                        parentField,
-                        Object.keys(_fields2).map(function (k) {
-                          return _fields2[k];
-                        })
-                      ),
-                    },
-                  };
-                } else if ((0, _graphql.isLeafType)(argType)) {
-                  argSelection = {
-                    kind: "Argument",
-                    name: { kind: "Name", value: arg.name },
-                    value: getDefaultScalarArgValue(parentField, arg, argType),
-                  };
-                }
-                if (!argSelection) {
-                  console.error("Unable to add arg for argType", argType);
-                  return null;
-                } else {
-                  return _this2.props.modifyArguments(
-                    [].concat(_toConsumableArray(selection.arguments || []), [
-                      argSelection,
-                    ]),
-                    commit
-                  );
-                }
-              }),
-              (_this2._setArgValue = function (event, options) {
-                var settingToNull = false;
-                var settingToVariable = false;
-                var settingToLiteralValue = false;
-                try {
-                  if (event.kind === "VariableDefinition") {
-                    settingToVariable = true;
-                  } else if (event === null || typeof event === "undefined") {
-                    settingToNull = true;
-                  } else if (typeof event.kind === "string") {
-                    settingToLiteralValue = true;
-                  }
-                } catch (e) {}
-                var selection = _this2.props.selection;
-                var argSelection = _this2._getArgSelection();
-                if (!argSelection && !settingToVariable) {
-                  console.error("missing arg selection when setting arg value");
-                  return;
-                }
-                var argType = unwrapInputType(_this2.props.arg.type);
-                var handleable =
-                  (0, _graphql.isLeafType)(argType) ||
-                  settingToVariable ||
-                  settingToNull ||
-                  settingToLiteralValue;
-                if (!handleable) {
-                  console.warn(
-                    "Unable to handle non leaf types in ArgView._setArgValue"
-                  );
-                  return;
-                }
-                var targetValue = void 0;
-                var value = void 0;
-                if (event === null || typeof event === "undefined") {
-                  value = null;
-                } else if (
-                  event.target &&
-                  typeof event.target.value === "string"
-                ) {
-                  targetValue = event.target.value;
-                  value = coerceArgValue(argType, targetValue);
-                } else if (
-                  !event.target &&
-                  event.kind === "VariableDefinition"
-                ) {
-                  targetValue = event;
-                  value = targetValue.variable;
-                } else if (typeof event.kind === "string") {
-                  value = event;
-                }
-                return _this2.props.modifyArguments(
-                  (selection.arguments || []).map(function (a) {
-                    return a === argSelection
-                      ? _extends({}, a, {
-                          value,
-                        })
-                      : a;
-                  }),
-                  options
-                );
-              }),
-              (_this2._setArgFields = function (fields, commit) {
-                var selection = _this2.props.selection;
-                var argSelection = _this2._getArgSelection();
-                if (!argSelection) {
-                  console.error("missing arg selection when setting arg value");
-                  return;
-                }
-                return _this2.props.modifyArguments(
-                  (selection.arguments || []).map(function (a) {
-                    return a === argSelection
-                      ? _extends({}, a, {
-                          value: {
-                            kind: "ObjectValue",
-                            fields,
-                          },
-                        })
-                      : a;
-                  }),
-                  commit
-                );
-              }),
-              _temp2)),
-            _possibleConstructorReturn(_this2, _ret2)
-          );
-        }
-        _createClass(ArgView2, [
-          {
-            key: "render",
-            value: function render() {
-              var _props2 = this.props,
-                arg = _props2.arg,
-                parentField = _props2.parentField;
-              var argSelection = this._getArgSelection();
-              return React.createElement(AbstractArgView, {
-                argValue: argSelection ? argSelection.value : null,
-                arg,
-                parentField,
-                addArg: this._addArg,
-                removeArg: this._removeArg,
-                setArgFields: this._setArgFields,
-                setArgValue: this._setArgValue,
-                getDefaultScalarArgValue: this.props.getDefaultScalarArgValue,
-                makeDefaultArg: this.props.makeDefaultArg,
-                onRunOperation: this.props.onRunOperation,
-                styleConfig: this.props.styleConfig,
-                onCommit: this.props.onCommit,
-                definition: this.props.definition,
-              });
-            },
-          },
-        ]);
-        return ArgView2;
-      })(React.PureComponent);
-      function isRunShortcut(event) {
-        return event.ctrlKey && event.key === "Enter";
-      }
-      function canRunOperation(operationName) {
-        return operationName !== "FragmentDefinition";
-      }
-      var ScalarInput = (function (_React$PureComponent3) {
-        _inherits(ScalarInput2, _React$PureComponent3);
-        function ScalarInput2() {
-          var _ref3;
-          var _temp3, _this3, _ret3;
-          _classCallCheck(this, ScalarInput2);
-          for (
-            var _len3 = arguments.length, args = Array(_len3), _key3 = 0;
-            _key3 < _len3;
-            _key3++
-          ) {
-            args[_key3] = arguments[_key3];
-          }
-          return (
-            (_ret3 =
-              ((_temp3 =
-                ((_this3 = _possibleConstructorReturn(
-                  this,
-                  (_ref3 =
-                    ScalarInput2.__proto__ ||
-                    Object.getPrototypeOf(ScalarInput2)).call.apply(
-                    _ref3,
-                    [this].concat(args)
-                  )
-                )),
-                _this3)),
-              (_this3._handleChange = function (event) {
-                _this3.props.setArgValue(event, true);
-              }),
-              _temp3)),
-            _possibleConstructorReturn(_this3, _ret3)
-          );
-        }
-        _createClass(ScalarInput2, [
-          {
-            key: "componentDidMount",
-            value: function componentDidMount() {
-              var input = this._ref;
-              var activeElement = document.activeElement;
-              if (
-                input &&
-                activeElement &&
-                !(activeElement instanceof HTMLTextAreaElement)
-              ) {
-                input.focus();
-                input.setSelectionRange(0, input.value.length);
-              }
-            },
-          },
-          {
-            key: "render",
-            value: function render() {
-              var _this4 = this;
-              var _props3 = this.props,
-                arg = _props3.arg,
-                argValue = _props3.argValue,
-                styleConfig = _props3.styleConfig;
-              var argType = unwrapInputType(arg.type);
-              var value =
-                typeof argValue.value === "string" ? argValue.value : "";
-              var color =
-                this.props.argValue.kind === "StringValue"
-                  ? styleConfig.colors.string
-                  : styleConfig.colors.number;
-              return React.createElement(
-                "span",
-                { style: { color } },
-                argType.name === "String" ? '"' : "",
-                React.createElement("input", {
-                  style: {
-                    border: "none",
-                    borderBottom: "1px solid #888",
-                    outline: "none",
-                    width: Math.max(1, Math.min(15, value.length)) + "ch",
-                    color,
-                  },
-                  ref: function ref(_ref4) {
-                    _this4._ref = _ref4;
-                  },
-                  type: "text",
-                  onChange: this._handleChange,
-                  value,
-                }),
-                argType.name === "String" ? '"' : ""
-              );
-            },
-          },
-        ]);
-        return ScalarInput2;
-      })(React.PureComponent);
-      var AbstractArgView = (function (_React$PureComponent4) {
-        _inherits(AbstractArgView2, _React$PureComponent4);
-        function AbstractArgView2() {
-          var _ref5;
-          var _temp4, _this5, _ret4;
-          _classCallCheck(this, AbstractArgView2);
-          for (
-            var _len4 = arguments.length, args = Array(_len4), _key4 = 0;
-            _key4 < _len4;
-            _key4++
-          ) {
-            args[_key4] = arguments[_key4];
-          }
-          return (
-            (_ret4 =
-              ((_temp4 =
-                ((_this5 = _possibleConstructorReturn(
-                  this,
-                  (_ref5 =
-                    AbstractArgView2.__proto__ ||
-                    Object.getPrototypeOf(AbstractArgView2)).call.apply(
-                    _ref5,
-                    [this].concat(args)
-                  )
-                )),
-                _this5)),
-              (_this5.state = { displayArgActions: false }),
-              _temp4)),
-            _possibleConstructorReturn(_this5, _ret4)
-          );
-        }
-        _createClass(AbstractArgView2, [
-          {
-            key: "render",
-            value: function render() {
-              var _this6 = this;
-              var _props4 = this.props,
-                argValue = _props4.argValue,
-                arg = _props4.arg,
-                styleConfig = _props4.styleConfig;
-              var argType = unwrapInputType(arg.type);
-              var input = null;
-              if (argValue) {
-                if (argValue.kind === "Variable") {
-                  input = React.createElement(
-                    "span",
-                    { style: { color: styleConfig.colors.variable } },
-                    "$",
-                    argValue.name.value
-                  );
-                } else if ((0, _graphql.isScalarType)(argType)) {
-                  if (argType.name === "Boolean") {
-                    input = React.createElement(
-                      "select",
-                      {
-                        style: {
-                          color: styleConfig.colors.builtin,
-                        },
-                        onChange: this.props.setArgValue,
-                        value:
-                          argValue.kind === "BooleanValue"
-                            ? argValue.value
-                            : void 0,
-                      },
-                      React.createElement(
-                        "option",
-                        { key: "true", value: "true" },
-                        "true"
-                      ),
-                      React.createElement(
-                        "option",
-                        { key: "false", value: "false" },
-                        "false"
-                      )
-                    );
-                  } else {
-                    input = React.createElement(ScalarInput, {
-                      setArgValue: this.props.setArgValue,
-                      arg,
-                      argValue,
-                      onRunOperation: this.props.onRunOperation,
-                      styleConfig: this.props.styleConfig,
-                    });
-                  }
-                } else if ((0, _graphql.isEnumType)(argType)) {
-                  if (argValue.kind === "EnumValue") {
-                    input = React.createElement(
-                      "select",
-                      {
-                        style: {
-                          backgroundColor: "white",
-                          color: styleConfig.colors.string2,
-                        },
-                        onChange: this.props.setArgValue,
-                        value: argValue.value,
-                      },
-                      argType.getValues().map(function (value) {
-                        return React.createElement(
-                          "option",
-                          { key: value.name, value: value.name },
-                          value.name
-                        );
-                      })
-                    );
-                  } else {
-                    console.error(
-                      "arg mismatch between arg and selection",
-                      argType,
-                      argValue
-                    );
-                  }
-                } else if ((0, _graphql.isInputObjectType)(argType)) {
-                  if (argValue.kind === "ObjectValue") {
-                    var _fields3 = argType.getFields();
-                    input = React.createElement(
-                      "div",
-                      { style: { marginLeft: 16 } },
-                      Object.keys(_fields3)
-                        .sort()
-                        .map(function (fieldName) {
-                          return React.createElement(InputArgView, {
-                            key: fieldName,
-                            arg: _fields3[fieldName],
-                            parentField: _this6.props.parentField,
-                            selection: argValue,
-                            modifyFields: _this6.props.setArgFields,
-                            getDefaultScalarArgValue:
-                              _this6.props.getDefaultScalarArgValue,
-                            makeDefaultArg: _this6.props.makeDefaultArg,
-                            onRunOperation: _this6.props.onRunOperation,
-                            styleConfig: _this6.props.styleConfig,
-                            onCommit: _this6.props.onCommit,
-                            definition: _this6.props.definition,
-                          });
-                        })
-                    );
-                  } else {
-                    console.error(
-                      "arg mismatch between arg and selection",
-                      argType,
-                      argValue
-                    );
-                  }
-                }
-              }
-              var variablize = function variablize2() {
-                var baseVariableName = arg.name;
-                var conflictingNameCount = (
-                  _this6.props.definition.variableDefinitions || []
-                ).filter(function (varDef) {
-                  return varDef.variable.name.value.startsWith(
-                    baseVariableName
-                  );
-                }).length;
-                var variableName = void 0;
-                if (conflictingNameCount > 0) {
-                  variableName = "" + baseVariableName + conflictingNameCount;
-                } else {
-                  variableName = baseVariableName;
-                }
-                var argPrintedType = arg.type.toString();
-                var argType2 = (0, _graphql.parseType)(argPrintedType);
-                var base2 = {
-                  kind: "VariableDefinition",
-                  variable: {
-                    kind: "Variable",
-                    name: {
-                      kind: "Name",
-                      value: variableName,
-                    },
-                  },
-                  type: argType2,
-                  directives: [],
-                };
-                var variableDefinitionByName =
-                  function variableDefinitionByName2(name2) {
-                    return (
-                      _this6.props.definition.variableDefinitions || []
-                    ).find(function (varDef) {
-                      return varDef.variable.name.value === name2;
-                    });
-                  };
-                var variable = void 0;
-                var subVariableUsageCountByName = {};
-                if (typeof argValue !== "undefined" && argValue !== null) {
-                  var cleanedDefaultValue = (0, _graphql.visit)(argValue, {
-                    Variable: function Variable(node) {
-                      var varName = node.name.value;
-                      var varDef = variableDefinitionByName(varName);
-                      subVariableUsageCountByName[varName] =
-                        subVariableUsageCountByName[varName] + 1 || 1;
-                      if (!varDef) {
-                        return;
-                      }
-                      return varDef.defaultValue;
-                    },
-                  });
-                  var isNonNullable = base2.type.kind === "NonNullType";
-                  var unwrappedBase = isNonNullable
-                    ? _extends({}, base2, { type: base2.type.type })
-                    : base2;
-                  variable = _extends({}, unwrappedBase, {
-                    defaultValue: cleanedDefaultValue,
-                  });
-                } else {
-                  variable = base2;
-                }
-                var newlyUnusedVariables = Object.entries(
-                  subVariableUsageCountByName
-                )
-                  .filter(function (_ref6) {
-                    var _ref7 = _slicedToArray(_ref6, 2);
-                    _ref7[0];
-                    var usageCount = _ref7[1];
-                    return usageCount < 2;
-                  })
-                  .map(function (_ref8) {
-                    var _ref9 = _slicedToArray(_ref8, 2),
-                      varName = _ref9[0];
-                    _ref9[1];
-                    return varName;
-                  });
-                if (variable) {
-                  var _newDoc = _this6.props.setArgValue(variable, false);
-                  if (_newDoc) {
-                    var targetOperation = _newDoc.definitions.find(function (
-                      definition
-                    ) {
-                      if (
-                        !!definition.operation &&
-                        !!definition.name &&
-                        !!definition.name.value &&
-                        !!_this6.props.definition.name &&
-                        !!_this6.props.definition.name.value
-                      ) {
-                        return (
-                          definition.name.value ===
-                          _this6.props.definition.name.value
-                        );
-                      } else {
-                        return false;
-                      }
-                    });
-                    var newVariableDefinitions = []
-                      .concat(
-                        _toConsumableArray(
-                          targetOperation.variableDefinitions || []
-                        ),
-                        [variable]
-                      )
-                      .filter(function (varDef) {
-                        return (
-                          newlyUnusedVariables.indexOf(
-                            varDef.variable.name.value
-                          ) === -1
-                        );
-                      });
-                    var newOperation = _extends({}, targetOperation, {
-                      variableDefinitions: newVariableDefinitions,
-                    });
-                    var existingDefs = _newDoc.definitions;
-                    var newDefinitions = existingDefs.map(function (
-                      existingOperation
-                    ) {
-                      if (targetOperation === existingOperation) {
-                        return newOperation;
-                      } else {
-                        return existingOperation;
-                      }
-                    });
-                    var finalDoc = _extends({}, _newDoc, {
-                      definitions: newDefinitions,
-                    });
-                    _this6.props.onCommit(finalDoc);
-                  }
-                }
-              };
-              var devariablize = function devariablize2() {
-                if (!argValue || !argValue.name || !argValue.name.value) {
-                  return;
-                }
-                var variableName = argValue.name.value;
-                var variableDefinition = (
-                  _this6.props.definition.variableDefinitions || []
-                ).find(function (varDef) {
-                  return varDef.variable.name.value === variableName;
-                });
-                if (!variableDefinition) {
-                  return;
-                }
-                var defaultValue2 = variableDefinition.defaultValue;
-                var newDoc = _this6.props.setArgValue(defaultValue2, {
-                  commit: false,
-                });
-                if (newDoc) {
-                  var targetOperation = newDoc.definitions.find(function (
-                    definition
-                  ) {
-                    return (
-                      definition.name.value ===
-                      _this6.props.definition.name.value
-                    );
-                  });
-                  if (!targetOperation) {
-                    return;
-                  }
-                  var variableUseCount = 0;
-                  (0, _graphql.visit)(targetOperation, {
-                    Variable: function Variable(node) {
-                      if (node.name.value === variableName) {
-                        variableUseCount = variableUseCount + 1;
-                      }
-                    },
-                  });
-                  var newVariableDefinitions =
-                    targetOperation.variableDefinitions || [];
-                  if (variableUseCount < 2) {
-                    newVariableDefinitions = newVariableDefinitions.filter(
-                      function (varDef) {
-                        return varDef.variable.name.value !== variableName;
-                      }
-                    );
-                  }
-                  var newOperation = _extends({}, targetOperation, {
-                    variableDefinitions: newVariableDefinitions,
-                  });
-                  var existingDefs = newDoc.definitions;
-                  var newDefinitions = existingDefs.map(function (
-                    existingOperation
-                  ) {
-                    if (targetOperation === existingOperation) {
-                      return newOperation;
-                    } else {
-                      return existingOperation;
-                    }
-                  });
-                  var finalDoc = _extends({}, newDoc, {
-                    definitions: newDefinitions,
-                  });
-                  _this6.props.onCommit(finalDoc);
-                }
-              };
-              var isArgValueVariable = argValue && argValue.kind === "Variable";
-              var variablizeActionButton = !this.state.displayArgActions
-                ? null
-                : React.createElement(
-                    "button",
-                    {
-                      type: "submit",
-                      className: "toolbar-button",
-                      title: isArgValueVariable
-                        ? "Remove the variable"
-                        : "Extract the current value into a GraphQL variable",
-                      onClick: function onClick(event) {
-                        event.preventDefault();
-                        event.stopPropagation();
-                        if (isArgValueVariable) {
-                          devariablize();
-                        } else {
-                          variablize();
-                        }
-                      },
-                      style: styleConfig.styles.actionButtonStyle,
-                    },
-                    React.createElement(
-                      "span",
-                      { style: { color: styleConfig.colors.variable } },
-                      "$"
-                    )
-                  );
-              return React.createElement(
-                "div",
-                {
-                  style: {
-                    cursor: "pointer",
-                    minHeight: "16px",
-                    WebkitUserSelect: "none",
-                    userSelect: "none",
-                  },
-                  "data-arg-name": arg.name,
-                  "data-arg-type": argType.name,
-                  className: "graphiql-explorer-" + arg.name,
-                },
-                React.createElement(
-                  "span",
-                  {
-                    style: { cursor: "pointer" },
-                    onClick: function onClick(event) {
-                      var shouldAdd = !argValue;
-                      if (shouldAdd) {
-                        _this6.props.addArg(true);
-                      } else {
-                        _this6.props.removeArg(true);
-                      }
-                      _this6.setState({ displayArgActions: shouldAdd });
-                    },
-                  },
-                  (0, _graphql.isInputObjectType)(argType)
-                    ? React.createElement(
-                        "span",
-                        null,
-                        !!argValue
-                          ? this.props.styleConfig.arrowOpen
-                          : this.props.styleConfig.arrowClosed
-                      )
-                    : React.createElement(Checkbox, {
-                        checked: !!argValue,
-                        styleConfig: this.props.styleConfig,
-                      }),
-                  React.createElement(
-                    "span",
-                    {
-                      style: { color: styleConfig.colors.attribute },
-                      title: arg.description,
-                      onMouseEnter: function onMouseEnter() {
-                        if (
-                          argValue !== null &&
-                          typeof argValue !== "undefined"
-                        ) {
-                          _this6.setState({ displayArgActions: true });
-                        }
-                      },
-                      onMouseLeave: function onMouseLeave() {
-                        return _this6.setState({ displayArgActions: false });
-                      },
-                    },
-                    arg.name,
-                    isRequiredArgument(arg) ? "*" : "",
-                    ": ",
-                    variablizeActionButton,
-                    " "
-                  ),
-                  " "
-                ),
-                input || React.createElement("span", null),
-                " "
-              );
-            },
-          },
-        ]);
-        return AbstractArgView2;
-      })(React.PureComponent);
-      var AbstractView = (function (_React$PureComponent5) {
-        _inherits(AbstractView2, _React$PureComponent5);
-        function AbstractView2() {
-          var _ref10;
-          var _temp5, _this7, _ret5;
-          _classCallCheck(this, AbstractView2);
-          for (
-            var _len5 = arguments.length, args = Array(_len5), _key5 = 0;
-            _key5 < _len5;
-            _key5++
-          ) {
-            args[_key5] = arguments[_key5];
-          }
-          return (
-            (_ret5 =
-              ((_temp5 =
-                ((_this7 = _possibleConstructorReturn(
-                  this,
-                  (_ref10 =
-                    AbstractView2.__proto__ ||
-                    Object.getPrototypeOf(AbstractView2)).call.apply(
-                    _ref10,
-                    [this].concat(args)
-                  )
-                )),
-                _this7)),
-              (_this7._addFragment = function () {
-                _this7.props.modifySelections(
-                  [].concat(_toConsumableArray(_this7.props.selections), [
-                    _this7._previousSelection || {
-                      kind: "InlineFragment",
-                      typeCondition: {
-                        kind: "NamedType",
-                        name: {
-                          kind: "Name",
-                          value: _this7.props.implementingType.name,
-                        },
-                      },
-                      selectionSet: {
-                        kind: "SelectionSet",
-                        selections: _this7.props
-                          .getDefaultFieldNames(_this7.props.implementingType)
-                          .map(function (fieldName) {
-                            return {
-                              kind: "Field",
-                              name: { kind: "Name", value: fieldName },
-                            };
-                          }),
-                      },
-                    },
-                  ])
-                );
-              }),
-              (_this7._removeFragment = function () {
-                var thisSelection = _this7._getSelection();
-                _this7._previousSelection = thisSelection;
-                _this7.props.modifySelections(
-                  _this7.props.selections.filter(function (s) {
-                    return s !== thisSelection;
-                  })
-                );
-              }),
-              (_this7._getSelection = function () {
-                var selection = _this7.props.selections.find(function (
-                  selection2
-                ) {
-                  return (
-                    selection2.kind === "InlineFragment" &&
-                    selection2.typeCondition &&
-                    _this7.props.implementingType.name ===
-                      selection2.typeCondition.name.value
-                  );
-                });
-                if (!selection) {
-                  return null;
-                }
-                if (selection.kind === "InlineFragment") {
-                  return selection;
-                }
-              }),
-              (_this7._modifyChildSelections = function (selections, options) {
-                var thisSelection = _this7._getSelection();
-                return _this7.props.modifySelections(
-                  _this7.props.selections.map(function (selection) {
-                    if (selection === thisSelection) {
-                      return {
-                        directives: selection.directives,
-                        kind: "InlineFragment",
-                        typeCondition: {
-                          kind: "NamedType",
-                          name: {
-                            kind: "Name",
-                            value: _this7.props.implementingType.name,
-                          },
-                        },
-                        selectionSet: {
-                          kind: "SelectionSet",
-                          selections,
-                        },
-                      };
-                    }
-                    return selection;
-                  }),
-                  options
-                );
-              }),
-              _temp5)),
-            _possibleConstructorReturn(_this7, _ret5)
-          );
-        }
-        _createClass(AbstractView2, [
-          {
-            key: "render",
-            value: function render() {
-              var _this8 = this;
-              var _props5 = this.props,
-                implementingType = _props5.implementingType,
-                schema = _props5.schema,
-                getDefaultFieldNames = _props5.getDefaultFieldNames,
-                styleConfig = _props5.styleConfig;
-              var selection = this._getSelection();
-              var fields = implementingType.getFields();
-              var childSelections = selection
-                ? selection.selectionSet
-                  ? selection.selectionSet.selections
-                  : []
-                : [];
-              return React.createElement(
-                "div",
-                { className: "graphiql-explorer-" + implementingType.name },
-                React.createElement(
-                  "span",
-                  {
-                    style: { cursor: "pointer" },
-                    onClick: selection
-                      ? this._removeFragment
-                      : this._addFragment,
-                  },
-                  React.createElement(Checkbox, {
-                    checked: !!selection,
-                    styleConfig: this.props.styleConfig,
-                  }),
-                  React.createElement(
-                    "span",
-                    { style: { color: styleConfig.colors.atom } },
-                    this.props.implementingType.name
-                  )
-                ),
-                selection
-                  ? React.createElement(
-                      "div",
-                      { style: { marginLeft: 16 } },
-                      Object.keys(fields)
-                        .sort()
-                        .map(function (fieldName) {
-                          return React.createElement(FieldView, {
-                            key: fieldName,
-                            field: fields[fieldName],
-                            selections: childSelections,
-                            modifySelections: _this8._modifyChildSelections,
-                            schema,
-                            getDefaultFieldNames,
-                            getDefaultScalarArgValue:
-                              _this8.props.getDefaultScalarArgValue,
-                            makeDefaultArg: _this8.props.makeDefaultArg,
-                            onRunOperation: _this8.props.onRunOperation,
-                            onCommit: _this8.props.onCommit,
-                            styleConfig: _this8.props.styleConfig,
-                            definition: _this8.props.definition,
-                            availableFragments: _this8.props.availableFragments,
-                          });
-                        })
-                    )
-                  : null
-              );
-            },
-          },
-        ]);
-        return AbstractView2;
-      })(React.PureComponent);
-      var FragmentView = (function (_React$PureComponent6) {
-        _inherits(FragmentView2, _React$PureComponent6);
-        function FragmentView2() {
-          var _ref11;
-          var _temp6, _this9, _ret6;
-          _classCallCheck(this, FragmentView2);
-          for (
-            var _len6 = arguments.length, args = Array(_len6), _key6 = 0;
-            _key6 < _len6;
-            _key6++
-          ) {
-            args[_key6] = arguments[_key6];
-          }
-          return (
-            (_ret6 =
-              ((_temp6 =
-                ((_this9 = _possibleConstructorReturn(
-                  this,
-                  (_ref11 =
-                    FragmentView2.__proto__ ||
-                    Object.getPrototypeOf(FragmentView2)).call.apply(
-                    _ref11,
-                    [this].concat(args)
-                  )
-                )),
-                _this9)),
-              (_this9._addFragment = function () {
-                _this9.props.modifySelections(
-                  [].concat(_toConsumableArray(_this9.props.selections), [
-                    _this9._previousSelection || {
-                      kind: "FragmentSpread",
-                      name: _this9.props.fragment.name,
-                    },
-                  ])
-                );
-              }),
-              (_this9._removeFragment = function () {
-                var thisSelection = _this9._getSelection();
-                _this9._previousSelection = thisSelection;
-                _this9.props.modifySelections(
-                  _this9.props.selections.filter(function (s) {
-                    var isTargetSelection =
-                      s.kind === "FragmentSpread" &&
-                      s.name.value === _this9.props.fragment.name.value;
-                    return !isTargetSelection;
-                  })
-                );
-              }),
-              (_this9._getSelection = function () {
-                var selection = _this9.props.selections.find(function (
-                  selection2
-                ) {
-                  return (
-                    selection2.kind === "FragmentSpread" &&
-                    selection2.name.value === _this9.props.fragment.name.value
-                  );
-                });
-                return selection;
-              }),
-              _temp6)),
-            _possibleConstructorReturn(_this9, _ret6)
-          );
-        }
-        _createClass(FragmentView2, [
-          {
-            key: "render",
-            value: function render() {
-              var styleConfig = this.props.styleConfig;
-              var selection = this._getSelection();
-              return React.createElement(
-                "div",
-                {
-                  className:
-                    "graphiql-explorer-" + this.props.fragment.name.value,
-                },
-                React.createElement(
-                  "span",
-                  {
-                    style: { cursor: "pointer" },
-                    onClick: selection
-                      ? this._removeFragment
-                      : this._addFragment,
-                  },
-                  React.createElement(Checkbox, {
-                    checked: !!selection,
-                    styleConfig: this.props.styleConfig,
-                  }),
-                  React.createElement(
-                    "span",
-                    {
-                      style: { color: styleConfig.colors.def },
-                      className:
-                        "graphiql-explorer-" + this.props.fragment.name.value,
-                    },
-                    this.props.fragment.name.value
-                  )
-                )
-              );
-            },
-          },
-        ]);
-        return FragmentView2;
-      })(React.PureComponent);
-      function defaultInputObjectFields(
-        getDefaultScalarArgValue,
-        makeDefaultArg,
-        parentField,
-        fields
-      ) {
-        var nodes = [];
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = void 0;
-        try {
-          for (
-            var _iterator = fields[Symbol.iterator](), _step;
-            !(_iteratorNormalCompletion = (_step = _iterator.next()).done);
-            _iteratorNormalCompletion = true
-          ) {
-            var _field = _step.value;
-            if (
-              (0, _graphql.isRequiredInputField)(_field) ||
-              (makeDefaultArg && makeDefaultArg(parentField, _field))
-            ) {
-              var fieldType = unwrapInputType(_field.type);
-              if ((0, _graphql.isInputObjectType)(fieldType)) {
-                (function () {
-                  var fields2 = fieldType.getFields();
-                  nodes.push({
-                    kind: "ObjectField",
-                    name: { kind: "Name", value: _field.name },
-                    value: {
-                      kind: "ObjectValue",
-                      fields: defaultInputObjectFields(
-                        getDefaultScalarArgValue,
-                        makeDefaultArg,
-                        parentField,
-                        Object.keys(fields2).map(function (k) {
-                          return fields2[k];
-                        })
-                      ),
-                    },
-                  });
-                })();
-              } else if ((0, _graphql.isLeafType)(fieldType)) {
-                nodes.push({
-                  kind: "ObjectField",
-                  name: { kind: "Name", value: _field.name },
-                  value: getDefaultScalarArgValue(
-                    parentField,
-                    _field,
-                    fieldType
-                  ),
-                });
-              }
-            }
-          }
-        } catch (err) {
-          _didIteratorError = true;
-          _iteratorError = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion && _iterator.return) {
-              _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
-        }
-        return nodes;
-      }
-      function defaultArgs(getDefaultScalarArgValue, makeDefaultArg, field) {
-        var args = [];
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = void 0;
-        try {
-          for (
-            var _iterator2 = field.args[Symbol.iterator](), _step2;
-            !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done);
-            _iteratorNormalCompletion2 = true
-          ) {
-            var _arg = _step2.value;
-            if (
-              isRequiredArgument(_arg) ||
-              (makeDefaultArg && makeDefaultArg(field, _arg))
-            ) {
-              var argType = unwrapInputType(_arg.type);
-              if ((0, _graphql.isInputObjectType)(argType)) {
-                (function () {
-                  var fields = argType.getFields();
-                  args.push({
-                    kind: "Argument",
-                    name: { kind: "Name", value: _arg.name },
-                    value: {
-                      kind: "ObjectValue",
-                      fields: defaultInputObjectFields(
-                        getDefaultScalarArgValue,
-                        makeDefaultArg,
-                        field,
-                        Object.keys(fields).map(function (k) {
-                          return fields[k];
-                        })
-                      ),
-                    },
-                  });
-                })();
-              } else if ((0, _graphql.isLeafType)(argType)) {
-                args.push({
-                  kind: "Argument",
-                  name: { kind: "Name", value: _arg.name },
-                  value: getDefaultScalarArgValue(field, _arg, argType),
-                });
-              }
-            }
-          }
-        } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion2 && _iterator2.return) {
-              _iterator2.return();
-            }
-          } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
-            }
-          }
-        }
-        return args;
-      }
-      var FieldView = (function (_React$PureComponent7) {
-        _inherits(FieldView2, _React$PureComponent7);
-        function FieldView2() {
-          var _ref12;
-          var _temp7, _this10, _ret9;
-          _classCallCheck(this, FieldView2);
-          for (
-            var _len7 = arguments.length, args = Array(_len7), _key7 = 0;
-            _key7 < _len7;
-            _key7++
-          ) {
-            args[_key7] = arguments[_key7];
-          }
-          return (
-            (_ret9 =
-              ((_temp7 =
-                ((_this10 = _possibleConstructorReturn(
-                  this,
-                  (_ref12 =
-                    FieldView2.__proto__ ||
-                    Object.getPrototypeOf(FieldView2)).call.apply(
-                    _ref12,
-                    [this].concat(args)
-                  )
-                )),
-                _this10)),
-              (_this10.state = { displayFieldActions: false }),
-              (_this10._addAllFieldsToSelections = function (rawSubfields) {
-                var subFields = !!rawSubfields
-                  ? Object.keys(rawSubfields).map(function (fieldName) {
-                      return {
-                        kind: "Field",
-                        name: { kind: "Name", value: fieldName },
-                        arguments: [],
-                      };
-                    })
-                  : [];
-                var subSelectionSet = {
-                  kind: "SelectionSet",
-                  selections: subFields,
-                };
-                var nextSelections = [].concat(
-                  _toConsumableArray(
-                    _this10.props.selections.filter(function (selection) {
-                      if (selection.kind === "InlineFragment") {
-                        return true;
-                      } else {
-                        return (
-                          selection.name.value !== _this10.props.field.name
-                        );
-                      }
-                    })
-                  ),
-                  [
-                    {
-                      kind: "Field",
-                      name: { kind: "Name", value: _this10.props.field.name },
-                      arguments: defaultArgs(
-                        _this10.props.getDefaultScalarArgValue,
-                        _this10.props.makeDefaultArg,
-                        _this10.props.field
-                      ),
-                      selectionSet: subSelectionSet,
-                    },
-                  ]
-                );
-                _this10.props.modifySelections(nextSelections);
-              }),
-              (_this10._addFieldToSelections = function (rawSubfields) {
-                var nextSelections = [].concat(
-                  _toConsumableArray(_this10.props.selections),
-                  [
-                    _this10._previousSelection || {
-                      kind: "Field",
-                      name: { kind: "Name", value: _this10.props.field.name },
-                      arguments: defaultArgs(
-                        _this10.props.getDefaultScalarArgValue,
-                        _this10.props.makeDefaultArg,
-                        _this10.props.field
-                      ),
-                    },
-                  ]
-                );
-                _this10.props.modifySelections(nextSelections);
-              }),
-              (_this10._handleUpdateSelections = function (event) {
-                var selection = _this10._getSelection();
-                if (selection && !event.altKey) {
-                  _this10._removeFieldFromSelections();
-                } else {
-                  var fieldType = (0, _graphql.getNamedType)(
-                    _this10.props.field.type
-                  );
-                  var rawSubfields =
-                    (0, _graphql.isObjectType)(fieldType) &&
-                    fieldType.getFields();
-                  var shouldSelectAllSubfields = !!rawSubfields && event.altKey;
-                  shouldSelectAllSubfields
-                    ? _this10._addAllFieldsToSelections(rawSubfields)
-                    : _this10._addFieldToSelections(rawSubfields);
-                }
-              }),
-              (_this10._removeFieldFromSelections = function () {
-                var previousSelection = _this10._getSelection();
-                _this10._previousSelection = previousSelection;
-                _this10.props.modifySelections(
-                  _this10.props.selections.filter(function (selection) {
-                    return selection !== previousSelection;
-                  })
-                );
-              }),
-              (_this10._getSelection = function () {
-                var selection = _this10.props.selections.find(function (
-                  selection2
-                ) {
-                  return (
-                    selection2.kind === "Field" &&
-                    _this10.props.field.name === selection2.name.value
-                  );
-                });
-                if (!selection) {
-                  return null;
-                }
-                if (selection.kind === "Field") {
-                  return selection;
-                }
-              }),
-              (_this10._setArguments = function (argumentNodes, options) {
-                var selection = _this10._getSelection();
-                if (!selection) {
-                  console.error(
-                    "Missing selection when setting arguments",
-                    argumentNodes
-                  );
-                  return;
-                }
-                return _this10.props.modifySelections(
-                  _this10.props.selections.map(function (s) {
-                    return s === selection
-                      ? {
-                          alias: selection.alias,
-                          arguments: argumentNodes,
-                          directives: selection.directives,
-                          kind: "Field",
-                          name: selection.name,
-                          selectionSet: selection.selectionSet,
-                        }
-                      : s;
-                  }),
-                  options
-                );
-              }),
-              (_this10._modifyChildSelections = function (selections, options) {
-                return _this10.props.modifySelections(
-                  _this10.props.selections.map(function (selection) {
-                    if (
-                      selection.kind === "Field" &&
-                      _this10.props.field.name === selection.name.value
-                    ) {
-                      if (selection.kind !== "Field") {
-                        throw new Error("invalid selection");
-                      }
-                      return {
-                        alias: selection.alias,
-                        arguments: selection.arguments,
-                        directives: selection.directives,
-                        kind: "Field",
-                        name: selection.name,
-                        selectionSet: {
-                          kind: "SelectionSet",
-                          selections,
-                        },
-                      };
-                    }
-                    return selection;
-                  }),
-                  options
-                );
-              }),
-              _temp7)),
-            _possibleConstructorReturn(_this10, _ret9)
-          );
-        }
-        _createClass(FieldView2, [
-          {
-            key: "render",
-            value: function render() {
-              var _this11 = this;
-              var _props6 = this.props,
-                field = _props6.field,
-                schema = _props6.schema,
-                getDefaultFieldNames = _props6.getDefaultFieldNames,
-                styleConfig = _props6.styleConfig;
-              var selection = this._getSelection();
-              var type2 = unwrapOutputType(field.type);
-              var args = field.args.sort(function (a, b) {
-                return a.name.localeCompare(b.name);
-              });
-              var className =
-                "graphiql-explorer-node graphiql-explorer-" + field.name;
-              if (field.isDeprecated) {
-                className += " graphiql-explorer-deprecated";
-              }
-              var applicableFragments =
-                (0, _graphql.isObjectType)(type2) ||
-                (0, _graphql.isInterfaceType)(type2) ||
-                (0, _graphql.isUnionType)(type2)
-                  ? this.props.availableFragments &&
-                    this.props.availableFragments[type2.name]
-                  : null;
-              var node = React.createElement(
-                "div",
-                { className },
-                React.createElement(
-                  "span",
-                  {
-                    title: field.description,
-                    style: {
-                      cursor: "pointer",
-                      display: "inline-flex",
-                      alignItems: "center",
-                      minHeight: "16px",
-                      WebkitUserSelect: "none",
-                      userSelect: "none",
-                    },
-                    "data-field-name": field.name,
-                    "data-field-type": type2.name,
-                    onClick: this._handleUpdateSelections,
-                    onMouseEnter: function onMouseEnter() {
-                      var containsMeaningfulSubselection =
-                        (0, _graphql.isObjectType)(type2) &&
-                        selection &&
-                        selection.selectionSet &&
-                        selection.selectionSet.selections.filter(function (
-                          selection2
-                        ) {
-                          return selection2.kind !== "FragmentSpread";
-                        }).length > 0;
-                      if (containsMeaningfulSubselection) {
-                        _this11.setState({ displayFieldActions: true });
-                      }
-                    },
-                    onMouseLeave: function onMouseLeave() {
-                      return _this11.setState({ displayFieldActions: false });
-                    },
-                  },
-                  (0, _graphql.isObjectType)(type2)
-                    ? React.createElement(
-                        "span",
-                        null,
-                        !!selection
-                          ? this.props.styleConfig.arrowOpen
-                          : this.props.styleConfig.arrowClosed
-                      )
-                    : null,
-                  (0, _graphql.isObjectType)(type2)
-                    ? null
-                    : React.createElement(Checkbox, {
-                        checked: !!selection,
-                        styleConfig: this.props.styleConfig,
-                      }),
-                  React.createElement(
-                    "span",
-                    {
-                      style: { color: styleConfig.colors.property },
-                      className: "graphiql-explorer-field-view",
-                    },
-                    field.name
-                  ),
-                  !this.state.displayFieldActions
-                    ? null
-                    : React.createElement(
-                        "button",
-                        {
-                          type: "submit",
-                          className: "toolbar-button",
-                          title:
-                            "Extract selections into a new reusable fragment",
-                          onClick: function onClick(event) {
-                            event.preventDefault();
-                            event.stopPropagation();
-                            var typeName = type2.name;
-                            var newFragmentName = typeName + "Fragment";
-                            var conflictingNameCount = (
-                              applicableFragments || []
-                            ).filter(function (fragment) {
-                              return fragment.name.value.startsWith(
-                                newFragmentName
-                              );
-                            }).length;
-                            if (conflictingNameCount > 0) {
-                              newFragmentName =
-                                "" + newFragmentName + conflictingNameCount;
-                            }
-                            var childSelections2 = selection
-                              ? selection.selectionSet
-                                ? selection.selectionSet.selections
-                                : []
-                              : [];
-                            var nextSelections = [
-                              {
-                                kind: "FragmentSpread",
-                                name: {
-                                  kind: "Name",
-                                  value: newFragmentName,
-                                },
-                                directives: [],
-                              },
-                            ];
-                            var newFragmentDefinition = {
-                              kind: "FragmentDefinition",
-                              name: {
-                                kind: "Name",
-                                value: newFragmentName,
-                              },
-                              typeCondition: {
-                                kind: "NamedType",
-                                name: {
-                                  kind: "Name",
-                                  value: type2.name,
-                                },
-                              },
-                              directives: [],
-                              selectionSet: {
-                                kind: "SelectionSet",
-                                selections: childSelections2,
-                              },
-                            };
-                            var newDoc = _this11._modifyChildSelections(
-                              nextSelections,
-                              false
-                            );
-                            if (newDoc) {
-                              var newDocWithFragment = _extends({}, newDoc, {
-                                definitions: [].concat(
-                                  _toConsumableArray(newDoc.definitions),
-                                  [newFragmentDefinition]
-                                ),
-                              });
-                              _this11.props.onCommit(newDocWithFragment);
-                            } else {
-                              console.warn(
-                                "Unable to complete extractFragment operation"
-                              );
-                            }
-                          },
-                          style: _extends(
-                            {},
-                            styleConfig.styles.actionButtonStyle
-                          ),
-                        },
-                        React.createElement("span", null, "\u2026")
-                      )
-                ),
-                selection && args.length
-                  ? React.createElement(
-                      "div",
-                      {
-                        style: { marginLeft: 16 },
-                        className: "graphiql-explorer-graphql-arguments",
-                      },
-                      args.map(function (arg) {
-                        return React.createElement(ArgView, {
-                          key: arg.name,
-                          parentField: field,
-                          arg,
-                          selection,
-                          modifyArguments: _this11._setArguments,
-                          getDefaultScalarArgValue:
-                            _this11.props.getDefaultScalarArgValue,
-                          makeDefaultArg: _this11.props.makeDefaultArg,
-                          onRunOperation: _this11.props.onRunOperation,
-                          styleConfig: _this11.props.styleConfig,
-                          onCommit: _this11.props.onCommit,
-                          definition: _this11.props.definition,
-                        });
-                      })
-                    )
-                  : null
-              );
-              if (
-                selection &&
-                ((0, _graphql.isObjectType)(type2) ||
-                  (0, _graphql.isInterfaceType)(type2) ||
-                  (0, _graphql.isUnionType)(type2))
-              ) {
-                var _fields4 = (0, _graphql.isUnionType)(type2)
-                  ? {}
-                  : type2.getFields();
-                var childSelections = selection
-                  ? selection.selectionSet
-                    ? selection.selectionSet.selections
-                    : []
-                  : [];
-                return React.createElement(
-                  "div",
-                  { className: "graphiql-explorer-" + field.name },
-                  node,
-                  React.createElement(
-                    "div",
-                    { style: { marginLeft: 16 } },
-                    !!applicableFragments
-                      ? applicableFragments.map(function (fragment) {
-                          var type3 = schema.getType(
-                            fragment.typeCondition.name.value
-                          );
-                          var fragmentName = fragment.name.value;
-                          return !type3
-                            ? null
-                            : React.createElement(FragmentView, {
-                                key: fragmentName,
-                                fragment,
-                                selections: childSelections,
-                                modifySelections:
-                                  _this11._modifyChildSelections,
-                                schema,
-                                styleConfig: _this11.props.styleConfig,
-                                onCommit: _this11.props.onCommit,
-                              });
-                        })
-                      : null,
-                    Object.keys(_fields4)
-                      .sort()
-                      .map(function (fieldName) {
-                        return React.createElement(FieldView2, {
-                          key: fieldName,
-                          field: _fields4[fieldName],
-                          selections: childSelections,
-                          modifySelections: _this11._modifyChildSelections,
-                          schema,
-                          getDefaultFieldNames,
-                          getDefaultScalarArgValue:
-                            _this11.props.getDefaultScalarArgValue,
-                          makeDefaultArg: _this11.props.makeDefaultArg,
-                          onRunOperation: _this11.props.onRunOperation,
-                          styleConfig: _this11.props.styleConfig,
-                          onCommit: _this11.props.onCommit,
-                          definition: _this11.props.definition,
-                          availableFragments: _this11.props.availableFragments,
-                        });
-                      }),
-                    (0, _graphql.isInterfaceType)(type2) ||
-                      (0, _graphql.isUnionType)(type2)
-                      ? schema.getPossibleTypes(type2).map(function (type3) {
-                          return React.createElement(AbstractView, {
-                            key: type3.name,
-                            implementingType: type3,
-                            selections: childSelections,
-                            modifySelections: _this11._modifyChildSelections,
-                            schema,
-                            getDefaultFieldNames,
-                            getDefaultScalarArgValue:
-                              _this11.props.getDefaultScalarArgValue,
-                            makeDefaultArg: _this11.props.makeDefaultArg,
-                            onRunOperation: _this11.props.onRunOperation,
-                            styleConfig: _this11.props.styleConfig,
-                            onCommit: _this11.props.onCommit,
-                            definition: _this11.props.definition,
-                          });
-                        })
-                      : null
-                  )
-                );
-              }
-              return node;
-            },
-          },
-        ]);
-        return FieldView2;
-      })(React.PureComponent);
-      function parseQuery(text3) {
-        try {
-          if (!text3.trim()) {
-            return null;
-          }
-          return (0, _graphql.parse)(text3, { noLocation: true });
-        } catch (e) {
-          return new Error(e);
-        }
-      }
-      var DEFAULT_OPERATION = {
-        kind: "OperationDefinition",
-        operation: "query",
-        variableDefinitions: [],
-        name: { kind: "Name", value: "MyQuery" },
-        directives: [],
-        selectionSet: {
-          kind: "SelectionSet",
-          selections: [],
-        },
-      };
-      var DEFAULT_DOCUMENT = {
-        kind: "Document",
-        definitions: [DEFAULT_OPERATION],
-      };
-      var parseQueryMemoize = null;
-      function memoizeParseQuery(query) {
-        if (parseQueryMemoize && parseQueryMemoize[0] === query) {
-          return parseQueryMemoize[1];
-        } else {
-          var result2 = parseQuery(query);
-          if (!result2) {
-            return DEFAULT_DOCUMENT;
-          } else if (result2 instanceof Error) {
-            if (parseQueryMemoize) {
-              return parseQueryMemoize[1];
-            } else {
-              return DEFAULT_DOCUMENT;
-            }
-          } else {
-            parseQueryMemoize = [query, result2];
-            return result2;
-          }
-        }
-      }
-      var defaultStyles = {
-        buttonStyle: {
-          fontSize: "1.2em",
-          padding: "0px",
-          backgroundColor: "white",
-          border: "none",
-          margin: "5px 0px",
-          height: "40px",
-          width: "100%",
-          display: "block",
-          maxWidth: "none",
-        },
-        actionButtonStyle: {
-          padding: "0px",
-          backgroundColor: "white",
-          border: "none",
-          margin: "0px",
-          maxWidth: "none",
-          height: "15px",
-          width: "15px",
-          display: "inline-block",
-          fontSize: "smaller",
-        },
-        explorerActionsStyle: {
-          margin: "4px -8px -8px",
-          paddingLeft: "8px",
-          bottom: "0px",
-          width: "100%",
-          textAlign: "center",
-          background: "none",
-          borderTop: "none",
-          borderBottom: "none",
-        },
-      };
-      var RootView = (function (_React$PureComponent8) {
-        _inherits(RootView2, _React$PureComponent8);
-        function RootView2() {
-          var _ref13;
-          var _temp8, _this12, _ret10;
-          _classCallCheck(this, RootView2);
-          for (
-            var _len8 = arguments.length, args = Array(_len8), _key8 = 0;
-            _key8 < _len8;
-            _key8++
-          ) {
-            args[_key8] = arguments[_key8];
-          }
-          return (
-            (_ret10 =
-              ((_temp8 =
-                ((_this12 = _possibleConstructorReturn(
-                  this,
-                  (_ref13 =
-                    RootView2.__proto__ ||
-                    Object.getPrototypeOf(RootView2)).call.apply(
-                    _ref13,
-                    [this].concat(args)
-                  )
-                )),
-                _this12)),
-              (_this12.state = {
-                newOperationType: "query",
-                displayTitleActions: false,
-              }),
-              (_this12._modifySelections = function (selections, options) {
-                var operationDef = _this12.props.definition;
-                if (
-                  operationDef.selectionSet.selections.length === 0 &&
-                  _this12._previousOperationDef
-                ) {
-                  operationDef = _this12._previousOperationDef;
-                }
-                var newOperationDef = void 0;
-                if (operationDef.kind === "FragmentDefinition") {
-                  newOperationDef = _extends({}, operationDef, {
-                    selectionSet: _extends({}, operationDef.selectionSet, {
-                      selections,
-                    }),
-                  });
-                } else if (operationDef.kind === "OperationDefinition") {
-                  var cleanedSelections = selections.filter(function (
-                    selection
-                  ) {
-                    return !(
-                      selection.kind === "Field" &&
-                      selection.name.value === "__typename"
-                    );
-                  });
-                  if (cleanedSelections.length === 0) {
-                    cleanedSelections = [
-                      {
-                        kind: "Field",
-                        name: {
-                          kind: "Name",
-                          value: "__typename ## Placeholder value",
-                        },
-                      },
-                    ];
-                  }
-                  newOperationDef = _extends({}, operationDef, {
-                    selectionSet: _extends({}, operationDef.selectionSet, {
-                      selections: cleanedSelections,
-                    }),
-                  });
-                }
-                return _this12.props.onEdit(newOperationDef, options);
-              }),
-              (_this12._onOperationRename = function (event) {
-                return _this12.props.onOperationRename(event.target.value);
-              }),
-              (_this12._handlePotentialRun = function (event) {
-                if (
-                  isRunShortcut(event) &&
-                  canRunOperation(_this12.props.definition.kind)
-                ) {
-                  _this12.props.onRunOperation(_this12.props.name);
-                }
-              }),
-              (_this12._rootViewElId = function () {
-                var _this12$props = _this12.props,
-                  operationType = _this12$props.operationType,
-                  name2 = _this12$props.name;
-                var rootViewElId = operationType + "-" + (name2 || "unknown");
-                return rootViewElId;
-              }),
-              _temp8)),
-            _possibleConstructorReturn(_this12, _ret10)
-          );
-        }
-        _createClass(RootView2, [
-          {
-            key: "componentDidMount",
-            value: function componentDidMount() {
-              var rootViewElId = this._rootViewElId();
-              this.props.onMount(rootViewElId);
-            },
-          },
-          {
-            key: "render",
-            value: function render() {
-              var _this13 = this;
-              var _props7 = this.props,
-                operationType = _props7.operationType,
-                definition = _props7.definition,
-                schema = _props7.schema,
-                getDefaultFieldNames = _props7.getDefaultFieldNames,
-                styleConfig = _props7.styleConfig;
-              var rootViewElId = this._rootViewElId();
-              var fields = this.props.fields || {};
-              var operationDef = definition;
-              var selections = operationDef.selectionSet.selections;
-              var operationDisplayName =
-                this.props.name || capitalize(operationType) + " Name";
-              return React.createElement(
-                "div",
-                {
-                  id: rootViewElId,
-                  tabIndex: "0",
-                  onKeyDown: this._handlePotentialRun,
-                  style: {
-                    borderBottom: this.props.isLast
-                      ? "none"
-                      : "1px solid #d6d6d6",
-                    marginBottom: "0em",
-                    paddingBottom: "1em",
-                  },
-                },
-                React.createElement(
-                  "div",
-                  {
-                    style: {
-                      color: styleConfig.colors.keyword,
-                      paddingBottom: 4,
-                    },
-                    className: "graphiql-operation-title-bar",
-                    onMouseEnter: function onMouseEnter() {
-                      return _this13.setState({ displayTitleActions: true });
-                    },
-                    onMouseLeave: function onMouseLeave() {
-                      return _this13.setState({ displayTitleActions: false });
-                    },
-                  },
-                  operationType,
-                  " ",
-                  React.createElement(
-                    "span",
-                    { style: { color: styleConfig.colors.def } },
-                    React.createElement("input", {
-                      style: {
-                        color: styleConfig.colors.def,
-                        border: "none",
-                        borderBottom: "1px solid #888",
-                        outline: "none",
-                        width: Math.max(4, operationDisplayName.length) + "ch",
-                      },
-                      autoComplete: "false",
-                      placeholder: capitalize(operationType) + " Name",
-                      value: this.props.name,
-                      onKeyDown: this._handlePotentialRun,
-                      onChange: this._onOperationRename,
-                    })
-                  ),
-                  !!this.props.onTypeName
-                    ? React.createElement(
-                        "span",
-                        null,
-                        React.createElement("br", null),
-                        "on " + this.props.onTypeName
-                      )
-                    : "",
-                  !!this.state.displayTitleActions
-                    ? React.createElement(
-                        React.Fragment,
-                        null,
-                        React.createElement(
-                          "button",
-                          {
-                            type: "submit",
-                            className: "toolbar-button",
-                            onClick: function onClick() {
-                              return _this13.props.onOperationDestroy();
-                            },
-                            style: _extends(
-                              {},
-                              styleConfig.styles.actionButtonStyle
-                            ),
-                          },
-                          React.createElement("span", null, "\u2715")
-                        ),
-                        React.createElement(
-                          "button",
-                          {
-                            type: "submit",
-                            className: "toolbar-button",
-                            onClick: function onClick() {
-                              return _this13.props.onOperationClone();
-                            },
-                            style: _extends(
-                              {},
-                              styleConfig.styles.actionButtonStyle
-                            ),
-                          },
-                          React.createElement("span", null, "\u2398")
-                        )
-                      )
-                    : ""
-                ),
-                Object.keys(fields)
-                  .sort()
-                  .map(function (fieldName) {
-                    return React.createElement(FieldView, {
-                      key: fieldName,
-                      field: fields[fieldName],
-                      selections,
-                      modifySelections: _this13._modifySelections,
-                      schema,
-                      getDefaultFieldNames,
-                      getDefaultScalarArgValue:
-                        _this13.props.getDefaultScalarArgValue,
-                      makeDefaultArg: _this13.props.makeDefaultArg,
-                      onRunOperation: _this13.props.onRunOperation,
-                      styleConfig: _this13.props.styleConfig,
-                      onCommit: _this13.props.onCommit,
-                      definition: _this13.props.definition,
-                      availableFragments: _this13.props.availableFragments,
-                    });
-                  })
-              );
-            },
-          },
-        ]);
-        return RootView2;
-      })(React.PureComponent);
-      function Attribution() {
-        return React.createElement(
-          "div",
-          {
-            style: {
-              fontFamily: "sans-serif",
-              display: "flex",
-              flexDirection: "column",
-              alignItems: "center",
-              margin: "1em",
-              marginTop: 0,
-              flexGrow: 1,
-              justifyContent: "flex-end",
-            },
-          },
-          React.createElement(
-            "div",
-            {
-              style: {
-                borderTop: "1px solid #d6d6d6",
-                paddingTop: "1em",
-                width: "100%",
-                textAlign: "center",
-              },
-            },
-            "GraphiQL Explorer by ",
-            React.createElement(
-              "a",
-              { href: "https://www.onegraph.com" },
-              "OneGraph"
-            )
-          ),
-          React.createElement(
-            "div",
-            null,
-            "Contribute on",
-            " ",
-            React.createElement(
-              "a",
-              { href: "https://github.com/OneGraph/graphiql-explorer" },
-              "GitHub"
-            )
-          )
-        );
-      }
-      var Explorer = (function (_React$PureComponent9) {
-        _inherits(Explorer2, _React$PureComponent9);
-        function Explorer2() {
-          var _ref14;
-          var _temp9, _this14, _ret11;
-          _classCallCheck(this, Explorer2);
-          for (
-            var _len9 = arguments.length, args = Array(_len9), _key9 = 0;
-            _key9 < _len9;
-            _key9++
-          ) {
-            args[_key9] = arguments[_key9];
-          }
-          return (
-            (_ret11 =
-              ((_temp9 =
-                ((_this14 = _possibleConstructorReturn(
-                  this,
-                  (_ref14 =
-                    Explorer2.__proto__ ||
-                    Object.getPrototypeOf(Explorer2)).call.apply(
-                    _ref14,
-                    [this].concat(args)
-                  )
-                )),
-                _this14)),
-              (_this14.state = {
-                newOperationType: "query",
-                operation: null,
-                operationToScrollTo: null,
-              }),
-              (_this14._resetScroll = function () {
-                var container = _this14._ref;
-                if (container) {
-                  container.scrollLeft = 0;
-                }
-              }),
-              (_this14._onEdit = function (query) {
-                return _this14.props.onEdit(query);
-              }),
-              (_this14._setAddOperationType = function (value) {
-                _this14.setState({ newOperationType: value });
-              }),
-              (_this14._handleRootViewMount = function (rootViewElId) {
-                if (
-                  !!_this14.state.operationToScrollTo &&
-                  _this14.state.operationToScrollTo === rootViewElId
-                ) {
-                  var selector = ".graphiql-explorer-root #" + rootViewElId;
-                  var el2 = document.querySelector(selector);
-                  el2 && el2.scrollIntoView();
-                }
-              }),
-              _temp9)),
-            _possibleConstructorReturn(_this14, _ret11)
-          );
-        }
-        _createClass(Explorer2, [
-          {
-            key: "componentDidMount",
-            value: function componentDidMount() {
-              this._resetScroll();
-            },
-          },
-          {
-            key: "render",
-            value: function render() {
-              var _this15 = this;
-              var _props8 = this.props,
-                schema = _props8.schema,
-                query = _props8.query,
-                makeDefaultArg = _props8.makeDefaultArg;
-              if (!schema) {
-                return React.createElement(
-                  "div",
-                  {
-                    style: { fontFamily: "sans-serif" },
-                    className: "error-container",
-                  },
-                  "No Schema Available"
-                );
-              }
-              var styleConfig = {
-                colors: this.props.colors || defaultColors,
-                checkboxChecked:
-                  this.props.checkboxChecked || defaultCheckboxChecked,
-                checkboxUnchecked:
-                  this.props.checkboxUnchecked || defaultCheckboxUnchecked,
-                arrowClosed: this.props.arrowClosed || defaultArrowClosed,
-                arrowOpen: this.props.arrowOpen || defaultArrowOpen,
-                styles: this.props.styles
-                  ? _extends({}, defaultStyles, this.props.styles)
-                  : defaultStyles,
-              };
-              var queryType = schema.getQueryType();
-              var mutationType = schema.getMutationType();
-              var subscriptionType = schema.getSubscriptionType();
-              if (!queryType && !mutationType && !subscriptionType) {
-                return React.createElement("div", null, "Missing query type");
-              }
-              var queryFields = queryType && queryType.getFields();
-              var mutationFields = mutationType && mutationType.getFields();
-              var subscriptionFields =
-                subscriptionType && subscriptionType.getFields();
-              var parsedQuery = memoizeParseQuery(query);
-              var getDefaultFieldNames =
-                this.props.getDefaultFieldNames || defaultGetDefaultFieldNames;
-              var getDefaultScalarArgValue =
-                this.props.getDefaultScalarArgValue ||
-                defaultGetDefaultScalarArgValue;
-              var definitions = parsedQuery.definitions;
-              var _relevantOperations = definitions
-                .map(function (definition) {
-                  if (definition.kind === "FragmentDefinition") {
-                    return definition;
-                  } else if (definition.kind === "OperationDefinition") {
-                    return definition;
-                  } else {
-                    return null;
-                  }
-                })
-                .filter(Boolean);
-              var relevantOperations =
-                _relevantOperations.length === 0
-                  ? DEFAULT_DOCUMENT.definitions
-                  : _relevantOperations;
-              var renameOperation = function renameOperation2(
-                targetOperation,
-                name2
-              ) {
-                var newName =
-                  name2 == null || name2 === ""
-                    ? null
-                    : { kind: "Name", value: name2, loc: void 0 };
-                var newOperation = _extends({}, targetOperation, {
-                  name: newName,
-                });
-                var existingDefs = parsedQuery.definitions;
-                var newDefinitions = existingDefs.map(function (
-                  existingOperation
-                ) {
-                  if (targetOperation === existingOperation) {
-                    return newOperation;
-                  } else {
-                    return existingOperation;
-                  }
-                });
-                return _extends({}, parsedQuery, {
-                  definitions: newDefinitions,
-                });
-              };
-              var cloneOperation = function cloneOperation2(targetOperation) {
-                var kind2 = void 0;
-                if (targetOperation.kind === "FragmentDefinition") {
-                  kind2 = "fragment";
-                } else {
-                  kind2 = targetOperation.operation;
-                }
-                var newOperationName =
-                  ((targetOperation.name && targetOperation.name.value) || "") +
-                  "Copy";
-                var newName = {
-                  kind: "Name",
-                  value: newOperationName,
-                  loc: void 0,
-                };
-                var newOperation = _extends({}, targetOperation, {
-                  name: newName,
-                });
-                var existingDefs = parsedQuery.definitions;
-                var newDefinitions = [].concat(
-                  _toConsumableArray(existingDefs),
-                  [newOperation]
-                );
-                _this15.setState({
-                  operationToScrollTo: kind2 + "-" + newOperationName,
-                });
-                return _extends({}, parsedQuery, {
-                  definitions: newDefinitions,
-                });
-              };
-              var destroyOperation = function destroyOperation2(
-                targetOperation
-              ) {
-                var existingDefs = parsedQuery.definitions;
-                var newDefinitions = existingDefs.filter(function (
-                  existingOperation
-                ) {
-                  if (targetOperation === existingOperation) {
-                    return false;
-                  } else {
-                    return true;
-                  }
-                });
-                return _extends({}, parsedQuery, {
-                  definitions: newDefinitions,
-                });
-              };
-              var addOperation = function addOperation2(kind2) {
-                var existingDefs = parsedQuery.definitions;
-                var viewingDefaultOperation =
-                  parsedQuery.definitions.length === 1 &&
-                  parsedQuery.definitions[0] ===
-                    DEFAULT_DOCUMENT.definitions[0];
-                var MySiblingDefs = viewingDefaultOperation
-                  ? []
-                  : existingDefs.filter(function (def) {
-                      if (def.kind === "OperationDefinition") {
-                        return def.operation === kind2;
-                      } else {
-                        return false;
-                      }
-                    });
-                var newOperationName =
-                  "My" +
-                  capitalize(kind2) +
-                  (MySiblingDefs.length === 0 ? "" : MySiblingDefs.length + 1);
-                var firstFieldName = "__typename # Placeholder value";
-                var selectionSet = {
-                  kind: "SelectionSet",
-                  selections: [
-                    {
-                      kind: "Field",
-                      name: {
-                        kind: "Name",
-                        value: firstFieldName,
-                        loc: null,
-                      },
-                      arguments: [],
-                      directives: [],
-                      selectionSet: null,
-                      loc: null,
-                    },
-                  ],
-                  loc: null,
-                };
-                var newDefinition = {
-                  kind: "OperationDefinition",
-                  operation: kind2,
-                  name: { kind: "Name", value: newOperationName },
-                  variableDefinitions: [],
-                  directives: [],
-                  selectionSet,
-                  loc: null,
-                };
-                var newDefinitions = viewingDefaultOperation
-                  ? [newDefinition]
-                  : [].concat(_toConsumableArray(parsedQuery.definitions), [
-                      newDefinition,
-                    ]);
-                var newOperationDef = _extends({}, parsedQuery, {
-                  definitions: newDefinitions,
-                });
-                _this15.setState({
-                  operationToScrollTo: kind2 + "-" + newOperationName,
-                });
-                _this15.props.onEdit((0, _graphql.print)(newOperationDef));
-              };
-              var actionsOptions = [
-                !!queryFields
-                  ? React.createElement(
-                      "option",
-                      {
-                        key: "query",
-                        className: "toolbar-button",
-                        style: styleConfig.styles.buttonStyle,
-                        type: "link",
-                        value: "query",
-                      },
-                      "Query"
-                    )
-                  : null,
-                !!mutationFields
-                  ? React.createElement(
-                      "option",
-                      {
-                        key: "mutation",
-                        className: "toolbar-button",
-                        style: styleConfig.styles.buttonStyle,
-                        type: "link",
-                        value: "mutation",
-                      },
-                      "Mutation"
-                    )
-                  : null,
-                !!subscriptionFields
-                  ? React.createElement(
-                      "option",
-                      {
-                        key: "subscription",
-                        className: "toolbar-button",
-                        style: styleConfig.styles.buttonStyle,
-                        type: "link",
-                        value: "subscription",
-                      },
-                      "Subscription"
-                    )
-                  : null,
-              ].filter(Boolean);
-              var actionsEl =
-                actionsOptions.length === 0 || this.props.hideActions
-                  ? null
-                  : React.createElement(
-                      "div",
-                      {
-                        style: {
-                          minHeight: "50px",
-                          maxHeight: "50px",
-                          overflow: "none",
-                        },
-                      },
-                      React.createElement(
-                        "form",
-                        {
-                          className:
-                            "variable-editor-title graphiql-explorer-actions",
-                          style: _extends(
-                            {},
-                            styleConfig.styles.explorerActionsStyle,
-                            {
-                              display: "flex",
-                              flexDirection: "row",
-                              alignItems: "center",
-                              borderTop: "1px solid rgb(214, 214, 214)",
-                            }
-                          ),
-                          onSubmit: function onSubmit(event) {
-                            return event.preventDefault();
-                          },
-                        },
-                        React.createElement(
-                          "span",
-                          {
-                            style: {
-                              display: "inline-block",
-                              flexGrow: "0",
-                              textAlign: "right",
-                            },
-                          },
-                          "Add new",
-                          " "
-                        ),
-                        React.createElement(
-                          "select",
-                          {
-                            onChange: function onChange(event) {
-                              return _this15._setAddOperationType(
-                                event.target.value
-                              );
-                            },
-                            value: this.state.newOperationType,
-                            style: { flexGrow: "2" },
-                          },
-                          actionsOptions
-                        ),
-                        React.createElement(
-                          "button",
-                          {
-                            type: "submit",
-                            className: "toolbar-button",
-                            onClick: function onClick() {
-                              return _this15.state.newOperationType
-                                ? addOperation(_this15.state.newOperationType)
-                                : null;
-                            },
-                            style: _extends(
-                              {},
-                              styleConfig.styles.buttonStyle,
-                              {
-                                height: "22px",
-                                width: "22px",
-                              }
-                            ),
-                          },
-                          React.createElement("span", null, "+")
-                        )
-                      )
-                    );
-              var externalFragments =
-                this.props.externalFragments &&
-                this.props.externalFragments.reduce(function (acc, fragment) {
-                  if (fragment.kind === "FragmentDefinition") {
-                    var fragmentTypeName = fragment.typeCondition.name.value;
-                    var existingFragmentsForType = acc[fragmentTypeName] || [];
-                    var newFragmentsForType = []
-                      .concat(_toConsumableArray(existingFragmentsForType), [
-                        fragment,
-                      ])
-                      .sort(function (a, b) {
-                        return a.name.value.localeCompare(b.name.value);
-                      });
-                    return _extends(
-                      {},
-                      acc,
-                      _defineProperty({}, fragmentTypeName, newFragmentsForType)
-                    );
-                  }
-                  return acc;
-                }, {});
-              var documentFragments = relevantOperations.reduce(function (
-                acc,
-                operation
-              ) {
-                if (operation.kind === "FragmentDefinition") {
-                  var fragmentTypeName = operation.typeCondition.name.value;
-                  var existingFragmentsForType = acc[fragmentTypeName] || [];
-                  var newFragmentsForType = []
-                    .concat(_toConsumableArray(existingFragmentsForType), [
-                      operation,
-                    ])
-                    .sort(function (a, b) {
-                      return a.name.value.localeCompare(b.name.value);
-                    });
-                  return _extends(
-                    {},
-                    acc,
-                    _defineProperty({}, fragmentTypeName, newFragmentsForType)
-                  );
-                }
-                return acc;
-              },
-              {});
-              var availableFragments = _extends(
-                {},
-                documentFragments,
-                externalFragments
-              );
-              var attribution = this.props.showAttribution
-                ? React.createElement(Attribution, null)
-                : null;
-              return React.createElement(
-                "div",
-                {
-                  ref: function ref(_ref15) {
-                    _this15._ref = _ref15;
-                  },
-                  style: {
-                    fontSize: 12,
-                    textOverflow: "ellipsis",
-                    whiteSpace: "nowrap",
-                    margin: 0,
-                    padding: 8,
-                    fontFamily:
-                      'Consolas, Inconsolata, "Droid Sans Mono", Monaco, monospace',
-                    display: "flex",
-                    flexDirection: "column",
-                    height: "100%",
-                  },
-                  className: "graphiql-explorer-root",
-                },
-                React.createElement(
-                  "div",
-                  {
-                    style: {
-                      flexGrow: "1",
-                      overflow: "scroll",
-                    },
-                  },
-                  relevantOperations.map(function (operation, index) {
-                    var operationName =
-                      operation && operation.name && operation.name.value;
-                    var operationType =
-                      operation.kind === "FragmentDefinition"
-                        ? "fragment"
-                        : (operation && operation.operation) || "query";
-                    var onOperationRename = function onOperationRename2(
-                      newName
-                    ) {
-                      var newOperationDef = renameOperation(operation, newName);
-                      _this15.props.onEdit(
-                        (0, _graphql.print)(newOperationDef)
-                      );
-                    };
-                    var onOperationClone = function onOperationClone2() {
-                      var newOperationDef = cloneOperation(operation);
-                      _this15.props.onEdit(
-                        (0, _graphql.print)(newOperationDef)
-                      );
-                    };
-                    var onOperationDestroy = function onOperationDestroy2() {
-                      var newOperationDef = destroyOperation(operation);
-                      _this15.props.onEdit(
-                        (0, _graphql.print)(newOperationDef)
-                      );
-                    };
-                    var fragmentType =
-                      operation.kind === "FragmentDefinition" &&
-                      operation.typeCondition.kind === "NamedType" &&
-                      schema.getType(operation.typeCondition.name.value);
-                    var fragmentFields =
-                      fragmentType instanceof _graphql.GraphQLObjectType
-                        ? fragmentType.getFields()
-                        : null;
-                    var fields =
-                      operationType === "query"
-                        ? queryFields
-                        : operationType === "mutation"
-                        ? mutationFields
-                        : operationType === "subscription"
-                        ? subscriptionFields
-                        : operation.kind === "FragmentDefinition"
-                        ? fragmentFields
-                        : null;
-                    var fragmentTypeName =
-                      operation.kind === "FragmentDefinition"
-                        ? operation.typeCondition.name.value
-                        : null;
-                    var onCommit = function onCommit2(parsedDocument) {
-                      var textualNewDocument = (0, _graphql.print)(
-                        parsedDocument
-                      );
-                      _this15.props.onEdit(textualNewDocument);
-                    };
-                    return React.createElement(RootView, {
-                      key: index,
-                      isLast: index === relevantOperations.length - 1,
-                      fields,
-                      operationType,
-                      name: operationName,
-                      definition: operation,
-                      onOperationRename,
-                      onOperationDestroy,
-                      onOperationClone,
-                      onTypeName: fragmentTypeName,
-                      onMount: _this15._handleRootViewMount,
-                      onCommit,
-                      onEdit: function onEdit(newDefinition, options) {
-                        var commit = void 0;
-                        if (
-                          (typeof options === "undefined"
-                            ? "undefined"
-                            : _typeof(options)) === "object" &&
-                          typeof options.commit !== "undefined"
-                        ) {
-                          commit = options.commit;
-                        } else {
-                          commit = true;
-                        }
-                        if (!!newDefinition) {
-                          var newQuery = _extends({}, parsedQuery, {
-                            definitions: parsedQuery.definitions.map(function (
-                              existingDefinition
-                            ) {
-                              return existingDefinition === operation
-                                ? newDefinition
-                                : existingDefinition;
-                            }),
-                          });
-                          if (commit) {
-                            onCommit(newQuery);
-                            return newQuery;
-                          } else {
-                            return newQuery;
-                          }
-                        } else {
-                          return parsedQuery;
-                        }
-                      },
-                      schema,
-                      getDefaultFieldNames,
-                      getDefaultScalarArgValue,
-                      makeDefaultArg,
-                      onRunOperation: function onRunOperation() {
-                        if (!!_this15.props.onRunOperation) {
-                          _this15.props.onRunOperation(operationName);
-                        }
-                      },
-                      styleConfig,
-                      availableFragments,
-                    });
-                  }),
-                  attribution
-                ),
-                actionsEl
-              );
-            },
-          },
-        ]);
-        return Explorer2;
-      })(React.PureComponent);
-      Explorer.defaultProps = {
-        getDefaultFieldNames: defaultGetDefaultFieldNames,
-        getDefaultScalarArgValue: defaultGetDefaultScalarArgValue,
-      };
-      var ErrorBoundary = (function (_React$Component) {
-        _inherits(ErrorBoundary2, _React$Component);
-        function ErrorBoundary2() {
-          var _ref16;
-          var _temp10, _this16, _ret12;
-          _classCallCheck(this, ErrorBoundary2);
-          for (
-            var _len10 = arguments.length, args = Array(_len10), _key10 = 0;
-            _key10 < _len10;
-            _key10++
-          ) {
-            args[_key10] = arguments[_key10];
-          }
-          return (
-            (_ret12 =
-              ((_temp10 =
-                ((_this16 = _possibleConstructorReturn(
-                  this,
-                  (_ref16 =
-                    ErrorBoundary2.__proto__ ||
-                    Object.getPrototypeOf(ErrorBoundary2)).call.apply(
-                    _ref16,
-                    [this].concat(args)
-                  )
-                )),
-                _this16)),
-              (_this16.state = {
-                hasError: false,
-                error: null,
-                errorInfo: null,
-              }),
-              _temp10)),
-            _possibleConstructorReturn(_this16, _ret12)
-          );
-        }
-        _createClass(ErrorBoundary2, [
-          {
-            key: "componentDidCatch",
-            value: function componentDidCatch(error2, errorInfo) {
-              this.setState({ hasError: true, error: error2, errorInfo });
-              console.error("Error in component", error2, errorInfo);
-            },
-          },
-          {
-            key: "render",
-            value: function render() {
-              if (this.state.hasError) {
-                return React.createElement(
-                  "div",
-                  { style: { padding: 18, fontFamily: "sans-serif" } },
-                  React.createElement("div", null, "Something went wrong"),
-                  React.createElement(
-                    "details",
-                    { style: { whiteSpace: "pre-wrap" } },
-                    this.state.error ? this.state.error.toString() : null,
-                    React.createElement("br", null),
-                    this.state.errorInfo
-                      ? this.state.errorInfo.componentStack
-                      : null
-                  )
-                );
-              }
-              return this.props.children;
-            },
-          },
-        ]);
-        return ErrorBoundary2;
-      })(React.Component);
-      var ExplorerWrapper = (function (_React$PureComponent10) {
-        _inherits(ExplorerWrapper2, _React$PureComponent10);
-        function ExplorerWrapper2() {
-          _classCallCheck(this, ExplorerWrapper2);
-          return _possibleConstructorReturn(
-            this,
-            (
-              ExplorerWrapper2.__proto__ ||
-              Object.getPrototypeOf(ExplorerWrapper2)
-            ).apply(this, arguments)
-          );
-        }
-        _createClass(ExplorerWrapper2, [
-          {
-            key: "render",
-            value: function render() {
-              return React.createElement(
-                "div",
-                {
-                  className: "docExplorerWrap",
-                  style: {
-                    height: "100%",
-                    width: this.props.width,
-                    minWidth: this.props.width,
-                    zIndex: 7,
-                    display: this.props.explorerIsOpen ? "flex" : "none",
-                    flexDirection: "column",
-                    overflow: "hidden",
-                  },
-                },
-                React.createElement(
-                  "section",
-                  {
-                    className: "doc-explorer",
-                  },
-                  React.createElement(
-                    "div",
-                    { className: "doc-explorer-title-bar" },
-                    React.createElement(
-                      "div",
-                      { className: "doc-explorer-title" },
-                      this.props.title
-                    ),
-                    React.createElement(
-                      "div",
-                      { className: "doc-explorer-rhs" },
-                      React.createElement(
-                        "div",
-                        {
-                          className: "docExplorerHide",
-                          onClick: this.props.onToggleExplorer,
-                        },
-                        "\u2715"
-                      )
-                    )
-                  ),
-                  React.createElement(
-                    "div",
-                    {
-                      className: "doc-explorer-contents",
-                      style: {
-                        padding: "0px",
-                        overflowY: "unset",
-                      },
-                    },
-                    React.createElement(
-                      ErrorBoundary,
-                      null,
-                      React.createElement(Explorer, this.props)
-                    )
-                  )
-                )
-              );
-            },
-          },
-        ]);
-        return ExplorerWrapper2;
-      })(React.PureComponent);
-      ExplorerWrapper.defaultValue = defaultValue;
-      ExplorerWrapper.defaultProps = {
-        width: 320,
-        title: "Explorer",
-      };
-      Explorer$1.default = ExplorerWrapper;
-      Object.defineProperty(dist, "__esModule", {
-        value: true,
-      });
-      dist.Explorer = void 0;
-      var _Explorer = Explorer$1;
-      var _Explorer2 = _interopRequireDefault(_Explorer);
-      function _interopRequireDefault(obj) {
-        return obj && obj.__esModule ? obj : { default: obj };
-      }
-      dist.Explorer = _Explorer2.default;
-      var _default = (dist.default = _Explorer2.default);
-      var graphiql = "";
-      var styles = "";
-      var darkMode = "";
-      const YogaLogo = () =>
-        /* @__PURE__ */ React$1.createElement(
-          "svg",
-          {
-            width: "22px",
-            height: "28px",
-            viewBox: "0 0 22 28",
-            version: "1.1",
-            xmlns: "http://www.w3.org/2000/svg",
-          },
-          " ",
-          /* @__PURE__ */ React$1.createElement("title", null, "Fill 19"),
-          " ",
-          /* @__PURE__ */ React$1.createElement(
-            "desc",
-            null,
-            "Created with Sketch."
-          ),
-          " ",
-          /* @__PURE__ */ React$1.createElement(
-            "g",
-            {
-              id: "Symbols",
-              stroke: "none",
-              "stroke-width": "1",
-              fill: "none",
-              "fill-rule": "evenodd",
-            },
-            " ",
-            /* @__PURE__ */ React$1.createElement(
-              "g",
-              {
-                id: "Menu-/-not-signed-in",
-                transform: "translate(-88.000000, -52.000000)",
-                fill: "white",
-              },
-              " ",
-              /* @__PURE__ */ React$1.createElement("path", {
-                d: "M97.3333019,67.5555032 C93.8969498,67.5555032 91.1111006,64.7698425 91.1111006,61.3333019 C91.1111006,57.8967613 93.8969498,55.1111006 97.3333019,55.1111006 C100.769843,55.1111006 103.555503,57.8967613 103.555503,61.3333019 C103.555503,64.7698425 100.769843,67.5555032 97.3333019,67.5555032 M97.3333019,52 C102.487924,52 106.666604,56.1786795 106.666604,61.3333019 C106.666604,66.4879243 102.487924,70.6666038 97.3333019,70.6666038 C92.1786795,70.6666038 88,66.4879243 88,61.3333019 C88,56.1786795 92.1786795,52 97.3333019,52 Z M106.211063,71.1221444 C106.818576,71.7296575 106.818576,72.7144622 106.211063,73.3219753 L99.9886734,79.5443652 C99.3811603,80.1518783 98.3963556,80.1518783 97.7888425,79.5443652 C97.1813294,78.9368521 97.1813294,77.9520473 97.7888425,77.3445342 L104.011232,71.1221444 C104.618745,70.5146313 105.60355,70.5146313 106.211063,71.1221444 Z M109.777704,53.5555503 C109.777704,54.4147797 109.081384,55.1111006 108.222343,55.1111006 C107.363113,55.1111006 106.666792,54.4147797 106.666792,53.5555503 C106.666792,52.6963209 107.363113,52 108.222343,52 C109.081384,52 109.777704,52.6963209 109.777704,53.5555503 Z",
-                id: "Fill-19",
-              }),
-              " "
-            ),
-            " "
-          )
-        );
-      const noop = function () {};
-      const listeners = {
-        popstate: [],
-      };
-      let mockWindow = {
-        URL: function URL2() {
-          return {
-            searchParams: {
-              set: noop,
-              append: noop,
-              delete: noop,
-            },
-          };
-        },
-        location: {
-          href: "",
-          search: "",
-        },
-        history: {
-          pushState: noop,
-        },
-        fireEvent: function (eventName) {
-          listeners[eventName].forEach((listener) => {
-            listener();
-          });
-        },
-        addEventListener: function (eventName, listener) {
-          listeners[eventName].push(listener);
-        },
-        removeEventListener: function (eventName, listener) {
-          const eventListeners = listeners[eventName];
-          const i = eventListeners.findIndex((l2) => l2 === listener);
-          eventListeners.splice(i, 1);
-        },
-      };
-      function getWindow() {
-        if (typeof window !== "undefined") return window;
-        return mockWindow;
-      }
-      const SUPPORTED_PARAMS_TYPES = [Number, String, Boolean, Date];
-      function setQueryToCurrentUrl(params) {
-        const { URL: URL3 } = getWindow();
-        const url = new URL3(getWindow().location.href);
-        Object.keys(params).forEach((key) => {
-          const value = params[key];
-          if (value !== null && value !== void 0) {
-            if (Array.isArray(value)) {
-              url.searchParams.delete(key);
-              value.forEach((valueItem) => {
-                url.searchParams.append(key, valueItem);
-              });
-            } else if (value instanceof Date) {
-              if (!isNaN(value.getTime())) {
-                url.searchParams.set(key, value.toISOString());
-              }
-            } else if (typeof value === "object") {
-              url.searchParams.set(key, JSON.stringify(value));
-            } else {
-              url.searchParams.set(key, value);
-            }
-          } else {
-            url.searchParams.delete(key);
-          }
-        });
-        return url;
-      }
-      function isNoneEmptyPrimitiveArray(input) {
-        return (
-          Array.isArray(input) &&
-          input.length > 0 &&
-          input.every(
-            (item) =>
-              typeof item === "number" ||
-              typeof item === "string" ||
-              typeof item === "boolean"
-          )
-        );
-      }
-      function validateTypes(types = {}) {
-        const isValidTypes = Object.values(types).every(
-          (type2) =>
-            SUPPORTED_PARAMS_TYPES.includes(type2) ||
-            isNoneEmptyPrimitiveArray(type2) ||
-            typeof type2 === "function"
-        );
-        if (!isValidTypes) {
-          throw new Error(
-            `Unsupported param types. Must be one of [${SUPPORTED_PARAMS_TYPES.map(
-              (item) => item.name
-            ).join(", ")}]`
-          );
-        }
-      }
-      function useUrlSearchParams(initial = {}, types = {}, replace2 = false) {
-        if (types) validateTypes(types);
-        const [, forceUpdate] = react.exports.useState();
-        const locationSearch = getWindow().location.search;
-        const urlSearchParams = react.exports.useMemo(() => {
-          return new URLSearchParams(locationSearch);
-        }, [locationSearch]);
-        const params = react.exports.useMemo(() => {
-          let result2 = [];
-          urlSearchParams.forEach((value, key) => {
-            result2.push({
-              key,
-              value,
-            });
-          });
-          result2 = result2.reduce((acc, val) => {
-            (acc[val.key] = acc[val.key] || []).push(val);
-            return acc;
-          }, {});
-          result2 = Object.keys(result2).map((key) => {
-            const valueGroup = result2[key];
-            if (valueGroup.length === 1) {
-              return [key, valueGroup[0].value];
-            } else {
-              return [key, valueGroup.map(({ value }) => value)];
-            }
-          });
-          const params2 = Object.assign({}, initial);
-          result2.forEach(([key, value]) => {
-            params2[key] = parseValue(key, value, types, initial);
-          });
-          return params2;
-        }, [urlSearchParams]);
-        function redirectToNewSearchParams(params2) {
-          const url = setQueryToCurrentUrl(params2);
-          if (getWindow().location.search !== url.search) {
-            if (replace2) {
-              getWindow().history.replaceState({}, "", url.toString());
-            } else {
-              getWindow().history.pushState({}, "", url.toString());
-            }
-          }
-          if (urlSearchParams.toString() !== url.searchParams.toString()) {
-            forceUpdate({});
-          }
-        }
-        react.exports.useEffect(() => {
-          redirectToNewSearchParams(
-            Object.assign(Object.assign({}, initial), params)
-          );
-        }, [params]);
-        const setParams = (params2) => {
-          redirectToNewSearchParams(params2);
-        };
-        react.exports.useEffect(() => {
-          const onPopState = () => {
-            forceUpdate({});
-          };
-          getWindow().addEventListener("popstate", onPopState);
-          return () => {
-            getWindow().removeEventListener("popstate", onPopState);
-          };
-        }, []);
-        return [params, setParams];
-      }
-      const booleanValues = {
-        true: true,
-        false: false,
-      };
-      function parseValue(key, _value, types, defaultParams) {
-        if (!types) return _value;
-        const type2 = types[key];
-        const value = _value === void 0 ? defaultParams[key] : _value;
-        if (type2 === Number) {
-          return Number(value);
-        }
-        if (type2 === Boolean) {
-          return booleanValues[value];
-        }
-        if (type2 === Date) {
-          return new Date(value);
-        }
-        if (Array.isArray(type2)) {
-          return type2.find((item) => item == value) || defaultParams[key];
-        }
-        if (typeof type2 === "function") {
-          return type2(value);
-        }
-        return value;
-      }
-      var JSON$1 = {};
-      const stringify = (...args) => JSON$1.stringify(...args);
-      (function () {
-        var escapable =
-            /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
-          gap2,
-          indent2,
-          meta = {
-            "\b": "\\b",
-            "	": "\\t",
-            "\n": "\\n",
-            "\f": "\\f",
-            "\r": "\\r",
-            '"': '\\"',
-            "\\": "\\\\",
-          },
-          rep;
-        function quote(string2) {
-          escapable.lastIndex = 0;
-          return escapable.test(string2)
-            ? '"' +
-                string2.replace(escapable, function (a) {
-                  var c = meta[a];
-                  return typeof c === "string"
-                    ? c
-                    : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
-                }) +
-                '"'
-            : '"' + string2 + '"';
-        }
-        function str(key, holder) {
-          var i,
-            k,
-            v2,
-            length,
-            mind = gap2,
-            partial,
-            value = holder[key];
-          if (
-            value &&
-            typeof value === "object" &&
-            typeof value.toJSON === "function"
-          ) {
-            value = value.toJSON(key);
-          }
-          if (typeof rep === "function") {
-            value = rep.call(holder, key, value);
-          }
-          switch (typeof value) {
-            case "string":
-              return quote(value);
-            case "number":
-              return isFinite(value) ? String(value) : "null";
-            case "bigint":
-            case "boolean":
-            case "null":
-              return String(value);
-            case "object":
-              if (!value) {
-                return "null";
-              }
-              gap2 += indent2;
-              partial = [];
-              if (Object.prototype.toString.apply(value) === "[object Array]") {
-                length = value.length;
-                for (i = 0; i < length; i += 1) {
-                  partial[i] = str(i, value) || "null";
-                }
-                v2 =
-                  partial.length === 0
-                    ? "[]"
-                    : gap2
-                    ? "[\n" +
-                      gap2 +
-                      partial.join(",\n" + gap2) +
-                      "\n" +
-                      mind +
-                      "]"
-                    : "[" + partial.join(",") + "]";
-                gap2 = mind;
-                return v2;
-              }
-              if (rep && typeof rep === "object") {
-                length = rep.length;
-                for (i = 0; i < length; i += 1) {
-                  if (typeof rep[i] === "string") {
-                    k = rep[i];
-                    v2 = str(k, value);
-                    if (v2) {
-                      partial.push(quote(k) + (gap2 ? ": " : ":") + v2);
-                    }
-                  }
-                }
-              } else {
-                Object.keys(value).forEach(function (k2) {
-                  var v3 = str(k2, value);
-                  if (v3) {
-                    partial.push(quote(k2) + (gap2 ? ": " : ":") + v3);
-                  }
-                });
-              }
-              v2 =
-                partial.length === 0
-                  ? "{}"
-                  : gap2
-                  ? "{\n" +
-                    gap2 +
-                    partial.join(",\n" + gap2) +
-                    "\n" +
-                    mind +
-                    "}"
-                  : "{" + partial.join(",") + "}";
-              gap2 = mind;
-              return v2;
-          }
-        }
-        if (typeof JSON$1.stringify !== "function") {
-          JSON$1.stringify = function (value, replacer, space) {
-            var i;
-            gap2 = "";
-            indent2 = "";
-            if (typeof space === "number") {
-              for (i = 0; i < space; i += 1) {
-                indent2 += " ";
-              }
-            } else if (typeof space === "string") {
-              indent2 = space;
-            }
-            rep = replacer;
-            if (
-              replacer &&
-              typeof replacer !== "function" &&
-              (typeof replacer !== "object" ||
-                typeof replacer.length !== "number")
-            ) {
-              throw new Error("JSON.stringify");
-            }
-            return str("", { "": value });
-          };
-        }
-      })();
-      function json_parse(options) {
-        var _options = {
-          strict: false,
-          storeAsString: false,
-        };
-        if (options !== void 0 && options !== null) {
-          if (options.strict === true) {
-            _options.strict = true;
-          }
-          if (options.storeAsString === true) {
-            _options.storeAsString = true;
-          }
-        }
-        var at,
-          ch2,
-          escapee = {
-            '"': '"',
-            "\\": "\\",
-            "/": "/",
-            b: "\b",
-            f: "\f",
-            n: "\n",
-            r: "\r",
-            t: "	",
-          },
-          text3,
-          error2 = function (m) {
-            throw {
-              name: "SyntaxError",
-              message: m,
-              at,
-              text: text3,
-            };
-          },
-          next = function (c) {
-            if (c && c !== ch2) {
-              error2("Expected '" + c + "' instead of '" + ch2 + "'");
-            }
-            ch2 = text3.charAt(at);
-            at += 1;
-            return ch2;
-          },
-          number = function () {
-            var string3 = "";
-            if (ch2 === "-") {
-              string3 = "-";
-              next("-");
-            }
-            while (ch2 >= "0" && ch2 <= "9") {
-              string3 += ch2;
-              next();
-            }
-            if (ch2 === ".") {
-              string3 += ".";
-              while (next() && ch2 >= "0" && ch2 <= "9") {
-                string3 += ch2;
-              }
-            }
-            if (ch2 === "e" || ch2 === "E") {
-              string3 += ch2;
-              next();
-              if (ch2 === "-" || ch2 === "+") {
-                string3 += ch2;
-                next();
-              }
-              while (ch2 >= "0" && ch2 <= "9") {
-                string3 += ch2;
-                next();
-              }
-            }
-            if (!isFinite(Number(string3))) {
-              error2("Bad number");
-            } else {
-              const nonBigIntNum = Number(string3);
-              if (
-                Number.isInteger(nonBigIntNum) &&
-                !Number.isSafeInteger(nonBigIntNum)
-              )
-                return _options.storeAsString === true
-                  ? string3
-                  : BigInt(string3);
-              return nonBigIntNum;
-            }
-          },
-          string2 = function () {
-            var hex,
-              i,
-              string3 = "",
-              uffff;
-            if (ch2 === '"') {
-              while (next()) {
-                if (ch2 === '"') {
-                  next();
-                  return string3;
-                }
-                if (ch2 === "\\") {
-                  next();
-                  if (ch2 === "u") {
-                    uffff = 0;
-                    for (i = 0; i < 4; i += 1) {
-                      hex = parseInt(next(), 16);
-                      if (!isFinite(hex)) {
-                        break;
-                      }
-                      uffff = uffff * 16 + hex;
-                    }
-                    string3 += String.fromCharCode(uffff);
-                  } else if (typeof escapee[ch2] === "string") {
-                    string3 += escapee[ch2];
-                  } else {
-                    break;
-                  }
-                } else {
-                  string3 += ch2;
-                }
-              }
-            }
-            error2("Bad string");
-          },
-          white = function () {
-            while (ch2 && ch2 <= " ") {
-              next();
-            }
-          },
-          word2 = function () {
-            switch (ch2) {
-              case "t":
-                next("t");
-                next("r");
-                next("u");
-                next("e");
-                return true;
-              case "f":
-                next("f");
-                next("a");
-                next("l");
-                next("s");
-                next("e");
-                return false;
-              case "n":
-                next("n");
-                next("u");
-                next("l");
-                next("l");
-                return null;
-            }
-            error2("Unexpected '" + ch2 + "'");
-          },
-          value,
-          array = function () {
-            var array2 = [];
-            if (ch2 === "[") {
-              next("[");
-              white();
-              if (ch2 === "]") {
-                next("]");
-                return array2;
-              }
-              while (ch2) {
-                array2.push(value());
-                white();
-                if (ch2 === "]") {
-                  next("]");
-                  return array2;
-                }
-                next(",");
-                white();
-              }
-            }
-            error2("Bad array");
-          },
-          object = function () {
-            var key,
-              object2 = {};
-            if (ch2 === "{") {
-              next("{");
-              white();
-              if (ch2 === "}") {
-                next("}");
-                return object2;
-              }
-              while (ch2) {
-                key = string2();
-                white();
-                next(":");
-                if (
-                  _options.strict === true &&
-                  Object.hasOwnProperty.call(object2, key)
-                ) {
-                  error2('Duplicate key "' + key + '"');
-                }
-                object2[key] = value();
-                white();
-                if (ch2 === "}") {
-                  next("}");
-                  return object2;
-                }
-                next(",");
-                white();
-              }
-            }
-            error2("Bad object");
-          };
-        value = function () {
-          white();
-          switch (ch2) {
-            case "{":
-              return object();
-            case "[":
-              return array();
-            case '"':
-              return string2();
-            case "-":
-              return number();
-            default:
-              return ch2 >= "0" && ch2 <= "9" ? number() : word2();
-          }
-        };
-        return function (source, reviver) {
-          var result2;
-          text3 = source + "";
-          at = 0;
-          ch2 = " ";
-          result2 = value();
-          white();
-          if (ch2) {
-            error2("Syntax error");
-          }
-          return typeof reviver === "function"
-            ? (function walk(holder, key) {
-                var v2,
-                  value2 = holder[key];
-                if (value2 && typeof value2 === "object") {
-                  Object.keys(value2).forEach(function (k) {
-                    v2 = walk(value2, k);
-                    if (v2 !== void 0) {
-                      value2[k] = v2;
-                    } else {
-                      delete value2[k];
-                    }
-                  });
-                }
-                return reviver.call(holder, key, value2);
-              })({ "": result2 }, "")
-            : result2;
-        };
-      }
-      let globalObj;
-      if (typeof globalThis !== "undefined") {
-        globalObj = globalThis;
-      } else if (typeof self !== "undefined") {
-        globalObj = self;
-      } else if (typeof window !== "undefined") {
-        globalObj = window;
-      } else if (typeof commonjsGlobal !== "undefined") {
-        globalObj = commonjsGlobal;
-      }
-      globalObj.BigInt.prototype.toJSON = function () {
-        return this;
-      };
-      globalObj.JSON.parse = json_parse();
-      globalObj.JSON.stringify = stringify;
-      const getOperationWithFragments = (document2, operationName) => {
-        const definitions = document2.definitions.filter((definition) => {
-          var _a2;
-          if (definition.kind === Kind.OPERATION_DEFINITION) {
-            if (operationName) {
-              if (
-                ((_a2 = definition.name) == null ? void 0 : _a2.value) !==
-                operationName
-              ) {
-                return false;
-              }
-            }
-          }
-          return true;
-        });
-        return {
-          kind: Kind.DOCUMENT,
-          definitions,
-        };
-      };
-      function YogaGraphiQL(props) {
-        var _a2;
-        const initialQuery = `
-    #
-    # Welcome to The GraphiQL
-    #
-    # GraphiQL is an in-browser tool for writing, validating, and
-    # testing GraphQL queries.
-    #
-    # Type queries into this side of the screen, and you will see intelligent
-    # typeaheads aware of the current GraphQL type schema and live syntax and
-    # validation errors highlighted within the text.
-    #
-    # GraphQL queries typically start with a "{" character. Lines that start
-    # with a # are ignored.
-    #
-    # An example GraphQL query might look like:
-    #
-    #     {
-    #       field(arg: "value") {
-    #         subField
-    #       }
-    #     }
-    #
-    # Keyboard shortcuts:
-    #
-    #  Prettify Query:  Shift-Ctrl-P (or press the prettify button above)
-    #
-    #     Merge Query:  Shift-Ctrl-M (or press the merge button above)
-    #
-    #       Run Query:  Ctrl-Enter (or press the play button above)
-    #
-    #   Auto Complete:  Ctrl-Space (or just start typing)
-    #
-  `;
-        const endpoint = new URL(
-          (_a2 = props.endpoint) != null ? _a2 : location.pathname,
-          location.href
-        ).toString();
-        const graphiqlRef = React$1.useRef(null);
-        const urlLoader = react.exports.useMemo(() => new UrlLoader(), []);
-        const fetcher = react.exports.useMemo(() => {
-          const executor = urlLoader.getExecutorAsync(
-            endpoint,
-            __spreadProps(
-              __spreadValues(
-                {
-                  subscriptionsProtocol: SubscriptionProtocol.SSE,
-                  credentials: "same-origin",
-                  specifiedByUrl: true,
-                  directiveIsRepeatable: true,
-                  schemaDescription: true,
-                },
-                props
-              ),
-              {
-                headers: {},
-              }
-            )
-          );
-          return function fetcher2(graphQLParams, opts) {
-            const document2 = getOperationWithFragments(
-              parse$1(graphQLParams.query),
-              graphQLParams.operationName
-            );
-            return executor({
-              document: document2,
-              operationName: graphQLParams.operationName,
-              variables: graphQLParams.variables,
-              extensions: {
-                headers: opts == null ? void 0 : opts.headers,
-              },
-            });
-          };
-        }, [urlLoader, endpoint]);
-        const [showExplorer, setShowExplorer] = React$1.useState(false);
-        const [schema, setSchema] = React$1.useState(null);
-        const types = {
-          query: String,
-        };
-        const [params, setParams] = useUrlSearchParams(
-          {
-            query: props.defaultQuery || initialQuery,
-          },
-          types,
-          false
-        );
-        const [showDocs, setShowDocs] = React$1.useState(false);
-        return /* @__PURE__ */ React$1.createElement(
-          "div",
-          {
-            className: "graphiql-container",
-          },
-          schema && (params == null ? void 0 : params.query) != null
-            ? /* @__PURE__ */ React$1.createElement(_default, {
-                schema,
-                query: params.query.toString(),
-                onEdit: (query) => {
-                  setParams({
-                    query,
-                  });
-                },
-                explorerIsOpen: showExplorer,
-                onToggleExplorer: () => setShowExplorer((isOpen) => !isOpen),
-                colors: {
-                  keyword: "#FF6D5D",
-                  def: "#9F51D9",
-                  property: "#0083c7",
-                  qualifier: "#008AED",
-                  attribute: "#00b8ff",
-                  number: "#97b1aa",
-                  string: "#00917D",
-                  string2: "#146574",
-                  builtin: "#da8aff",
-                  variable: "#FF6D5D",
-                  atom: "#ff9f4c",
-                },
-              })
-            : null,
-          (params == null ? void 0 : params.query) != null
-            ? /* @__PURE__ */ React$1.createElement(
-                GraphiQL,
-                __spreadValues(
-                  {
-                    ref: graphiqlRef,
-                    fetcher,
-                    headerEditorEnabled: true,
-                    defaultVariableEditorOpen: true,
-                    docExplorerOpen: showDocs,
-                    onToggleDocs: () => setShowDocs((isOpen) => !isOpen),
-                    tabs: true,
-                    toolbar: {
-                      additionalContent: /* @__PURE__ */ React$1.createElement(
-                        React$1.Fragment,
-                        null,
-                        /* @__PURE__ */ React$1.createElement(
-                          "button",
-                          {
-                            className: "toolbar-button",
-                            onClick: () => {
-                              var _a3;
-                              const state =
-                                (_a3 = graphiqlRef.current) == null
-                                  ? void 0
-                                  : _a3.state;
-                              copyToClipboard(
-                                urlLoader.prepareGETUrl({
-                                  baseUrl: window.location.href,
-                                  query:
-                                    (state == null ? void 0 : state.query) ||
-                                    "",
-                                  variables:
-                                    state == null ? void 0 : state.variables,
-                                  operationName:
-                                    state == null
-                                      ? void 0
-                                      : state.operationName,
-                                })
-                              );
-                            },
-                          },
-                          "Copy Link"
-                        )
-                      ),
-                    },
-                    onSchemaChange: (schema2) => {
-                      setSchema(schema2);
-                    },
-                    query: params.query.toString(),
-                    onEditQuery: (query) =>
-                      setParams({
-                        query,
-                      }),
-                    beforeTopBarContent: schema
-                      ? showExplorer
-                        ? null
-                        : /* @__PURE__ */ React$1.createElement(
-                            "button",
-                            {
-                              className:
-                                "docExplorerShow docExplorerShowReverse",
-                              onClick: () =>
-                                setShowExplorer((isOpen) => !isOpen),
-                            },
-                            "Explorer"
-                          )
-                      : null,
-                  },
-                  props
-                ),
-                /* @__PURE__ */ React$1.createElement(
-                  GraphiQL.Logo,
-                  null,
-                  /* @__PURE__ */ React$1.createElement(
-                    "div",
-                    {
-                      style: { display: "flex", alignItems: "center" },
-                    },
-                    /* @__PURE__ */ React$1.createElement(
-                      "div",
-                      {
-                        style: { width: 40, display: "flex" },
-                      },
-                      /* @__PURE__ */ React$1.createElement(YogaLogo, null)
-                    ),
-                    /* @__PURE__ */ React$1.createElement(
-                      "span",
-                      null,
-                      (props == null ? void 0 : props.title)
-                        ? props.title
-                        : /* @__PURE__ */ React$1.createElement(
-                            React$1.Fragment,
-                            null,
-                            "The Graph",
-                            /* @__PURE__ */ React$1.createElement(
-                              "em",
-                              null,
-                              "i"
-                            ),
-                            "QL"
-                          )
-                    )
-                  )
-                )
-              )
-            : null
-        );
-      }
-      function renderYogaGraphiQL(element, opts) {
-        ReactDOM.render(
-          /* @__PURE__ */ React$1.createElement(
-            YogaGraphiQL,
-            __spreadValues({}, opts)
-          ),
-          element
-        );
-      }
-      var codemirror$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (global2, factory) {
-          module2.exports = factory();
-        })(commonjsGlobal, function () {
-          var userAgent = navigator.userAgent;
-          var platform = navigator.platform;
-          var gecko = /gecko\/\d/i.test(userAgent);
-          var ie_upto10 = /MSIE \d/.test(userAgent);
-          var ie_11up = /Trident\/(?:[7-9]|\d{2,})\..*rv:(\d+)/.exec(userAgent);
-          var edge = /Edge\/(\d+)/.exec(userAgent);
-          var ie2 = ie_upto10 || ie_11up || edge;
-          var ie_version =
-            ie2 &&
-            (ie_upto10 ? document.documentMode || 6 : +(edge || ie_11up)[1]);
-          var webkit = !edge && /WebKit\//.test(userAgent);
-          var qtwebkit = webkit && /Qt\/\d+\.\d+/.test(userAgent);
-          var chrome = !edge && /Chrome\//.test(userAgent);
-          var presto = /Opera\//.test(userAgent);
-          var safari = /Apple Computer/.test(navigator.vendor);
-          var mac_geMountainLion = /Mac OS X 1\d\D([8-9]|\d\d)\D/.test(
-            userAgent
-          );
-          var phantom = /PhantomJS/.test(userAgent);
-          var ios =
-            safari &&
-            (/Mobile\/\w+/.test(userAgent) || navigator.maxTouchPoints > 2);
-          var android = /Android/.test(userAgent);
-          var mobile =
-            ios ||
-            android ||
-            /webOS|BlackBerry|Opera Mini|Opera Mobi|IEMobile/i.test(userAgent);
-          var mac = ios || /Mac/.test(platform);
-          var chromeOS = /\bCrOS\b/.test(userAgent);
-          var windows = /win/i.test(platform);
-          var presto_version = presto && userAgent.match(/Version\/(\d*\.\d*)/);
-          if (presto_version) {
-            presto_version = Number(presto_version[1]);
-          }
-          if (presto_version && presto_version >= 15) {
-            presto = false;
-            webkit = true;
-          }
-          var flipCtrlCmd =
-            mac &&
-            (qtwebkit ||
-              (presto && (presto_version == null || presto_version < 12.11)));
-          var captureRightClick = gecko || (ie2 && ie_version >= 9);
-          function classTest(cls) {
-            return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*");
-          }
-          var rmClass = function (node, cls) {
-            var current = node.className;
-            var match2 = classTest(cls).exec(current);
-            if (match2) {
-              var after = current.slice(match2.index + match2[0].length);
-              node.className =
-                current.slice(0, match2.index) +
-                (after ? match2[1] + after : "");
-            }
-          };
-          function removeChildren(e) {
-            for (var count = e.childNodes.length; count > 0; --count) {
-              e.removeChild(e.firstChild);
-            }
-            return e;
-          }
-          function removeChildrenAndAdd(parent, e) {
-            return removeChildren(parent).appendChild(e);
-          }
-          function elt(tag, content, className, style) {
-            var e = document.createElement(tag);
-            if (className) {
-              e.className = className;
-            }
-            if (style) {
-              e.style.cssText = style;
-            }
-            if (typeof content == "string") {
-              e.appendChild(document.createTextNode(content));
-            } else if (content) {
-              for (var i2 = 0; i2 < content.length; ++i2) {
-                e.appendChild(content[i2]);
-              }
-            }
-            return e;
-          }
-          function eltP(tag, content, className, style) {
-            var e = elt(tag, content, className, style);
-            e.setAttribute("role", "presentation");
-            return e;
-          }
-          var range2;
-          if (document.createRange) {
-            range2 = function (node, start2, end2, endNode) {
-              var r2 = document.createRange();
-              r2.setEnd(endNode || node, end2);
-              r2.setStart(node, start2);
-              return r2;
-            };
-          } else {
-            range2 = function (node, start2, end2) {
-              var r2 = document.body.createTextRange();
-              try {
-                r2.moveToElementText(node.parentNode);
-              } catch (e) {
-                return r2;
-              }
-              r2.collapse(true);
-              r2.moveEnd("character", end2);
-              r2.moveStart("character", start2);
-              return r2;
-            };
-          }
-          function contains(parent, child) {
-            if (child.nodeType == 3) {
-              child = child.parentNode;
-            }
-            if (parent.contains) {
-              return parent.contains(child);
-            }
-            do {
-              if (child.nodeType == 11) {
-                child = child.host;
-              }
-              if (child == parent) {
-                return true;
-              }
-            } while ((child = child.parentNode));
-          }
-          function activeElt() {
-            var activeElement;
-            try {
-              activeElement = document.activeElement;
-            } catch (e) {
-              activeElement = document.body || null;
-            }
-            while (
-              activeElement &&
-              activeElement.shadowRoot &&
-              activeElement.shadowRoot.activeElement
-            ) {
-              activeElement = activeElement.shadowRoot.activeElement;
-            }
-            return activeElement;
-          }
-          function addClass(node, cls) {
-            var current = node.className;
-            if (!classTest(cls).test(current)) {
-              node.className += (current ? " " : "") + cls;
-            }
-          }
-          function joinClasses(a, b) {
-            var as = a.split(" ");
-            for (var i2 = 0; i2 < as.length; i2++) {
-              if (as[i2] && !classTest(as[i2]).test(b)) {
-                b += " " + as[i2];
-              }
-            }
-            return b;
-          }
-          var selectInput = function (node) {
-            node.select();
-          };
-          if (ios) {
-            selectInput = function (node) {
-              node.selectionStart = 0;
-              node.selectionEnd = node.value.length;
-            };
-          } else if (ie2) {
-            selectInput = function (node) {
-              try {
-                node.select();
-              } catch (_e) {}
-            };
-          }
-          function bind(f) {
-            var args = Array.prototype.slice.call(arguments, 1);
-            return function () {
-              return f.apply(null, args);
-            };
-          }
-          function copyObj(obj, target2, overwrite) {
-            if (!target2) {
-              target2 = {};
-            }
-            for (var prop3 in obj) {
-              if (
-                obj.hasOwnProperty(prop3) &&
-                (overwrite !== false || !target2.hasOwnProperty(prop3))
-              ) {
-                target2[prop3] = obj[prop3];
-              }
-            }
-            return target2;
-          }
-          function countColumn(string2, end2, tabSize, startIndex, startValue) {
-            if (end2 == null) {
-              end2 = string2.search(/[^\s\u00a0]/);
-              if (end2 == -1) {
-                end2 = string2.length;
-              }
-            }
-            for (var i2 = startIndex || 0, n2 = startValue || 0; ; ) {
-              var nextTab = string2.indexOf("	", i2);
-              if (nextTab < 0 || nextTab >= end2) {
-                return n2 + (end2 - i2);
-              }
-              n2 += nextTab - i2;
-              n2 += tabSize - (n2 % tabSize);
-              i2 = nextTab + 1;
-            }
-          }
-          var Delayed = function () {
-            this.id = null;
-            this.f = null;
-            this.time = 0;
-            this.handler = bind(this.onTimeout, this);
-          };
-          Delayed.prototype.onTimeout = function (self2) {
-            self2.id = 0;
-            if (self2.time <= +new Date()) {
-              self2.f();
-            } else {
-              setTimeout(self2.handler, self2.time - +new Date());
-            }
-          };
-          Delayed.prototype.set = function (ms, f) {
-            this.f = f;
-            var time = +new Date() + ms;
-            if (!this.id || time < this.time) {
-              clearTimeout(this.id);
-              this.id = setTimeout(this.handler, ms);
-              this.time = time;
-            }
-          };
-          function indexOf(array, elt2) {
-            for (var i2 = 0; i2 < array.length; ++i2) {
-              if (array[i2] == elt2) {
-                return i2;
-              }
-            }
-            return -1;
-          }
-          var scrollerGap = 50;
-          var Pass = {
-            toString: function () {
-              return "CodeMirror.Pass";
-            },
-          };
-          var sel_dontScroll = { scroll: false },
-            sel_mouse = { origin: "*mouse" },
-            sel_move = { origin: "+move" };
-          function findColumn(string2, goal, tabSize) {
-            for (var pos = 0, col = 0; ; ) {
-              var nextTab = string2.indexOf("	", pos);
-              if (nextTab == -1) {
-                nextTab = string2.length;
-              }
-              var skipped = nextTab - pos;
-              if (nextTab == string2.length || col + skipped >= goal) {
-                return pos + Math.min(skipped, goal - col);
-              }
-              col += nextTab - pos;
-              col += tabSize - (col % tabSize);
-              pos = nextTab + 1;
-              if (col >= goal) {
-                return pos;
-              }
-            }
-          }
-          var spaceStrs = [""];
-          function spaceStr(n2) {
-            while (spaceStrs.length <= n2) {
-              spaceStrs.push(lst(spaceStrs) + " ");
-            }
-            return spaceStrs[n2];
-          }
-          function lst(arr) {
-            return arr[arr.length - 1];
-          }
-          function map2(array, f) {
-            var out = [];
-            for (var i2 = 0; i2 < array.length; i2++) {
-              out[i2] = f(array[i2], i2);
-            }
-            return out;
-          }
-          function insertSorted(array, value, score) {
-            var pos = 0,
-              priority = score(value);
-            while (pos < array.length && score(array[pos]) <= priority) {
-              pos++;
-            }
-            array.splice(pos, 0, value);
-          }
-          function nothing() {}
-          function createObj(base2, props) {
-            var inst;
-            if (Object.create) {
-              inst = Object.create(base2);
-            } else {
-              nothing.prototype = base2;
-              inst = new nothing();
-            }
-            if (props) {
-              copyObj(props, inst);
-            }
-            return inst;
-          }
-          var nonASCIISingleCaseWordChar =
-            /[\u00df\u0587\u0590-\u05f4\u0600-\u06ff\u3040-\u309f\u30a0-\u30ff\u3400-\u4db5\u4e00-\u9fcc\uac00-\ud7af]/;
-          function isWordCharBasic(ch2) {
-            return (
-              /\w/.test(ch2) ||
-              (ch2 > "\x80" &&
-                (ch2.toUpperCase() != ch2.toLowerCase() ||
-                  nonASCIISingleCaseWordChar.test(ch2)))
-            );
-          }
-          function isWordChar(ch2, helper) {
-            if (!helper) {
-              return isWordCharBasic(ch2);
-            }
-            if (helper.source.indexOf("\\w") > -1 && isWordCharBasic(ch2)) {
-              return true;
-            }
-            return helper.test(ch2);
-          }
-          function isEmpty2(obj) {
-            for (var n2 in obj) {
-              if (obj.hasOwnProperty(n2) && obj[n2]) {
-                return false;
-              }
-            }
-            return true;
-          }
-          var extendingChars =
-            /[\u0300-\u036f\u0483-\u0489\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u065e\u0670\u06d6-\u06dc\u06de-\u06e4\u06e7\u06e8\u06ea-\u06ed\u0711\u0730-\u074a\u07a6-\u07b0\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0900-\u0902\u093c\u0941-\u0948\u094d\u0951-\u0955\u0962\u0963\u0981\u09bc\u09be\u09c1-\u09c4\u09cd\u09d7\u09e2\u09e3\u0a01\u0a02\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a70\u0a71\u0a75\u0a81\u0a82\u0abc\u0ac1-\u0ac5\u0ac7\u0ac8\u0acd\u0ae2\u0ae3\u0b01\u0b3c\u0b3e\u0b3f\u0b41-\u0b44\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b82\u0bbe\u0bc0\u0bcd\u0bd7\u0c3e-\u0c40\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0cbc\u0cbf\u0cc2\u0cc6\u0ccc\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0d3e\u0d41-\u0d44\u0d4d\u0d57\u0d62\u0d63\u0dca\u0dcf\u0dd2-\u0dd4\u0dd6\u0ddf\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0f18\u0f19\u0f35\u0f37\u0f39\u0f71-\u0f7e\u0f80-\u0f84\u0f86\u0f87\u0f90-\u0f97\u0f99-\u0fbc\u0fc6\u102d-\u1030\u1032-\u1037\u1039\u103a\u103d\u103e\u1058\u1059\u105e-\u1060\u1071-\u1074\u1082\u1085\u1086\u108d\u109d\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b7-\u17bd\u17c6\u17c9-\u17d3\u17dd\u180b-\u180d\u18a9\u1920-\u1922\u1927\u1928\u1932\u1939-\u193b\u1a17\u1a18\u1a56\u1a58-\u1a5e\u1a60\u1a62\u1a65-\u1a6c\u1a73-\u1a7c\u1a7f\u1b00-\u1b03\u1b34\u1b36-\u1b3a\u1b3c\u1b42\u1b6b-\u1b73\u1b80\u1b81\u1ba2-\u1ba5\u1ba8\u1ba9\u1c2c-\u1c33\u1c36\u1c37\u1cd0-\u1cd2\u1cd4-\u1ce0\u1ce2-\u1ce8\u1ced\u1dc0-\u1de6\u1dfd-\u1dff\u200c\u200d\u20d0-\u20f0\u2cef-\u2cf1\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua66f-\ua672\ua67c\ua67d\ua6f0\ua6f1\ua802\ua806\ua80b\ua825\ua826\ua8c4\ua8e0-\ua8f1\ua926-\ua92d\ua947-\ua951\ua980-\ua982\ua9b3\ua9b6-\ua9b9\ua9bc\uaa29-\uaa2e\uaa31\uaa32\uaa35\uaa36\uaa43\uaa4c\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uabe5\uabe8\uabed\udc00-\udfff\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\uff9e\uff9f]/;
-          function isExtendingChar(ch2) {
-            return ch2.charCodeAt(0) >= 768 && extendingChars.test(ch2);
-          }
-          function skipExtendingChars(str, pos, dir) {
-            while (
-              (dir < 0 ? pos > 0 : pos < str.length) &&
-              isExtendingChar(str.charAt(pos))
-            ) {
-              pos += dir;
-            }
-            return pos;
-          }
-          function findFirst(pred, from, to) {
-            var dir = from > to ? -1 : 1;
-            for (;;) {
-              if (from == to) {
-                return from;
-              }
-              var midF = (from + to) / 2,
-                mid2 = dir < 0 ? Math.ceil(midF) : Math.floor(midF);
-              if (mid2 == from) {
-                return pred(mid2) ? from : to;
-              }
-              if (pred(mid2)) {
-                to = mid2;
-              } else {
-                from = mid2 + dir;
-              }
-            }
-          }
-          function iterateBidiSections(order2, from, to, f) {
-            if (!order2) {
-              return f(from, to, "ltr", 0);
-            }
-            var found = false;
-            for (var i2 = 0; i2 < order2.length; ++i2) {
-              var part2 = order2[i2];
-              if (
-                (part2.from < to && part2.to > from) ||
-                (from == to && part2.to == from)
-              ) {
-                f(
-                  Math.max(part2.from, from),
-                  Math.min(part2.to, to),
-                  part2.level == 1 ? "rtl" : "ltr",
-                  i2
-                );
-                found = true;
-              }
-            }
-            if (!found) {
-              f(from, to, "ltr");
-            }
-          }
-          var bidiOther = null;
-          function getBidiPartAt(order2, ch2, sticky) {
-            var found;
-            bidiOther = null;
-            for (var i2 = 0; i2 < order2.length; ++i2) {
-              var cur = order2[i2];
-              if (cur.from < ch2 && cur.to > ch2) {
-                return i2;
-              }
-              if (cur.to == ch2) {
-                if (cur.from != cur.to && sticky == "before") {
-                  found = i2;
-                } else {
-                  bidiOther = i2;
-                }
-              }
-              if (cur.from == ch2) {
-                if (cur.from != cur.to && sticky != "before") {
-                  found = i2;
-                } else {
-                  bidiOther = i2;
-                }
-              }
-            }
-            return found != null ? found : bidiOther;
-          }
-          var bidiOrdering = (function () {
-            var lowTypes =
-              "bbbbbbbbbtstwsbbbbbbbbbbbbbbssstwNN%%%NNNNNN,N,N1111111111NNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNNNLLLLLLLLLLLLLLLLLLLLLLLLLLNNNNbbbbbbsbbbbbbbbbbbbbbbbbbbbbbbbbb,N%%%%NNNNLNNNNN%%11NLNNN1LNNNNNLLLLLLLLLLLLLLLLLLLLLLLNLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLN";
-            var arabicTypes =
-              "nnnnnnNNr%%r,rNNmmmmmmmmmmmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmmmmmmmmmmmmmmmnnnnnnnnnn%nnrrrmrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrmmmmmmmnNmmmmmmrrmmNmmmmrr1111111111";
-            function charType(code3) {
-              if (code3 <= 247) {
-                return lowTypes.charAt(code3);
-              } else if (1424 <= code3 && code3 <= 1524) {
-                return "R";
-              } else if (1536 <= code3 && code3 <= 1785) {
-                return arabicTypes.charAt(code3 - 1536);
-              } else if (1774 <= code3 && code3 <= 2220) {
-                return "r";
-              } else if (8192 <= code3 && code3 <= 8203) {
-                return "w";
-              } else if (code3 == 8204) {
-                return "b";
-              } else {
-                return "L";
-              }
-            }
-            var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac]/;
-            var isNeutral = /[stwN]/,
-              isStrong = /[LRr]/,
-              countsAsLeft = /[Lb1n]/,
-              countsAsNum = /[1n]/;
-            function BidiSpan(level, from, to) {
-              this.level = level;
-              this.from = from;
-              this.to = to;
-            }
-            return function (str, direction) {
-              var outerType = direction == "ltr" ? "L" : "R";
-              if (
-                str.length == 0 ||
-                (direction == "ltr" && !bidiRE.test(str))
-              ) {
-                return false;
-              }
-              var len = str.length,
-                types = [];
-              for (var i2 = 0; i2 < len; ++i2) {
-                types.push(charType(str.charCodeAt(i2)));
-              }
-              for (var i$12 = 0, prev = outerType; i$12 < len; ++i$12) {
-                var type2 = types[i$12];
-                if (type2 == "m") {
-                  types[i$12] = prev;
-                } else {
-                  prev = type2;
-                }
-              }
-              for (var i$22 = 0, cur = outerType; i$22 < len; ++i$22) {
-                var type$1 = types[i$22];
-                if (type$1 == "1" && cur == "r") {
-                  types[i$22] = "n";
-                } else if (isStrong.test(type$1)) {
-                  cur = type$1;
-                  if (type$1 == "r") {
-                    types[i$22] = "R";
-                  }
-                }
-              }
-              for (var i$3 = 1, prev$1 = types[0]; i$3 < len - 1; ++i$3) {
-                var type$2 = types[i$3];
-                if (type$2 == "+" && prev$1 == "1" && types[i$3 + 1] == "1") {
-                  types[i$3] = "1";
-                } else if (
-                  type$2 == "," &&
-                  prev$1 == types[i$3 + 1] &&
-                  (prev$1 == "1" || prev$1 == "n")
-                ) {
-                  types[i$3] = prev$1;
-                }
-                prev$1 = type$2;
-              }
-              for (var i$4 = 0; i$4 < len; ++i$4) {
-                var type$3 = types[i$4];
-                if (type$3 == ",") {
-                  types[i$4] = "N";
-                } else if (type$3 == "%") {
-                  var end2 = void 0;
-                  for (
-                    end2 = i$4 + 1;
-                    end2 < len && types[end2] == "%";
-                    ++end2
-                  ) {}
-                  var replace2 =
-                    (i$4 && types[i$4 - 1] == "!") ||
-                    (end2 < len && types[end2] == "1")
-                      ? "1"
-                      : "N";
-                  for (var j = i$4; j < end2; ++j) {
-                    types[j] = replace2;
-                  }
-                  i$4 = end2 - 1;
-                }
-              }
-              for (var i$5 = 0, cur$1 = outerType; i$5 < len; ++i$5) {
-                var type$4 = types[i$5];
-                if (cur$1 == "L" && type$4 == "1") {
-                  types[i$5] = "L";
-                } else if (isStrong.test(type$4)) {
-                  cur$1 = type$4;
-                }
-              }
-              for (var i$6 = 0; i$6 < len; ++i$6) {
-                if (isNeutral.test(types[i$6])) {
-                  var end$1 = void 0;
-                  for (
-                    end$1 = i$6 + 1;
-                    end$1 < len && isNeutral.test(types[end$1]);
-                    ++end$1
-                  ) {}
-                  var before = (i$6 ? types[i$6 - 1] : outerType) == "L";
-                  var after = (end$1 < len ? types[end$1] : outerType) == "L";
-                  var replace$1 =
-                    before == after ? (before ? "L" : "R") : outerType;
-                  for (var j$1 = i$6; j$1 < end$1; ++j$1) {
-                    types[j$1] = replace$1;
-                  }
-                  i$6 = end$1 - 1;
-                }
-              }
-              var order2 = [],
-                m;
-              for (var i$7 = 0; i$7 < len; ) {
-                if (countsAsLeft.test(types[i$7])) {
-                  var start2 = i$7;
-                  for (
-                    ++i$7;
-                    i$7 < len && countsAsLeft.test(types[i$7]);
-                    ++i$7
-                  ) {}
-                  order2.push(new BidiSpan(0, start2, i$7));
-                } else {
-                  var pos = i$7,
-                    at = order2.length,
-                    isRTL = direction == "rtl" ? 1 : 0;
-                  for (++i$7; i$7 < len && types[i$7] != "L"; ++i$7) {}
-                  for (var j$2 = pos; j$2 < i$7; ) {
-                    if (countsAsNum.test(types[j$2])) {
-                      if (pos < j$2) {
-                        order2.splice(at, 0, new BidiSpan(1, pos, j$2));
-                        at += isRTL;
-                      }
-                      var nstart = j$2;
-                      for (
-                        ++j$2;
-                        j$2 < i$7 && countsAsNum.test(types[j$2]);
-                        ++j$2
-                      ) {}
-                      order2.splice(at, 0, new BidiSpan(2, nstart, j$2));
-                      at += isRTL;
-                      pos = j$2;
-                    } else {
-                      ++j$2;
-                    }
-                  }
-                  if (pos < i$7) {
-                    order2.splice(at, 0, new BidiSpan(1, pos, i$7));
-                  }
-                }
-              }
-              if (direction == "ltr") {
-                if (order2[0].level == 1 && (m = str.match(/^\s+/))) {
-                  order2[0].from = m[0].length;
-                  order2.unshift(new BidiSpan(0, 0, m[0].length));
-                }
-                if (lst(order2).level == 1 && (m = str.match(/\s+$/))) {
-                  lst(order2).to -= m[0].length;
-                  order2.push(new BidiSpan(0, len - m[0].length, len));
-                }
-              }
-              return direction == "rtl" ? order2.reverse() : order2;
-            };
-          })();
-          function getOrder(line, direction) {
-            var order2 = line.order;
-            if (order2 == null) {
-              order2 = line.order = bidiOrdering(line.text, direction);
-            }
-            return order2;
-          }
-          var noHandlers = [];
-          var on = function (emitter, type2, f) {
-            if (emitter.addEventListener) {
-              emitter.addEventListener(type2, f, false);
-            } else if (emitter.attachEvent) {
-              emitter.attachEvent("on" + type2, f);
-            } else {
-              var map3 = emitter._handlers || (emitter._handlers = {});
-              map3[type2] = (map3[type2] || noHandlers).concat(f);
-            }
-          };
-          function getHandlers(emitter, type2) {
-            return (
-              (emitter._handlers && emitter._handlers[type2]) || noHandlers
-            );
-          }
-          function off(emitter, type2, f) {
-            if (emitter.removeEventListener) {
-              emitter.removeEventListener(type2, f, false);
-            } else if (emitter.detachEvent) {
-              emitter.detachEvent("on" + type2, f);
-            } else {
-              var map3 = emitter._handlers,
-                arr = map3 && map3[type2];
-              if (arr) {
-                var index = indexOf(arr, f);
-                if (index > -1) {
-                  map3[type2] = arr
-                    .slice(0, index)
-                    .concat(arr.slice(index + 1));
-                }
-              }
-            }
-          }
-          function signal(emitter, type2) {
-            var handlers = getHandlers(emitter, type2);
-            if (!handlers.length) {
-              return;
-            }
-            var args = Array.prototype.slice.call(arguments, 2);
-            for (var i2 = 0; i2 < handlers.length; ++i2) {
-              handlers[i2].apply(null, args);
-            }
-          }
-          function signalDOMEvent(cm, e, override) {
-            if (typeof e == "string") {
-              e = {
-                type: e,
-                preventDefault: function () {
-                  this.defaultPrevented = true;
-                },
-              };
-            }
-            signal(cm, override || e.type, cm, e);
-            return e_defaultPrevented(e) || e.codemirrorIgnore;
-          }
-          function signalCursorActivity(cm) {
-            var arr = cm._handlers && cm._handlers.cursorActivity;
-            if (!arr) {
-              return;
-            }
-            var set2 =
-              cm.curOp.cursorActivityHandlers ||
-              (cm.curOp.cursorActivityHandlers = []);
-            for (var i2 = 0; i2 < arr.length; ++i2) {
-              if (indexOf(set2, arr[i2]) == -1) {
-                set2.push(arr[i2]);
-              }
-            }
-          }
-          function hasHandler(emitter, type2) {
-            return getHandlers(emitter, type2).length > 0;
-          }
-          function eventMixin(ctor) {
-            ctor.prototype.on = function (type2, f) {
-              on(this, type2, f);
-            };
-            ctor.prototype.off = function (type2, f) {
-              off(this, type2, f);
-            };
-          }
-          function e_preventDefault(e) {
-            if (e.preventDefault) {
-              e.preventDefault();
-            } else {
-              e.returnValue = false;
-            }
-          }
-          function e_stopPropagation(e) {
-            if (e.stopPropagation) {
-              e.stopPropagation();
-            } else {
-              e.cancelBubble = true;
-            }
-          }
-          function e_defaultPrevented(e) {
-            return e.defaultPrevented != null
-              ? e.defaultPrevented
-              : e.returnValue == false;
-          }
-          function e_stop(e) {
-            e_preventDefault(e);
-            e_stopPropagation(e);
-          }
-          function e_target(e) {
-            return e.target || e.srcElement;
-          }
-          function e_button(e) {
-            var b = e.which;
-            if (b == null) {
-              if (e.button & 1) {
-                b = 1;
-              } else if (e.button & 2) {
-                b = 3;
-              } else if (e.button & 4) {
-                b = 2;
-              }
-            }
-            if (mac && e.ctrlKey && b == 1) {
-              b = 3;
-            }
-            return b;
-          }
-          var dragAndDrop = (function () {
-            if (ie2 && ie_version < 9) {
-              return false;
-            }
-            var div2 = elt("div");
-            return "draggable" in div2 || "dragDrop" in div2;
-          })();
-          var zwspSupported;
-          function zeroWidthElement(measure) {
-            if (zwspSupported == null) {
-              var test2 = elt("span", "\u200B");
-              removeChildrenAndAdd(
-                measure,
-                elt("span", [test2, document.createTextNode("x")])
-              );
-              if (measure.firstChild.offsetHeight != 0) {
-                zwspSupported =
-                  test2.offsetWidth <= 1 &&
-                  test2.offsetHeight > 2 &&
-                  !(ie2 && ie_version < 8);
-              }
-            }
-            var node = zwspSupported
-              ? elt("span", "\u200B")
-              : elt(
-                  "span",
-                  "\xA0",
-                  null,
-                  "display: inline-block; width: 1px; margin-right: -1px"
-                );
-            node.setAttribute("cm-text", "");
-            return node;
-          }
-          var badBidiRects;
-          function hasBadBidiRects(measure) {
-            if (badBidiRects != null) {
-              return badBidiRects;
-            }
-            var txt = removeChildrenAndAdd(
-              measure,
-              document.createTextNode("A\u062EA")
-            );
-            var r0 = range2(txt, 0, 1).getBoundingClientRect();
-            var r1 = range2(txt, 1, 2).getBoundingClientRect();
-            removeChildren(measure);
-            if (!r0 || r0.left == r0.right) {
-              return false;
-            }
-            return (badBidiRects = r1.right - r0.right < 3);
-          }
-          var splitLinesAuto =
-            "\n\nb".split(/\n/).length != 3
-              ? function (string2) {
-                  var pos = 0,
-                    result2 = [],
-                    l2 = string2.length;
-                  while (pos <= l2) {
-                    var nl = string2.indexOf("\n", pos);
-                    if (nl == -1) {
-                      nl = string2.length;
-                    }
-                    var line = string2.slice(
-                      pos,
-                      string2.charAt(nl - 1) == "\r" ? nl - 1 : nl
-                    );
-                    var rt = line.indexOf("\r");
-                    if (rt != -1) {
-                      result2.push(line.slice(0, rt));
-                      pos += rt + 1;
-                    } else {
-                      result2.push(line);
-                      pos = nl + 1;
-                    }
-                  }
-                  return result2;
-                }
-              : function (string2) {
-                  return string2.split(/\r\n?|\n/);
-                };
-          var hasSelection = window.getSelection
-            ? function (te) {
-                try {
-                  return te.selectionStart != te.selectionEnd;
-                } catch (e) {
-                  return false;
-                }
-              }
-            : function (te) {
-                var range3;
-                try {
-                  range3 = te.ownerDocument.selection.createRange();
-                } catch (e) {}
-                if (!range3 || range3.parentElement() != te) {
-                  return false;
-                }
-                return range3.compareEndPoints("StartToEnd", range3) != 0;
-              };
-          var hasCopyEvent = (function () {
-            var e = elt("div");
-            if ("oncopy" in e) {
-              return true;
-            }
-            e.setAttribute("oncopy", "return;");
-            return typeof e.oncopy == "function";
-          })();
-          var badZoomedRects = null;
-          function hasBadZoomedRects(measure) {
-            if (badZoomedRects != null) {
-              return badZoomedRects;
-            }
-            var node = removeChildrenAndAdd(measure, elt("span", "x"));
-            var normal = node.getBoundingClientRect();
-            var fromRange = range2(node, 0, 1).getBoundingClientRect();
-            return (badZoomedRects =
-              Math.abs(normal.left - fromRange.left) > 1);
-          }
-          var modes = {},
-            mimeModes = {};
-          function defineMode(name2, mode2) {
-            if (arguments.length > 2) {
-              mode2.dependencies = Array.prototype.slice.call(arguments, 2);
-            }
-            modes[name2] = mode2;
-          }
-          function defineMIME(mime, spec) {
-            mimeModes[mime] = spec;
-          }
-          function resolveMode(spec) {
-            if (typeof spec == "string" && mimeModes.hasOwnProperty(spec)) {
-              spec = mimeModes[spec];
-            } else if (
-              spec &&
-              typeof spec.name == "string" &&
-              mimeModes.hasOwnProperty(spec.name)
-            ) {
-              var found = mimeModes[spec.name];
-              if (typeof found == "string") {
-                found = { name: found };
-              }
-              spec = createObj(found, spec);
-              spec.name = found.name;
-            } else if (
-              typeof spec == "string" &&
-              /^[\w\-]+\/[\w\-]+\+xml$/.test(spec)
-            ) {
-              return resolveMode("application/xml");
-            } else if (
-              typeof spec == "string" &&
-              /^[\w\-]+\/[\w\-]+\+json$/.test(spec)
-            ) {
-              return resolveMode("application/json");
-            }
-            if (typeof spec == "string") {
-              return { name: spec };
-            } else {
-              return spec || { name: "null" };
-            }
-          }
-          function getMode(options, spec) {
-            spec = resolveMode(spec);
-            var mfactory = modes[spec.name];
-            if (!mfactory) {
-              return getMode(options, "text/plain");
-            }
-            var modeObj = mfactory(options, spec);
-            if (modeExtensions.hasOwnProperty(spec.name)) {
-              var exts = modeExtensions[spec.name];
-              for (var prop3 in exts) {
-                if (!exts.hasOwnProperty(prop3)) {
-                  continue;
-                }
-                if (modeObj.hasOwnProperty(prop3)) {
-                  modeObj["_" + prop3] = modeObj[prop3];
-                }
-                modeObj[prop3] = exts[prop3];
-              }
-            }
-            modeObj.name = spec.name;
-            if (spec.helperType) {
-              modeObj.helperType = spec.helperType;
-            }
-            if (spec.modeProps) {
-              for (var prop$1 in spec.modeProps) {
-                modeObj[prop$1] = spec.modeProps[prop$1];
-              }
-            }
-            return modeObj;
-          }
-          var modeExtensions = {};
-          function extendMode(mode2, properties) {
-            var exts = modeExtensions.hasOwnProperty(mode2)
-              ? modeExtensions[mode2]
-              : (modeExtensions[mode2] = {});
-            copyObj(properties, exts);
-          }
-          function copyState(mode2, state) {
-            if (state === true) {
-              return state;
-            }
-            if (mode2.copyState) {
-              return mode2.copyState(state);
-            }
-            var nstate = {};
-            for (var n2 in state) {
-              var val = state[n2];
-              if (val instanceof Array) {
-                val = val.concat([]);
-              }
-              nstate[n2] = val;
-            }
-            return nstate;
-          }
-          function innerMode(mode2, state) {
-            var info2;
-            while (mode2.innerMode) {
-              info2 = mode2.innerMode(state);
-              if (!info2 || info2.mode == mode2) {
-                break;
-              }
-              state = info2.state;
-              mode2 = info2.mode;
-            }
-            return info2 || { mode: mode2, state };
-          }
-          function startState(mode2, a1, a2) {
-            return mode2.startState ? mode2.startState(a1, a2) : true;
-          }
-          var StringStream = function (string2, tabSize, lineOracle) {
-            this.pos = this.start = 0;
-            this.string = string2;
-            this.tabSize = tabSize || 8;
-            this.lastColumnPos = this.lastColumnValue = 0;
-            this.lineStart = 0;
-            this.lineOracle = lineOracle;
-          };
-          StringStream.prototype.eol = function () {
-            return this.pos >= this.string.length;
-          };
-          StringStream.prototype.sol = function () {
-            return this.pos == this.lineStart;
-          };
-          StringStream.prototype.peek = function () {
-            return this.string.charAt(this.pos) || void 0;
-          };
-          StringStream.prototype.next = function () {
-            if (this.pos < this.string.length) {
-              return this.string.charAt(this.pos++);
-            }
-          };
-          StringStream.prototype.eat = function (match2) {
-            var ch2 = this.string.charAt(this.pos);
-            var ok2;
-            if (typeof match2 == "string") {
-              ok2 = ch2 == match2;
-            } else {
-              ok2 = ch2 && (match2.test ? match2.test(ch2) : match2(ch2));
-            }
-            if (ok2) {
-              ++this.pos;
-              return ch2;
-            }
-          };
-          StringStream.prototype.eatWhile = function (match2) {
-            var start2 = this.pos;
-            while (this.eat(match2)) {}
-            return this.pos > start2;
-          };
-          StringStream.prototype.eatSpace = function () {
-            var start2 = this.pos;
-            while (/[\s\u00a0]/.test(this.string.charAt(this.pos))) {
-              ++this.pos;
-            }
-            return this.pos > start2;
-          };
-          StringStream.prototype.skipToEnd = function () {
-            this.pos = this.string.length;
-          };
-          StringStream.prototype.skipTo = function (ch2) {
-            var found = this.string.indexOf(ch2, this.pos);
-            if (found > -1) {
-              this.pos = found;
-              return true;
-            }
-          };
-          StringStream.prototype.backUp = function (n2) {
-            this.pos -= n2;
-          };
-          StringStream.prototype.column = function () {
-            if (this.lastColumnPos < this.start) {
-              this.lastColumnValue = countColumn(
-                this.string,
-                this.start,
-                this.tabSize,
-                this.lastColumnPos,
-                this.lastColumnValue
-              );
-              this.lastColumnPos = this.start;
-            }
-            return (
-              this.lastColumnValue -
-              (this.lineStart
-                ? countColumn(this.string, this.lineStart, this.tabSize)
-                : 0)
-            );
-          };
-          StringStream.prototype.indentation = function () {
-            return (
-              countColumn(this.string, null, this.tabSize) -
-              (this.lineStart
-                ? countColumn(this.string, this.lineStart, this.tabSize)
-                : 0)
-            );
-          };
-          StringStream.prototype.match = function (
-            pattern,
-            consume,
-            caseInsensitive
-          ) {
-            if (typeof pattern == "string") {
-              var cased = function (str) {
-                return caseInsensitive ? str.toLowerCase() : str;
-              };
-              var substr = this.string.substr(this.pos, pattern.length);
-              if (cased(substr) == cased(pattern)) {
-                if (consume !== false) {
-                  this.pos += pattern.length;
-                }
-                return true;
-              }
-            } else {
-              var match2 = this.string.slice(this.pos).match(pattern);
-              if (match2 && match2.index > 0) {
-                return null;
-              }
-              if (match2 && consume !== false) {
-                this.pos += match2[0].length;
-              }
-              return match2;
-            }
-          };
-          StringStream.prototype.current = function () {
-            return this.string.slice(this.start, this.pos);
-          };
-          StringStream.prototype.hideFirstChars = function (n2, inner) {
-            this.lineStart += n2;
-            try {
-              return inner();
-            } finally {
-              this.lineStart -= n2;
-            }
-          };
-          StringStream.prototype.lookAhead = function (n2) {
-            var oracle = this.lineOracle;
-            return oracle && oracle.lookAhead(n2);
-          };
-          StringStream.prototype.baseToken = function () {
-            var oracle = this.lineOracle;
-            return oracle && oracle.baseToken(this.pos);
-          };
-          function getLine2(doc, n2) {
-            n2 -= doc.first;
-            if (n2 < 0 || n2 >= doc.size) {
-              throw new Error(
-                "There is no line " + (n2 + doc.first) + " in the document."
-              );
-            }
-            var chunk = doc;
-            while (!chunk.lines) {
-              for (var i2 = 0; ; ++i2) {
-                var child = chunk.children[i2],
-                  sz = child.chunkSize();
-                if (n2 < sz) {
-                  chunk = child;
-                  break;
-                }
-                n2 -= sz;
-              }
-            }
-            return chunk.lines[n2];
-          }
-          function getBetween(doc, start2, end2) {
-            var out = [],
-              n2 = start2.line;
-            doc.iter(start2.line, end2.line + 1, function (line) {
-              var text3 = line.text;
-              if (n2 == end2.line) {
-                text3 = text3.slice(0, end2.ch);
-              }
-              if (n2 == start2.line) {
-                text3 = text3.slice(start2.ch);
-              }
-              out.push(text3);
-              ++n2;
-            });
-            return out;
-          }
-          function getLines2(doc, from, to) {
-            var out = [];
-            doc.iter(from, to, function (line) {
-              out.push(line.text);
-            });
-            return out;
-          }
-          function updateLineHeight(line, height) {
-            var diff2 = height - line.height;
-            if (diff2) {
-              for (var n2 = line; n2; n2 = n2.parent) {
-                n2.height += diff2;
-              }
-            }
-          }
-          function lineNo(line) {
-            if (line.parent == null) {
-              return null;
-            }
-            var cur = line.parent,
-              no = indexOf(cur.lines, line);
-            for (
-              var chunk = cur.parent;
-              chunk;
-              cur = chunk, chunk = chunk.parent
-            ) {
-              for (var i2 = 0; ; ++i2) {
-                if (chunk.children[i2] == cur) {
-                  break;
-                }
-                no += chunk.children[i2].chunkSize();
-              }
-            }
-            return no + cur.first;
-          }
-          function lineAtHeight(chunk, h) {
-            var n2 = chunk.first;
-            outer: do {
-              for (var i$12 = 0; i$12 < chunk.children.length; ++i$12) {
-                var child = chunk.children[i$12],
-                  ch2 = child.height;
-                if (h < ch2) {
-                  chunk = child;
-                  continue outer;
-                }
-                h -= ch2;
-                n2 += child.chunkSize();
-              }
-              return n2;
-            } while (!chunk.lines);
-            var i2 = 0;
-            for (; i2 < chunk.lines.length; ++i2) {
-              var line = chunk.lines[i2],
-                lh2 = line.height;
-              if (h < lh2) {
-                break;
-              }
-              h -= lh2;
-            }
-            return n2 + i2;
-          }
-          function isLine(doc, l2) {
-            return l2 >= doc.first && l2 < doc.first + doc.size;
-          }
-          function lineNumberFor(options, i2) {
-            return String(
-              options.lineNumberFormatter(i2 + options.firstLineNumber)
-            );
-          }
-          function Pos(line, ch2, sticky) {
-            if (sticky === void 0) sticky = null;
-            if (!(this instanceof Pos)) {
-              return new Pos(line, ch2, sticky);
-            }
-            this.line = line;
-            this.ch = ch2;
-            this.sticky = sticky;
-          }
-          function cmp(a, b) {
-            return a.line - b.line || a.ch - b.ch;
-          }
-          function equalCursorPos(a, b) {
-            return a.sticky == b.sticky && cmp(a, b) == 0;
-          }
-          function copyPos(x2) {
-            return Pos(x2.line, x2.ch);
-          }
-          function maxPos(a, b) {
-            return cmp(a, b) < 0 ? b : a;
-          }
-          function minPos(a, b) {
-            return cmp(a, b) < 0 ? a : b;
-          }
-          function clipLine(doc, n2) {
-            return Math.max(doc.first, Math.min(n2, doc.first + doc.size - 1));
-          }
-          function clipPos(doc, pos) {
-            if (pos.line < doc.first) {
-              return Pos(doc.first, 0);
-            }
-            var last = doc.first + doc.size - 1;
-            if (pos.line > last) {
-              return Pos(last, getLine2(doc, last).text.length);
-            }
-            return clipToLen(pos, getLine2(doc, pos.line).text.length);
-          }
-          function clipToLen(pos, linelen) {
-            var ch2 = pos.ch;
-            if (ch2 == null || ch2 > linelen) {
-              return Pos(pos.line, linelen);
-            } else if (ch2 < 0) {
-              return Pos(pos.line, 0);
-            } else {
-              return pos;
-            }
-          }
-          function clipPosArray(doc, array) {
-            var out = [];
-            for (var i2 = 0; i2 < array.length; i2++) {
-              out[i2] = clipPos(doc, array[i2]);
-            }
-            return out;
-          }
-          var SavedContext = function (state, lookAhead) {
-            this.state = state;
-            this.lookAhead = lookAhead;
-          };
-          var Context = function (doc, state, line, lookAhead) {
-            this.state = state;
-            this.doc = doc;
-            this.line = line;
-            this.maxLookAhead = lookAhead || 0;
-            this.baseTokens = null;
-            this.baseTokenPos = 1;
-          };
-          Context.prototype.lookAhead = function (n2) {
-            var line = this.doc.getLine(this.line + n2);
-            if (line != null && n2 > this.maxLookAhead) {
-              this.maxLookAhead = n2;
-            }
-            return line;
-          };
-          Context.prototype.baseToken = function (n2) {
-            if (!this.baseTokens) {
-              return null;
-            }
-            while (this.baseTokens[this.baseTokenPos] <= n2) {
-              this.baseTokenPos += 2;
-            }
-            var type2 = this.baseTokens[this.baseTokenPos + 1];
-            return {
-              type: type2 && type2.replace(/( |^)overlay .*/, ""),
-              size: this.baseTokens[this.baseTokenPos] - n2,
-            };
-          };
-          Context.prototype.nextLine = function () {
-            this.line++;
-            if (this.maxLookAhead > 0) {
-              this.maxLookAhead--;
-            }
-          };
-          Context.fromSaved = function (doc, saved, line) {
-            if (saved instanceof SavedContext) {
-              return new Context(
-                doc,
-                copyState(doc.mode, saved.state),
-                line,
-                saved.lookAhead
-              );
-            } else {
-              return new Context(doc, copyState(doc.mode, saved), line);
-            }
-          };
-          Context.prototype.save = function (copy2) {
-            var state =
-              copy2 !== false
-                ? copyState(this.doc.mode, this.state)
-                : this.state;
-            return this.maxLookAhead > 0
-              ? new SavedContext(state, this.maxLookAhead)
-              : state;
-          };
-          function highlightLine(cm, line, context, forceToEnd) {
-            var st = [cm.state.modeGen],
-              lineClasses = {};
-            runMode(
-              cm,
-              line.text,
-              cm.doc.mode,
-              context,
-              function (end2, style) {
-                return st.push(end2, style);
-              },
-              lineClasses,
-              forceToEnd
-            );
-            var state = context.state;
-            var loop = function (o2) {
-              context.baseTokens = st;
-              var overlay = cm.state.overlays[o2],
-                i2 = 1,
-                at = 0;
-              context.state = true;
-              runMode(
-                cm,
-                line.text,
-                overlay.mode,
-                context,
-                function (end2, style) {
-                  var start2 = i2;
-                  while (at < end2) {
-                    var i_end = st[i2];
-                    if (i_end > end2) {
-                      st.splice(i2, 1, end2, st[i2 + 1], i_end);
-                    }
-                    i2 += 2;
-                    at = Math.min(end2, i_end);
-                  }
-                  if (!style) {
-                    return;
-                  }
-                  if (overlay.opaque) {
-                    st.splice(start2, i2 - start2, end2, "overlay " + style);
-                    i2 = start2 + 2;
-                  } else {
-                    for (; start2 < i2; start2 += 2) {
-                      var cur = st[start2 + 1];
-                      st[start2 + 1] =
-                        (cur ? cur + " " : "") + "overlay " + style;
-                    }
-                  }
-                },
-                lineClasses
-              );
-              context.state = state;
-              context.baseTokens = null;
-              context.baseTokenPos = 1;
-            };
-            for (var o = 0; o < cm.state.overlays.length; ++o) loop(o);
-            return {
-              styles: st,
-              classes:
-                lineClasses.bgClass || lineClasses.textClass
-                  ? lineClasses
-                  : null,
-            };
-          }
-          function getLineStyles(cm, line, updateFrontier) {
-            if (!line.styles || line.styles[0] != cm.state.modeGen) {
-              var context = getContextBefore(cm, lineNo(line));
-              var resetState =
-                line.text.length > cm.options.maxHighlightLength &&
-                copyState(cm.doc.mode, context.state);
-              var result2 = highlightLine(cm, line, context);
-              if (resetState) {
-                context.state = resetState;
-              }
-              line.stateAfter = context.save(!resetState);
-              line.styles = result2.styles;
-              if (result2.classes) {
-                line.styleClasses = result2.classes;
-              } else if (line.styleClasses) {
-                line.styleClasses = null;
-              }
-              if (updateFrontier === cm.doc.highlightFrontier) {
-                cm.doc.modeFrontier = Math.max(
-                  cm.doc.modeFrontier,
-                  ++cm.doc.highlightFrontier
-                );
-              }
-            }
-            return line.styles;
-          }
-          function getContextBefore(cm, n2, precise) {
-            var doc = cm.doc,
-              display = cm.display;
-            if (!doc.mode.startState) {
-              return new Context(doc, true, n2);
-            }
-            var start2 = findStartLine(cm, n2, precise);
-            var saved =
-              start2 > doc.first && getLine2(doc, start2 - 1).stateAfter;
-            var context = saved
-              ? Context.fromSaved(doc, saved, start2)
-              : new Context(doc, startState(doc.mode), start2);
-            doc.iter(start2, n2, function (line) {
-              processLine(cm, line.text, context);
-              var pos = context.line;
-              line.stateAfter =
-                pos == n2 - 1 ||
-                pos % 5 == 0 ||
-                (pos >= display.viewFrom && pos < display.viewTo)
-                  ? context.save()
-                  : null;
-              context.nextLine();
-            });
-            if (precise) {
-              doc.modeFrontier = context.line;
-            }
-            return context;
-          }
-          function processLine(cm, text3, context, startAt) {
-            var mode2 = cm.doc.mode;
-            var stream = new StringStream(text3, cm.options.tabSize, context);
-            stream.start = stream.pos = startAt || 0;
-            if (text3 == "") {
-              callBlankLine(mode2, context.state);
-            }
-            while (!stream.eol()) {
-              readToken(mode2, stream, context.state);
-              stream.start = stream.pos;
-            }
-          }
-          function callBlankLine(mode2, state) {
-            if (mode2.blankLine) {
-              return mode2.blankLine(state);
-            }
-            if (!mode2.innerMode) {
-              return;
-            }
-            var inner = innerMode(mode2, state);
-            if (inner.mode.blankLine) {
-              return inner.mode.blankLine(inner.state);
-            }
-          }
-          function readToken(mode2, stream, state, inner) {
-            for (var i2 = 0; i2 < 10; i2++) {
-              if (inner) {
-                inner[0] = innerMode(mode2, state).mode;
-              }
-              var style = mode2.token(stream, state);
-              if (stream.pos > stream.start) {
-                return style;
-              }
-            }
-            throw new Error(
-              "Mode " + mode2.name + " failed to advance stream."
-            );
-          }
-          var Token2 = function (stream, type2, state) {
-            this.start = stream.start;
-            this.end = stream.pos;
-            this.string = stream.current();
-            this.type = type2 || null;
-            this.state = state;
-          };
-          function takeToken(cm, pos, precise, asArray) {
-            var doc = cm.doc,
-              mode2 = doc.mode,
-              style;
-            pos = clipPos(doc, pos);
-            var line = getLine2(doc, pos.line),
-              context = getContextBefore(cm, pos.line, precise);
-            var stream = new StringStream(
-                line.text,
-                cm.options.tabSize,
-                context
-              ),
-              tokens;
-            if (asArray) {
-              tokens = [];
-            }
-            while ((asArray || stream.pos < pos.ch) && !stream.eol()) {
-              stream.start = stream.pos;
-              style = readToken(mode2, stream, context.state);
-              if (asArray) {
-                tokens.push(
-                  new Token2(stream, style, copyState(doc.mode, context.state))
-                );
-              }
-            }
-            return asArray ? tokens : new Token2(stream, style, context.state);
-          }
-          function extractLineClasses(type2, output) {
-            if (type2) {
-              for (;;) {
-                var lineClass = type2.match(
-                  /(?:^|\s+)line-(background-)?(\S+)/
-                );
-                if (!lineClass) {
-                  break;
-                }
-                type2 =
-                  type2.slice(0, lineClass.index) +
-                  type2.slice(lineClass.index + lineClass[0].length);
-                var prop3 = lineClass[1] ? "bgClass" : "textClass";
-                if (output[prop3] == null) {
-                  output[prop3] = lineClass[2];
-                } else if (
-                  !new RegExp("(?:^|\\s)" + lineClass[2] + "(?:$|\\s)").test(
-                    output[prop3]
-                  )
-                ) {
-                  output[prop3] += " " + lineClass[2];
-                }
-              }
-            }
-            return type2;
-          }
-          function runMode(
-            cm,
-            text3,
-            mode2,
-            context,
-            f,
-            lineClasses,
-            forceToEnd
-          ) {
-            var flattenSpans = mode2.flattenSpans;
-            if (flattenSpans == null) {
-              flattenSpans = cm.options.flattenSpans;
-            }
-            var curStart = 0,
-              curStyle = null;
-            var stream = new StringStream(text3, cm.options.tabSize, context),
-              style;
-            var inner = cm.options.addModeClass && [null];
-            if (text3 == "") {
-              extractLineClasses(
-                callBlankLine(mode2, context.state),
-                lineClasses
-              );
-            }
-            while (!stream.eol()) {
-              if (stream.pos > cm.options.maxHighlightLength) {
-                flattenSpans = false;
-                if (forceToEnd) {
-                  processLine(cm, text3, context, stream.pos);
-                }
-                stream.pos = text3.length;
-                style = null;
-              } else {
-                style = extractLineClasses(
-                  readToken(mode2, stream, context.state, inner),
-                  lineClasses
-                );
-              }
-              if (inner) {
-                var mName = inner[0].name;
-                if (mName) {
-                  style = "m-" + (style ? mName + " " + style : mName);
-                }
-              }
-              if (!flattenSpans || curStyle != style) {
-                while (curStart < stream.start) {
-                  curStart = Math.min(stream.start, curStart + 5e3);
-                  f(curStart, curStyle);
-                }
-                curStyle = style;
-              }
-              stream.start = stream.pos;
-            }
-            while (curStart < stream.pos) {
-              var pos = Math.min(stream.pos, curStart + 5e3);
-              f(pos, curStyle);
-              curStart = pos;
-            }
-          }
-          function findStartLine(cm, n2, precise) {
-            var minindent,
-              minline,
-              doc = cm.doc;
-            var lim = precise ? -1 : n2 - (cm.doc.mode.innerMode ? 1e3 : 100);
-            for (var search2 = n2; search2 > lim; --search2) {
-              if (search2 <= doc.first) {
-                return doc.first;
-              }
-              var line = getLine2(doc, search2 - 1),
-                after = line.stateAfter;
-              if (
-                after &&
-                (!precise ||
-                  search2 +
-                    (after instanceof SavedContext ? after.lookAhead : 0) <=
-                    doc.modeFrontier)
-              ) {
-                return search2;
-              }
-              var indented = countColumn(line.text, null, cm.options.tabSize);
-              if (minline == null || minindent > indented) {
-                minline = search2 - 1;
-                minindent = indented;
-              }
-            }
-            return minline;
-          }
-          function retreatFrontier(doc, n2) {
-            doc.modeFrontier = Math.min(doc.modeFrontier, n2);
-            if (doc.highlightFrontier < n2 - 10) {
-              return;
-            }
-            var start2 = doc.first;
-            for (var line = n2 - 1; line > start2; line--) {
-              var saved = getLine2(doc, line).stateAfter;
-              if (
-                saved &&
-                (!(saved instanceof SavedContext) ||
-                  line + saved.lookAhead < n2)
-              ) {
-                start2 = line + 1;
-                break;
-              }
-            }
-            doc.highlightFrontier = Math.min(doc.highlightFrontier, start2);
-          }
-          var sawReadOnlySpans = false,
-            sawCollapsedSpans = false;
-          function seeReadOnlySpans() {
-            sawReadOnlySpans = true;
-          }
-          function seeCollapsedSpans() {
-            sawCollapsedSpans = true;
-          }
-          function MarkedSpan(marker2, from, to) {
-            this.marker = marker2;
-            this.from = from;
-            this.to = to;
-          }
-          function getMarkedSpanFor(spans, marker2) {
-            if (spans) {
-              for (var i2 = 0; i2 < spans.length; ++i2) {
-                var span = spans[i2];
-                if (span.marker == marker2) {
-                  return span;
-                }
-              }
-            }
-          }
-          function removeMarkedSpan(spans, span) {
-            var r2;
-            for (var i2 = 0; i2 < spans.length; ++i2) {
-              if (spans[i2] != span) {
-                (r2 || (r2 = [])).push(spans[i2]);
-              }
-            }
-            return r2;
-          }
-          function addMarkedSpan(line, span, op) {
-            var inThisOp =
-              op &&
-              window.WeakSet &&
-              (op.markedSpans ||
-                (op.markedSpans = /* @__PURE__ */ new WeakSet()));
-            if (inThisOp && inThisOp.has(line.markedSpans)) {
-              line.markedSpans.push(span);
-            } else {
-              line.markedSpans = line.markedSpans
-                ? line.markedSpans.concat([span])
-                : [span];
-              if (inThisOp) {
-                inThisOp.add(line.markedSpans);
-              }
-            }
-            span.marker.attachLine(line);
-          }
-          function markedSpansBefore(old, startCh, isInsert) {
-            var nw;
-            if (old) {
-              for (var i2 = 0; i2 < old.length; ++i2) {
-                var span = old[i2],
-                  marker2 = span.marker;
-                var startsBefore =
-                  span.from == null ||
-                  (marker2.inclusiveLeft
-                    ? span.from <= startCh
-                    : span.from < startCh);
-                if (
-                  startsBefore ||
-                  (span.from == startCh &&
-                    marker2.type == "bookmark" &&
-                    (!isInsert || !span.marker.insertLeft))
-                ) {
-                  var endsAfter =
-                    span.to == null ||
-                    (marker2.inclusiveRight
-                      ? span.to >= startCh
-                      : span.to > startCh);
-                  (nw || (nw = [])).push(
-                    new MarkedSpan(
-                      marker2,
-                      span.from,
-                      endsAfter ? null : span.to
-                    )
-                  );
-                }
-              }
-            }
-            return nw;
-          }
-          function markedSpansAfter(old, endCh, isInsert) {
-            var nw;
-            if (old) {
-              for (var i2 = 0; i2 < old.length; ++i2) {
-                var span = old[i2],
-                  marker2 = span.marker;
-                var endsAfter =
-                  span.to == null ||
-                  (marker2.inclusiveRight ? span.to >= endCh : span.to > endCh);
-                if (
-                  endsAfter ||
-                  (span.from == endCh &&
-                    marker2.type == "bookmark" &&
-                    (!isInsert || span.marker.insertLeft))
-                ) {
-                  var startsBefore =
-                    span.from == null ||
-                    (marker2.inclusiveLeft
-                      ? span.from <= endCh
-                      : span.from < endCh);
-                  (nw || (nw = [])).push(
-                    new MarkedSpan(
-                      marker2,
-                      startsBefore ? null : span.from - endCh,
-                      span.to == null ? null : span.to - endCh
-                    )
-                  );
-                }
-              }
-            }
-            return nw;
-          }
-          function stretchSpansOverChange(doc, change) {
-            if (change.full) {
-              return null;
-            }
-            var oldFirst =
-              isLine(doc, change.from.line) &&
-              getLine2(doc, change.from.line).markedSpans;
-            var oldLast =
-              isLine(doc, change.to.line) &&
-              getLine2(doc, change.to.line).markedSpans;
-            if (!oldFirst && !oldLast) {
-              return null;
-            }
-            var startCh = change.from.ch,
-              endCh = change.to.ch,
-              isInsert = cmp(change.from, change.to) == 0;
-            var first = markedSpansBefore(oldFirst, startCh, isInsert);
-            var last = markedSpansAfter(oldLast, endCh, isInsert);
-            var sameLine = change.text.length == 1,
-              offset = lst(change.text).length + (sameLine ? startCh : 0);
-            if (first) {
-              for (var i2 = 0; i2 < first.length; ++i2) {
-                var span = first[i2];
-                if (span.to == null) {
-                  var found = getMarkedSpanFor(last, span.marker);
-                  if (!found) {
-                    span.to = startCh;
-                  } else if (sameLine) {
-                    span.to = found.to == null ? null : found.to + offset;
-                  }
-                }
-              }
-            }
-            if (last) {
-              for (var i$12 = 0; i$12 < last.length; ++i$12) {
-                var span$1 = last[i$12];
-                if (span$1.to != null) {
-                  span$1.to += offset;
-                }
-                if (span$1.from == null) {
-                  var found$1 = getMarkedSpanFor(first, span$1.marker);
-                  if (!found$1) {
-                    span$1.from = offset;
-                    if (sameLine) {
-                      (first || (first = [])).push(span$1);
-                    }
-                  }
-                } else {
-                  span$1.from += offset;
-                  if (sameLine) {
-                    (first || (first = [])).push(span$1);
-                  }
-                }
-              }
-            }
-            if (first) {
-              first = clearEmptySpans(first);
-            }
-            if (last && last != first) {
-              last = clearEmptySpans(last);
-            }
-            var newMarkers = [first];
-            if (!sameLine) {
-              var gap2 = change.text.length - 2,
-                gapMarkers;
-              if (gap2 > 0 && first) {
-                for (var i$22 = 0; i$22 < first.length; ++i$22) {
-                  if (first[i$22].to == null) {
-                    (gapMarkers || (gapMarkers = [])).push(
-                      new MarkedSpan(first[i$22].marker, null, null)
-                    );
-                  }
-                }
-              }
-              for (var i$3 = 0; i$3 < gap2; ++i$3) {
-                newMarkers.push(gapMarkers);
-              }
-              newMarkers.push(last);
-            }
-            return newMarkers;
-          }
-          function clearEmptySpans(spans) {
-            for (var i2 = 0; i2 < spans.length; ++i2) {
-              var span = spans[i2];
-              if (
-                span.from != null &&
-                span.from == span.to &&
-                span.marker.clearWhenEmpty !== false
-              ) {
-                spans.splice(i2--, 1);
-              }
-            }
-            if (!spans.length) {
-              return null;
-            }
-            return spans;
-          }
-          function removeReadOnlyRanges(doc, from, to) {
-            var markers = null;
-            doc.iter(from.line, to.line + 1, function (line) {
-              if (line.markedSpans) {
-                for (var i3 = 0; i3 < line.markedSpans.length; ++i3) {
-                  var mark = line.markedSpans[i3].marker;
-                  if (
-                    mark.readOnly &&
-                    (!markers || indexOf(markers, mark) == -1)
-                  ) {
-                    (markers || (markers = [])).push(mark);
-                  }
-                }
-              }
-            });
-            if (!markers) {
-              return null;
-            }
-            var parts = [{ from, to }];
-            for (var i2 = 0; i2 < markers.length; ++i2) {
-              var mk2 = markers[i2],
-                m = mk2.find(0);
-              for (var j = 0; j < parts.length; ++j) {
-                var p2 = parts[j];
-                if (cmp(p2.to, m.from) < 0 || cmp(p2.from, m.to) > 0) {
-                  continue;
-                }
-                var newParts = [j, 1],
-                  dfrom = cmp(p2.from, m.from),
-                  dto = cmp(p2.to, m.to);
-                if (dfrom < 0 || (!mk2.inclusiveLeft && !dfrom)) {
-                  newParts.push({ from: p2.from, to: m.from });
-                }
-                if (dto > 0 || (!mk2.inclusiveRight && !dto)) {
-                  newParts.push({ from: m.to, to: p2.to });
-                }
-                parts.splice.apply(parts, newParts);
-                j += newParts.length - 3;
-              }
-            }
-            return parts;
-          }
-          function detachMarkedSpans(line) {
-            var spans = line.markedSpans;
-            if (!spans) {
-              return;
-            }
-            for (var i2 = 0; i2 < spans.length; ++i2) {
-              spans[i2].marker.detachLine(line);
-            }
-            line.markedSpans = null;
-          }
-          function attachMarkedSpans(line, spans) {
-            if (!spans) {
-              return;
-            }
-            for (var i2 = 0; i2 < spans.length; ++i2) {
-              spans[i2].marker.attachLine(line);
-            }
-            line.markedSpans = spans;
-          }
-          function extraLeft(marker2) {
-            return marker2.inclusiveLeft ? -1 : 0;
-          }
-          function extraRight(marker2) {
-            return marker2.inclusiveRight ? 1 : 0;
-          }
-          function compareCollapsedMarkers(a, b) {
-            var lenDiff = a.lines.length - b.lines.length;
-            if (lenDiff != 0) {
-              return lenDiff;
-            }
-            var aPos = a.find(),
-              bPos = b.find();
-            var fromCmp =
-              cmp(aPos.from, bPos.from) || extraLeft(a) - extraLeft(b);
-            if (fromCmp) {
-              return -fromCmp;
-            }
-            var toCmp = cmp(aPos.to, bPos.to) || extraRight(a) - extraRight(b);
-            if (toCmp) {
-              return toCmp;
-            }
-            return b.id - a.id;
-          }
-          function collapsedSpanAtSide(line, start2) {
-            var sps = sawCollapsedSpans && line.markedSpans,
-              found;
-            if (sps) {
-              for (var sp = void 0, i2 = 0; i2 < sps.length; ++i2) {
-                sp = sps[i2];
-                if (
-                  sp.marker.collapsed &&
-                  (start2 ? sp.from : sp.to) == null &&
-                  (!found || compareCollapsedMarkers(found, sp.marker) < 0)
-                ) {
-                  found = sp.marker;
-                }
-              }
-            }
-            return found;
-          }
-          function collapsedSpanAtStart(line) {
-            return collapsedSpanAtSide(line, true);
-          }
-          function collapsedSpanAtEnd(line) {
-            return collapsedSpanAtSide(line, false);
-          }
-          function collapsedSpanAround(line, ch2) {
-            var sps = sawCollapsedSpans && line.markedSpans,
-              found;
-            if (sps) {
-              for (var i2 = 0; i2 < sps.length; ++i2) {
-                var sp = sps[i2];
-                if (
-                  sp.marker.collapsed &&
-                  (sp.from == null || sp.from < ch2) &&
-                  (sp.to == null || sp.to > ch2) &&
-                  (!found || compareCollapsedMarkers(found, sp.marker) < 0)
-                ) {
-                  found = sp.marker;
-                }
-              }
-            }
-            return found;
-          }
-          function conflictingCollapsedRange(doc, lineNo2, from, to, marker2) {
-            var line = getLine2(doc, lineNo2);
-            var sps = sawCollapsedSpans && line.markedSpans;
-            if (sps) {
-              for (var i2 = 0; i2 < sps.length; ++i2) {
-                var sp = sps[i2];
-                if (!sp.marker.collapsed) {
-                  continue;
-                }
-                var found = sp.marker.find(0);
-                var fromCmp =
-                  cmp(found.from, from) ||
-                  extraLeft(sp.marker) - extraLeft(marker2);
-                var toCmp =
-                  cmp(found.to, to) ||
-                  extraRight(sp.marker) - extraRight(marker2);
-                if (
-                  (fromCmp >= 0 && toCmp <= 0) ||
-                  (fromCmp <= 0 && toCmp >= 0)
-                ) {
-                  continue;
-                }
-                if (
-                  (fromCmp <= 0 &&
-                    (sp.marker.inclusiveRight && marker2.inclusiveLeft
-                      ? cmp(found.to, from) >= 0
-                      : cmp(found.to, from) > 0)) ||
-                  (fromCmp >= 0 &&
-                    (sp.marker.inclusiveRight && marker2.inclusiveLeft
-                      ? cmp(found.from, to) <= 0
-                      : cmp(found.from, to) < 0))
-                ) {
-                  return true;
-                }
-              }
-            }
-          }
-          function visualLine(line) {
-            var merged;
-            while ((merged = collapsedSpanAtStart(line))) {
-              line = merged.find(-1, true).line;
-            }
-            return line;
-          }
-          function visualLineEnd(line) {
-            var merged;
-            while ((merged = collapsedSpanAtEnd(line))) {
-              line = merged.find(1, true).line;
-            }
-            return line;
-          }
-          function visualLineContinued(line) {
-            var merged, lines;
-            while ((merged = collapsedSpanAtEnd(line))) {
-              line = merged.find(1, true).line;
-              (lines || (lines = [])).push(line);
-            }
-            return lines;
-          }
-          function visualLineNo(doc, lineN) {
-            var line = getLine2(doc, lineN),
-              vis = visualLine(line);
-            if (line == vis) {
-              return lineN;
-            }
-            return lineNo(vis);
-          }
-          function visualLineEndNo(doc, lineN) {
-            if (lineN > doc.lastLine()) {
-              return lineN;
-            }
-            var line = getLine2(doc, lineN),
-              merged;
-            if (!lineIsHidden(doc, line)) {
-              return lineN;
-            }
-            while ((merged = collapsedSpanAtEnd(line))) {
-              line = merged.find(1, true).line;
-            }
-            return lineNo(line) + 1;
-          }
-          function lineIsHidden(doc, line) {
-            var sps = sawCollapsedSpans && line.markedSpans;
-            if (sps) {
-              for (var sp = void 0, i2 = 0; i2 < sps.length; ++i2) {
-                sp = sps[i2];
-                if (!sp.marker.collapsed) {
-                  continue;
-                }
-                if (sp.from == null) {
-                  return true;
-                }
-                if (sp.marker.widgetNode) {
-                  continue;
-                }
-                if (
-                  sp.from == 0 &&
-                  sp.marker.inclusiveLeft &&
-                  lineIsHiddenInner(doc, line, sp)
-                ) {
-                  return true;
-                }
-              }
-            }
-          }
-          function lineIsHiddenInner(doc, line, span) {
-            if (span.to == null) {
-              var end2 = span.marker.find(1, true);
-              return lineIsHiddenInner(
-                doc,
-                end2.line,
-                getMarkedSpanFor(end2.line.markedSpans, span.marker)
-              );
-            }
-            if (span.marker.inclusiveRight && span.to == line.text.length) {
-              return true;
-            }
-            for (var sp = void 0, i2 = 0; i2 < line.markedSpans.length; ++i2) {
-              sp = line.markedSpans[i2];
-              if (
-                sp.marker.collapsed &&
-                !sp.marker.widgetNode &&
-                sp.from == span.to &&
-                (sp.to == null || sp.to != span.from) &&
-                (sp.marker.inclusiveLeft || span.marker.inclusiveRight) &&
-                lineIsHiddenInner(doc, line, sp)
-              ) {
-                return true;
-              }
-            }
-          }
-          function heightAtLine(lineObj) {
-            lineObj = visualLine(lineObj);
-            var h = 0,
-              chunk = lineObj.parent;
-            for (var i2 = 0; i2 < chunk.lines.length; ++i2) {
-              var line = chunk.lines[i2];
-              if (line == lineObj) {
-                break;
-              } else {
-                h += line.height;
-              }
-            }
-            for (var p2 = chunk.parent; p2; chunk = p2, p2 = chunk.parent) {
-              for (var i$12 = 0; i$12 < p2.children.length; ++i$12) {
-                var cur = p2.children[i$12];
-                if (cur == chunk) {
-                  break;
-                } else {
-                  h += cur.height;
-                }
-              }
-            }
-            return h;
-          }
-          function lineLength(line) {
-            if (line.height == 0) {
-              return 0;
-            }
-            var len = line.text.length,
-              merged,
-              cur = line;
-            while ((merged = collapsedSpanAtStart(cur))) {
-              var found = merged.find(0, true);
-              cur = found.from.line;
-              len += found.from.ch - found.to.ch;
-            }
-            cur = line;
-            while ((merged = collapsedSpanAtEnd(cur))) {
-              var found$1 = merged.find(0, true);
-              len -= cur.text.length - found$1.from.ch;
-              cur = found$1.to.line;
-              len += cur.text.length - found$1.to.ch;
-            }
-            return len;
-          }
-          function findMaxLine(cm) {
-            var d = cm.display,
-              doc = cm.doc;
-            d.maxLine = getLine2(doc, doc.first);
-            d.maxLineLength = lineLength(d.maxLine);
-            d.maxLineChanged = true;
-            doc.iter(function (line) {
-              var len = lineLength(line);
-              if (len > d.maxLineLength) {
-                d.maxLineLength = len;
-                d.maxLine = line;
-              }
-            });
-          }
-          var Line = function (text3, markedSpans, estimateHeight2) {
-            this.text = text3;
-            attachMarkedSpans(this, markedSpans);
-            this.height = estimateHeight2 ? estimateHeight2(this) : 1;
-          };
-          Line.prototype.lineNo = function () {
-            return lineNo(this);
-          };
-          eventMixin(Line);
-          function updateLine(line, text3, markedSpans, estimateHeight2) {
-            line.text = text3;
-            if (line.stateAfter) {
-              line.stateAfter = null;
-            }
-            if (line.styles) {
-              line.styles = null;
-            }
-            if (line.order != null) {
-              line.order = null;
-            }
-            detachMarkedSpans(line);
-            attachMarkedSpans(line, markedSpans);
-            var estHeight = estimateHeight2 ? estimateHeight2(line) : 1;
-            if (estHeight != line.height) {
-              updateLineHeight(line, estHeight);
-            }
-          }
-          function cleanUpLine(line) {
-            line.parent = null;
-            detachMarkedSpans(line);
-          }
-          var styleToClassCache = {},
-            styleToClassCacheWithMode = {};
-          function interpretTokenStyle(style, options) {
-            if (!style || /^\s*$/.test(style)) {
-              return null;
-            }
-            var cache = options.addModeClass
-              ? styleToClassCacheWithMode
-              : styleToClassCache;
-            return (
-              cache[style] || (cache[style] = style.replace(/\S+/g, "cm-$&"))
-            );
-          }
-          function buildLineContent(cm, lineView) {
-            var content = eltP(
-              "span",
-              null,
-              null,
-              webkit ? "padding-right: .1px" : null
-            );
-            var builder = {
-              pre: eltP("pre", [content], "CodeMirror-line"),
-              content,
-              col: 0,
-              pos: 0,
-              cm,
-              trailingSpace: false,
-              splitSpaces: cm.getOption("lineWrapping"),
-            };
-            lineView.measure = {};
-            for (
-              var i2 = 0;
-              i2 <= (lineView.rest ? lineView.rest.length : 0);
-              i2++
-            ) {
-              var line = i2 ? lineView.rest[i2 - 1] : lineView.line,
-                order2 = void 0;
-              builder.pos = 0;
-              builder.addToken = buildToken2;
-              if (
-                hasBadBidiRects(cm.display.measure) &&
-                (order2 = getOrder(line, cm.doc.direction))
-              ) {
-                builder.addToken = buildTokenBadBidi(builder.addToken, order2);
-              }
-              builder.map = [];
-              var allowFrontierUpdate =
-                lineView != cm.display.externalMeasured && lineNo(line);
-              insertLineContent(
-                line,
-                builder,
-                getLineStyles(cm, line, allowFrontierUpdate)
-              );
-              if (line.styleClasses) {
-                if (line.styleClasses.bgClass) {
-                  builder.bgClass = joinClasses(
-                    line.styleClasses.bgClass,
-                    builder.bgClass || ""
-                  );
-                }
-                if (line.styleClasses.textClass) {
-                  builder.textClass = joinClasses(
-                    line.styleClasses.textClass,
-                    builder.textClass || ""
-                  );
-                }
-              }
-              if (builder.map.length == 0) {
-                builder.map.push(
-                  0,
-                  0,
-                  builder.content.appendChild(
-                    zeroWidthElement(cm.display.measure)
-                  )
-                );
-              }
-              if (i2 == 0) {
-                lineView.measure.map = builder.map;
-                lineView.measure.cache = {};
-              } else {
-                (lineView.measure.maps || (lineView.measure.maps = [])).push(
-                  builder.map
-                );
-                (
-                  lineView.measure.caches || (lineView.measure.caches = [])
-                ).push({});
-              }
-            }
-            if (webkit) {
-              var last = builder.content.lastChild;
-              if (
-                /\bcm-tab\b/.test(last.className) ||
-                (last.querySelector && last.querySelector(".cm-tab"))
-              ) {
-                builder.content.className = "cm-tab-wrap-hack";
-              }
-            }
-            signal(cm, "renderLine", cm, lineView.line, builder.pre);
-            if (builder.pre.className) {
-              builder.textClass = joinClasses(
-                builder.pre.className,
-                builder.textClass || ""
-              );
-            }
-            return builder;
-          }
-          function defaultSpecialCharPlaceholder(ch2) {
-            var token2 = elt("span", "\u2022", "cm-invalidchar");
-            token2.title = "\\u" + ch2.charCodeAt(0).toString(16);
-            token2.setAttribute("aria-label", token2.title);
-            return token2;
-          }
-          function buildToken2(
-            builder,
-            text3,
-            style,
-            startStyle,
-            endStyle,
-            css,
-            attributes
-          ) {
-            if (!text3) {
-              return;
-            }
-            var displayText = builder.splitSpaces
-              ? splitSpaces(text3, builder.trailingSpace)
-              : text3;
-            var special = builder.cm.state.specialChars,
-              mustWrap = false;
-            var content;
-            if (!special.test(text3)) {
-              builder.col += text3.length;
-              content = document.createTextNode(displayText);
-              builder.map.push(
-                builder.pos,
-                builder.pos + text3.length,
-                content
-              );
-              if (ie2 && ie_version < 9) {
-                mustWrap = true;
-              }
-              builder.pos += text3.length;
-            } else {
-              content = document.createDocumentFragment();
-              var pos = 0;
-              while (true) {
-                special.lastIndex = pos;
-                var m = special.exec(text3);
-                var skipped = m ? m.index - pos : text3.length - pos;
-                if (skipped) {
-                  var txt = document.createTextNode(
-                    displayText.slice(pos, pos + skipped)
-                  );
-                  if (ie2 && ie_version < 9) {
-                    content.appendChild(elt("span", [txt]));
-                  } else {
-                    content.appendChild(txt);
-                  }
-                  builder.map.push(builder.pos, builder.pos + skipped, txt);
-                  builder.col += skipped;
-                  builder.pos += skipped;
-                }
-                if (!m) {
-                  break;
-                }
-                pos += skipped + 1;
-                var txt$1 = void 0;
-                if (m[0] == "	") {
-                  var tabSize = builder.cm.options.tabSize,
-                    tabWidth = tabSize - (builder.col % tabSize);
-                  txt$1 = content.appendChild(
-                    elt("span", spaceStr(tabWidth), "cm-tab")
-                  );
-                  txt$1.setAttribute("role", "presentation");
-                  txt$1.setAttribute("cm-text", "	");
-                  builder.col += tabWidth;
-                } else if (m[0] == "\r" || m[0] == "\n") {
-                  txt$1 = content.appendChild(
-                    elt(
-                      "span",
-                      m[0] == "\r" ? "\u240D" : "\u2424",
-                      "cm-invalidchar"
-                    )
-                  );
-                  txt$1.setAttribute("cm-text", m[0]);
-                  builder.col += 1;
-                } else {
-                  txt$1 = builder.cm.options.specialCharPlaceholder(m[0]);
-                  txt$1.setAttribute("cm-text", m[0]);
-                  if (ie2 && ie_version < 9) {
-                    content.appendChild(elt("span", [txt$1]));
-                  } else {
-                    content.appendChild(txt$1);
-                  }
-                  builder.col += 1;
-                }
-                builder.map.push(builder.pos, builder.pos + 1, txt$1);
-                builder.pos++;
-              }
-            }
-            builder.trailingSpace =
-              displayText.charCodeAt(text3.length - 1) == 32;
-            if (
-              style ||
-              startStyle ||
-              endStyle ||
-              mustWrap ||
-              css ||
-              attributes
-            ) {
-              var fullStyle = style || "";
-              if (startStyle) {
-                fullStyle += startStyle;
-              }
-              if (endStyle) {
-                fullStyle += endStyle;
-              }
-              var token2 = elt("span", [content], fullStyle, css);
-              if (attributes) {
-                for (var attr in attributes) {
-                  if (
-                    attributes.hasOwnProperty(attr) &&
-                    attr != "style" &&
-                    attr != "class"
-                  ) {
-                    token2.setAttribute(attr, attributes[attr]);
-                  }
-                }
-              }
-              return builder.content.appendChild(token2);
-            }
-            builder.content.appendChild(content);
-          }
-          function splitSpaces(text3, trailingBefore) {
-            if (text3.length > 1 && !/  /.test(text3)) {
-              return text3;
-            }
-            var spaceBefore = trailingBefore,
-              result2 = "";
-            for (var i2 = 0; i2 < text3.length; i2++) {
-              var ch2 = text3.charAt(i2);
-              if (
-                ch2 == " " &&
-                spaceBefore &&
-                (i2 == text3.length - 1 || text3.charCodeAt(i2 + 1) == 32)
-              ) {
-                ch2 = "\xA0";
-              }
-              result2 += ch2;
-              spaceBefore = ch2 == " ";
-            }
-            return result2;
-          }
-          function buildTokenBadBidi(inner, order2) {
-            return function (
-              builder,
-              text3,
-              style,
-              startStyle,
-              endStyle,
-              css,
-              attributes
-            ) {
-              style = style ? style + " cm-force-border" : "cm-force-border";
-              var start2 = builder.pos,
-                end2 = start2 + text3.length;
-              for (;;) {
-                var part2 = void 0;
-                for (var i2 = 0; i2 < order2.length; i2++) {
-                  part2 = order2[i2];
-                  if (part2.to > start2 && part2.from <= start2) {
-                    break;
-                  }
-                }
-                if (part2.to >= end2) {
-                  return inner(
-                    builder,
-                    text3,
-                    style,
-                    startStyle,
-                    endStyle,
-                    css,
-                    attributes
-                  );
-                }
-                inner(
-                  builder,
-                  text3.slice(0, part2.to - start2),
-                  style,
-                  startStyle,
-                  null,
-                  css,
-                  attributes
-                );
-                startStyle = null;
-                text3 = text3.slice(part2.to - start2);
-                start2 = part2.to;
-              }
-            };
-          }
-          function buildCollapsedSpan(builder, size, marker2, ignoreWidget) {
-            var widget = !ignoreWidget && marker2.widgetNode;
-            if (widget) {
-              builder.map.push(builder.pos, builder.pos + size, widget);
-            }
-            if (
-              !ignoreWidget &&
-              builder.cm.display.input.needsContentAttribute
-            ) {
-              if (!widget) {
-                widget = builder.content.appendChild(
-                  document.createElement("span")
-                );
-              }
-              widget.setAttribute("cm-marker", marker2.id);
-            }
-            if (widget) {
-              builder.cm.display.input.setUneditable(widget);
-              builder.content.appendChild(widget);
-            }
-            builder.pos += size;
-            builder.trailingSpace = false;
-          }
-          function insertLineContent(line, builder, styles2) {
-            var spans = line.markedSpans,
-              allText = line.text,
-              at = 0;
-            if (!spans) {
-              for (var i$12 = 1; i$12 < styles2.length; i$12 += 2) {
-                builder.addToken(
-                  builder,
-                  allText.slice(at, (at = styles2[i$12])),
-                  interpretTokenStyle(styles2[i$12 + 1], builder.cm.options)
-                );
-              }
-              return;
-            }
-            var len = allText.length,
-              pos = 0,
-              i2 = 1,
-              text3 = "",
-              style,
-              css;
-            var nextChange = 0,
-              spanStyle,
-              spanEndStyle,
-              spanStartStyle,
-              collapsed,
-              attributes;
-            for (;;) {
-              if (nextChange == pos) {
-                spanStyle = spanEndStyle = spanStartStyle = css = "";
-                attributes = null;
-                collapsed = null;
-                nextChange = Infinity;
-                var foundBookmarks = [],
-                  endStyles = void 0;
-                for (var j = 0; j < spans.length; ++j) {
-                  var sp = spans[j],
-                    m = sp.marker;
-                  if (m.type == "bookmark" && sp.from == pos && m.widgetNode) {
-                    foundBookmarks.push(m);
-                  } else if (
-                    sp.from <= pos &&
-                    (sp.to == null ||
-                      sp.to > pos ||
-                      (m.collapsed && sp.to == pos && sp.from == pos))
-                  ) {
-                    if (sp.to != null && sp.to != pos && nextChange > sp.to) {
-                      nextChange = sp.to;
-                      spanEndStyle = "";
-                    }
-                    if (m.className) {
-                      spanStyle += " " + m.className;
-                    }
-                    if (m.css) {
-                      css = (css ? css + ";" : "") + m.css;
-                    }
-                    if (m.startStyle && sp.from == pos) {
-                      spanStartStyle += " " + m.startStyle;
-                    }
-                    if (m.endStyle && sp.to == nextChange) {
-                      (endStyles || (endStyles = [])).push(m.endStyle, sp.to);
-                    }
-                    if (m.title) {
-                      (attributes || (attributes = {})).title = m.title;
-                    }
-                    if (m.attributes) {
-                      for (var attr in m.attributes) {
-                        (attributes || (attributes = {}))[attr] =
-                          m.attributes[attr];
-                      }
-                    }
-                    if (
-                      m.collapsed &&
-                      (!collapsed ||
-                        compareCollapsedMarkers(collapsed.marker, m) < 0)
-                    ) {
-                      collapsed = sp;
-                    }
-                  } else if (sp.from > pos && nextChange > sp.from) {
-                    nextChange = sp.from;
-                  }
-                }
-                if (endStyles) {
-                  for (var j$1 = 0; j$1 < endStyles.length; j$1 += 2) {
-                    if (endStyles[j$1 + 1] == nextChange) {
-                      spanEndStyle += " " + endStyles[j$1];
-                    }
-                  }
-                }
-                if (!collapsed || collapsed.from == pos) {
-                  for (var j$2 = 0; j$2 < foundBookmarks.length; ++j$2) {
-                    buildCollapsedSpan(builder, 0, foundBookmarks[j$2]);
-                  }
-                }
-                if (collapsed && (collapsed.from || 0) == pos) {
-                  buildCollapsedSpan(
-                    builder,
-                    (collapsed.to == null ? len + 1 : collapsed.to) - pos,
-                    collapsed.marker,
-                    collapsed.from == null
-                  );
-                  if (collapsed.to == null) {
-                    return;
-                  }
-                  if (collapsed.to == pos) {
-                    collapsed = false;
-                  }
-                }
-              }
-              if (pos >= len) {
-                break;
-              }
-              var upto = Math.min(len, nextChange);
-              while (true) {
-                if (text3) {
-                  var end2 = pos + text3.length;
-                  if (!collapsed) {
-                    var tokenText =
-                      end2 > upto ? text3.slice(0, upto - pos) : text3;
-                    builder.addToken(
-                      builder,
-                      tokenText,
-                      style ? style + spanStyle : spanStyle,
-                      spanStartStyle,
-                      pos + tokenText.length == nextChange ? spanEndStyle : "",
-                      css,
-                      attributes
-                    );
-                  }
-                  if (end2 >= upto) {
-                    text3 = text3.slice(upto - pos);
-                    pos = upto;
-                    break;
-                  }
-                  pos = end2;
-                  spanStartStyle = "";
-                }
-                text3 = allText.slice(at, (at = styles2[i2++]));
-                style = interpretTokenStyle(styles2[i2++], builder.cm.options);
-              }
-            }
-          }
-          function LineView(doc, line, lineN) {
-            this.line = line;
-            this.rest = visualLineContinued(line);
-            this.size = this.rest ? lineNo(lst(this.rest)) - lineN + 1 : 1;
-            this.node = this.text = null;
-            this.hidden = lineIsHidden(doc, line);
-          }
-          function buildViewArray(cm, from, to) {
-            var array = [],
-              nextPos;
-            for (var pos = from; pos < to; pos = nextPos) {
-              var view = new LineView(cm.doc, getLine2(cm.doc, pos), pos);
-              nextPos = pos + view.size;
-              array.push(view);
-            }
-            return array;
-          }
-          var operationGroup = null;
-          function pushOperation(op) {
-            if (operationGroup) {
-              operationGroup.ops.push(op);
-            } else {
-              op.ownsGroup = operationGroup = {
-                ops: [op],
-                delayedCallbacks: [],
-              };
-            }
-          }
-          function fireCallbacksForOps(group) {
-            var callbacks = group.delayedCallbacks,
-              i2 = 0;
-            do {
-              for (; i2 < callbacks.length; i2++) {
-                callbacks[i2].call(null);
-              }
-              for (var j = 0; j < group.ops.length; j++) {
-                var op = group.ops[j];
-                if (op.cursorActivityHandlers) {
-                  while (
-                    op.cursorActivityCalled < op.cursorActivityHandlers.length
-                  ) {
-                    op.cursorActivityHandlers[op.cursorActivityCalled++].call(
-                      null,
-                      op.cm
-                    );
-                  }
-                }
-              }
-            } while (i2 < callbacks.length);
-          }
-          function finishOperation(op, endCb) {
-            var group = op.ownsGroup;
-            if (!group) {
-              return;
-            }
-            try {
-              fireCallbacksForOps(group);
-            } finally {
-              operationGroup = null;
-              endCb(group);
-            }
-          }
-          var orphanDelayedCallbacks = null;
-          function signalLater(emitter, type2) {
-            var arr = getHandlers(emitter, type2);
-            if (!arr.length) {
-              return;
-            }
-            var args = Array.prototype.slice.call(arguments, 2),
-              list3;
-            if (operationGroup) {
-              list3 = operationGroup.delayedCallbacks;
-            } else if (orphanDelayedCallbacks) {
-              list3 = orphanDelayedCallbacks;
-            } else {
-              list3 = orphanDelayedCallbacks = [];
-              setTimeout(fireOrphanDelayed, 0);
-            }
-            var loop = function (i3) {
-              list3.push(function () {
-                return arr[i3].apply(null, args);
-              });
-            };
-            for (var i2 = 0; i2 < arr.length; ++i2) loop(i2);
-          }
-          function fireOrphanDelayed() {
-            var delayed = orphanDelayedCallbacks;
-            orphanDelayedCallbacks = null;
-            for (var i2 = 0; i2 < delayed.length; ++i2) {
-              delayed[i2]();
-            }
-          }
-          function updateLineForChanges(cm, lineView, lineN, dims) {
-            for (var j = 0; j < lineView.changes.length; j++) {
-              var type2 = lineView.changes[j];
-              if (type2 == "text") {
-                updateLineText(cm, lineView);
-              } else if (type2 == "gutter") {
-                updateLineGutter(cm, lineView, lineN, dims);
-              } else if (type2 == "class") {
-                updateLineClasses(cm, lineView);
-              } else if (type2 == "widget") {
-                updateLineWidgets(cm, lineView, dims);
-              }
-            }
-            lineView.changes = null;
-          }
-          function ensureLineWrapped(lineView) {
-            if (lineView.node == lineView.text) {
-              lineView.node = elt("div", null, null, "position: relative");
-              if (lineView.text.parentNode) {
-                lineView.text.parentNode.replaceChild(
-                  lineView.node,
-                  lineView.text
-                );
-              }
-              lineView.node.appendChild(lineView.text);
-              if (ie2 && ie_version < 8) {
-                lineView.node.style.zIndex = 2;
-              }
-            }
-            return lineView.node;
-          }
-          function updateLineBackground(cm, lineView) {
-            var cls = lineView.bgClass
-              ? lineView.bgClass + " " + (lineView.line.bgClass || "")
-              : lineView.line.bgClass;
-            if (cls) {
-              cls += " CodeMirror-linebackground";
-            }
-            if (lineView.background) {
-              if (cls) {
-                lineView.background.className = cls;
-              } else {
-                lineView.background.parentNode.removeChild(lineView.background);
-                lineView.background = null;
-              }
-            } else if (cls) {
-              var wrap2 = ensureLineWrapped(lineView);
-              lineView.background = wrap2.insertBefore(
-                elt("div", null, cls),
-                wrap2.firstChild
-              );
-              cm.display.input.setUneditable(lineView.background);
-            }
-          }
-          function getLineContent(cm, lineView) {
-            var ext = cm.display.externalMeasured;
-            if (ext && ext.line == lineView.line) {
-              cm.display.externalMeasured = null;
-              lineView.measure = ext.measure;
-              return ext.built;
-            }
-            return buildLineContent(cm, lineView);
-          }
-          function updateLineText(cm, lineView) {
-            var cls = lineView.text.className;
-            var built = getLineContent(cm, lineView);
-            if (lineView.text == lineView.node) {
-              lineView.node = built.pre;
-            }
-            lineView.text.parentNode.replaceChild(built.pre, lineView.text);
-            lineView.text = built.pre;
-            if (
-              built.bgClass != lineView.bgClass ||
-              built.textClass != lineView.textClass
-            ) {
-              lineView.bgClass = built.bgClass;
-              lineView.textClass = built.textClass;
-              updateLineClasses(cm, lineView);
-            } else if (cls) {
-              lineView.text.className = cls;
-            }
-          }
-          function updateLineClasses(cm, lineView) {
-            updateLineBackground(cm, lineView);
-            if (lineView.line.wrapClass) {
-              ensureLineWrapped(lineView).className = lineView.line.wrapClass;
-            } else if (lineView.node != lineView.text) {
-              lineView.node.className = "";
-            }
-            var textClass = lineView.textClass
-              ? lineView.textClass + " " + (lineView.line.textClass || "")
-              : lineView.line.textClass;
-            lineView.text.className = textClass || "";
-          }
-          function updateLineGutter(cm, lineView, lineN, dims) {
-            if (lineView.gutter) {
-              lineView.node.removeChild(lineView.gutter);
-              lineView.gutter = null;
-            }
-            if (lineView.gutterBackground) {
-              lineView.node.removeChild(lineView.gutterBackground);
-              lineView.gutterBackground = null;
-            }
-            if (lineView.line.gutterClass) {
-              var wrap2 = ensureLineWrapped(lineView);
-              lineView.gutterBackground = elt(
-                "div",
-                null,
-                "CodeMirror-gutter-background " + lineView.line.gutterClass,
-                "left: " +
-                  (cm.options.fixedGutter
-                    ? dims.fixedPos
-                    : -dims.gutterTotalWidth) +
-                  "px; width: " +
-                  dims.gutterTotalWidth +
-                  "px"
-              );
-              cm.display.input.setUneditable(lineView.gutterBackground);
-              wrap2.insertBefore(lineView.gutterBackground, lineView.text);
-            }
-            var markers = lineView.line.gutterMarkers;
-            if (cm.options.lineNumbers || markers) {
-              var wrap$12 = ensureLineWrapped(lineView);
-              var gutterWrap = (lineView.gutter = elt(
-                "div",
-                null,
-                "CodeMirror-gutter-wrapper",
-                "left: " +
-                  (cm.options.fixedGutter
-                    ? dims.fixedPos
-                    : -dims.gutterTotalWidth) +
-                  "px"
-              ));
-              gutterWrap.setAttribute("aria-hidden", "true");
-              cm.display.input.setUneditable(gutterWrap);
-              wrap$12.insertBefore(gutterWrap, lineView.text);
-              if (lineView.line.gutterClass) {
-                gutterWrap.className += " " + lineView.line.gutterClass;
-              }
-              if (
-                cm.options.lineNumbers &&
-                (!markers || !markers["CodeMirror-linenumbers"])
-              ) {
-                lineView.lineNumber = gutterWrap.appendChild(
-                  elt(
-                    "div",
-                    lineNumberFor(cm.options, lineN),
-                    "CodeMirror-linenumber CodeMirror-gutter-elt",
-                    "left: " +
-                      dims.gutterLeft["CodeMirror-linenumbers"] +
-                      "px; width: " +
-                      cm.display.lineNumInnerWidth +
-                      "px"
-                  )
-                );
-              }
-              if (markers) {
-                for (var k = 0; k < cm.display.gutterSpecs.length; ++k) {
-                  var id2 = cm.display.gutterSpecs[k].className,
-                    found = markers.hasOwnProperty(id2) && markers[id2];
-                  if (found) {
-                    gutterWrap.appendChild(
-                      elt(
-                        "div",
-                        [found],
-                        "CodeMirror-gutter-elt",
-                        "left: " +
-                          dims.gutterLeft[id2] +
-                          "px; width: " +
-                          dims.gutterWidth[id2] +
-                          "px"
-                      )
-                    );
-                  }
-                }
-              }
-            }
-          }
-          function updateLineWidgets(cm, lineView, dims) {
-            if (lineView.alignable) {
-              lineView.alignable = null;
-            }
-            var isWidget = classTest("CodeMirror-linewidget");
-            for (
-              var node = lineView.node.firstChild, next = void 0;
-              node;
-              node = next
-            ) {
-              next = node.nextSibling;
-              if (isWidget.test(node.className)) {
-                lineView.node.removeChild(node);
-              }
-            }
-            insertLineWidgets(cm, lineView, dims);
-          }
-          function buildLineElement(cm, lineView, lineN, dims) {
-            var built = getLineContent(cm, lineView);
-            lineView.text = lineView.node = built.pre;
-            if (built.bgClass) {
-              lineView.bgClass = built.bgClass;
-            }
-            if (built.textClass) {
-              lineView.textClass = built.textClass;
-            }
-            updateLineClasses(cm, lineView);
-            updateLineGutter(cm, lineView, lineN, dims);
-            insertLineWidgets(cm, lineView, dims);
-            return lineView.node;
-          }
-          function insertLineWidgets(cm, lineView, dims) {
-            insertLineWidgetsFor(cm, lineView.line, lineView, dims, true);
-            if (lineView.rest) {
-              for (var i2 = 0; i2 < lineView.rest.length; i2++) {
-                insertLineWidgetsFor(
-                  cm,
-                  lineView.rest[i2],
-                  lineView,
-                  dims,
-                  false
-                );
-              }
-            }
-          }
-          function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
-            if (!line.widgets) {
-              return;
-            }
-            var wrap2 = ensureLineWrapped(lineView);
-            for (var i2 = 0, ws2 = line.widgets; i2 < ws2.length; ++i2) {
-              var widget = ws2[i2],
-                node = elt(
-                  "div",
-                  [widget.node],
-                  "CodeMirror-linewidget" +
-                    (widget.className ? " " + widget.className : "")
-                );
-              if (!widget.handleMouseEvents) {
-                node.setAttribute("cm-ignore-events", "true");
-              }
-              positionLineWidget(widget, node, lineView, dims);
-              cm.display.input.setUneditable(node);
-              if (allowAbove && widget.above) {
-                wrap2.insertBefore(node, lineView.gutter || lineView.text);
-              } else {
-                wrap2.appendChild(node);
-              }
-              signalLater(widget, "redraw");
-            }
-          }
-          function positionLineWidget(widget, node, lineView, dims) {
-            if (widget.noHScroll) {
-              (lineView.alignable || (lineView.alignable = [])).push(node);
-              var width = dims.wrapperWidth;
-              node.style.left = dims.fixedPos + "px";
-              if (!widget.coverGutter) {
-                width -= dims.gutterTotalWidth;
-                node.style.paddingLeft = dims.gutterTotalWidth + "px";
-              }
-              node.style.width = width + "px";
-            }
-            if (widget.coverGutter) {
-              node.style.zIndex = 5;
-              node.style.position = "relative";
-              if (!widget.noHScroll) {
-                node.style.marginLeft = -dims.gutterTotalWidth + "px";
-              }
-            }
-          }
-          function widgetHeight(widget) {
-            if (widget.height != null) {
-              return widget.height;
-            }
-            var cm = widget.doc.cm;
-            if (!cm) {
-              return 0;
-            }
-            if (!contains(document.body, widget.node)) {
-              var parentStyle = "position: relative;";
-              if (widget.coverGutter) {
-                parentStyle +=
-                  "margin-left: -" + cm.display.gutters.offsetWidth + "px;";
-              }
-              if (widget.noHScroll) {
-                parentStyle +=
-                  "width: " + cm.display.wrapper.clientWidth + "px;";
-              }
-              removeChildrenAndAdd(
-                cm.display.measure,
-                elt("div", [widget.node], null, parentStyle)
-              );
-            }
-            return (widget.height = widget.node.parentNode.offsetHeight);
-          }
-          function eventInWidget(display, e) {
-            for (
-              var n2 = e_target(e);
-              n2 != display.wrapper;
-              n2 = n2.parentNode
-            ) {
-              if (
-                !n2 ||
-                (n2.nodeType == 1 &&
-                  n2.getAttribute("cm-ignore-events") == "true") ||
-                (n2.parentNode == display.sizer && n2 != display.mover)
-              ) {
-                return true;
-              }
-            }
-          }
-          function paddingTop(display) {
-            return display.lineSpace.offsetTop;
-          }
-          function paddingVert(display) {
-            return display.mover.offsetHeight - display.lineSpace.offsetHeight;
-          }
-          function paddingH(display) {
-            if (display.cachedPaddingH) {
-              return display.cachedPaddingH;
-            }
-            var e = removeChildrenAndAdd(
-              display.measure,
-              elt("pre", "x", "CodeMirror-line-like")
-            );
-            var style = window.getComputedStyle
-              ? window.getComputedStyle(e)
-              : e.currentStyle;
-            var data = {
-              left: parseInt(style.paddingLeft),
-              right: parseInt(style.paddingRight),
-            };
-            if (!isNaN(data.left) && !isNaN(data.right)) {
-              display.cachedPaddingH = data;
-            }
-            return data;
-          }
-          function scrollGap(cm) {
-            return scrollerGap - cm.display.nativeBarWidth;
-          }
-          function displayWidth(cm) {
-            return (
-              cm.display.scroller.clientWidth -
-              scrollGap(cm) -
-              cm.display.barWidth
-            );
-          }
-          function displayHeight(cm) {
-            return (
-              cm.display.scroller.clientHeight -
-              scrollGap(cm) -
-              cm.display.barHeight
-            );
-          }
-          function ensureLineHeights(cm, lineView, rect2) {
-            var wrapping = cm.options.lineWrapping;
-            var curWidth = wrapping && displayWidth(cm);
-            if (
-              !lineView.measure.heights ||
-              (wrapping && lineView.measure.width != curWidth)
-            ) {
-              var heights = (lineView.measure.heights = []);
-              if (wrapping) {
-                lineView.measure.width = curWidth;
-                var rects = lineView.text.firstChild.getClientRects();
-                for (var i2 = 0; i2 < rects.length - 1; i2++) {
-                  var cur = rects[i2],
-                    next = rects[i2 + 1];
-                  if (Math.abs(cur.bottom - next.bottom) > 2) {
-                    heights.push((cur.bottom + next.top) / 2 - rect2.top);
-                  }
-                }
-              }
-              heights.push(rect2.bottom - rect2.top);
-            }
-          }
-          function mapFromLineView(lineView, line, lineN) {
-            if (lineView.line == line) {
-              return {
-                map: lineView.measure.map,
-                cache: lineView.measure.cache,
-              };
-            }
-            if (lineView.rest) {
-              for (var i2 = 0; i2 < lineView.rest.length; i2++) {
-                if (lineView.rest[i2] == line) {
-                  return {
-                    map: lineView.measure.maps[i2],
-                    cache: lineView.measure.caches[i2],
-                  };
-                }
-              }
-              for (var i$12 = 0; i$12 < lineView.rest.length; i$12++) {
-                if (lineNo(lineView.rest[i$12]) > lineN) {
-                  return {
-                    map: lineView.measure.maps[i$12],
-                    cache: lineView.measure.caches[i$12],
-                    before: true,
-                  };
-                }
-              }
-            }
-          }
-          function updateExternalMeasurement(cm, line) {
-            line = visualLine(line);
-            var lineN = lineNo(line);
-            var view = (cm.display.externalMeasured = new LineView(
-              cm.doc,
-              line,
-              lineN
-            ));
-            view.lineN = lineN;
-            var built = (view.built = buildLineContent(cm, view));
-            view.text = built.pre;
-            removeChildrenAndAdd(cm.display.lineMeasure, built.pre);
-            return view;
-          }
-          function measureChar(cm, line, ch2, bias) {
-            return measureCharPrepared(
-              cm,
-              prepareMeasureForLine(cm, line),
-              ch2,
-              bias
-            );
-          }
-          function findViewForLine(cm, lineN) {
-            if (lineN >= cm.display.viewFrom && lineN < cm.display.viewTo) {
-              return cm.display.view[findViewIndex(cm, lineN)];
-            }
-            var ext = cm.display.externalMeasured;
-            if (ext && lineN >= ext.lineN && lineN < ext.lineN + ext.size) {
-              return ext;
-            }
-          }
-          function prepareMeasureForLine(cm, line) {
-            var lineN = lineNo(line);
-            var view = findViewForLine(cm, lineN);
-            if (view && !view.text) {
-              view = null;
-            } else if (view && view.changes) {
-              updateLineForChanges(cm, view, lineN, getDimensions(cm));
-              cm.curOp.forceUpdate = true;
-            }
-            if (!view) {
-              view = updateExternalMeasurement(cm, line);
-            }
-            var info2 = mapFromLineView(view, line, lineN);
-            return {
-              line,
-              view,
-              rect: null,
-              map: info2.map,
-              cache: info2.cache,
-              before: info2.before,
-              hasHeights: false,
-            };
-          }
-          function measureCharPrepared(cm, prepared, ch2, bias, varHeight) {
-            if (prepared.before) {
-              ch2 = -1;
-            }
-            var key = ch2 + (bias || ""),
-              found;
-            if (prepared.cache.hasOwnProperty(key)) {
-              found = prepared.cache[key];
-            } else {
-              if (!prepared.rect) {
-                prepared.rect = prepared.view.text.getBoundingClientRect();
-              }
-              if (!prepared.hasHeights) {
-                ensureLineHeights(cm, prepared.view, prepared.rect);
-                prepared.hasHeights = true;
-              }
-              found = measureCharInner(cm, prepared, ch2, bias);
-              if (!found.bogus) {
-                prepared.cache[key] = found;
-              }
-            }
-            return {
-              left: found.left,
-              right: found.right,
-              top: varHeight ? found.rtop : found.top,
-              bottom: varHeight ? found.rbottom : found.bottom,
-            };
-          }
-          var nullRect = { left: 0, right: 0, top: 0, bottom: 0 };
-          function nodeAndOffsetInLineMap(map3, ch2, bias) {
-            var node, start2, end2, collapse, mStart, mEnd;
-            for (var i2 = 0; i2 < map3.length; i2 += 3) {
-              mStart = map3[i2];
-              mEnd = map3[i2 + 1];
-              if (ch2 < mStart) {
-                start2 = 0;
-                end2 = 1;
-                collapse = "left";
-              } else if (ch2 < mEnd) {
-                start2 = ch2 - mStart;
-                end2 = start2 + 1;
-              } else if (
-                i2 == map3.length - 3 ||
-                (ch2 == mEnd && map3[i2 + 3] > ch2)
-              ) {
-                end2 = mEnd - mStart;
-                start2 = end2 - 1;
-                if (ch2 >= mEnd) {
-                  collapse = "right";
-                }
-              }
-              if (start2 != null) {
-                node = map3[i2 + 2];
-                if (
-                  mStart == mEnd &&
-                  bias == (node.insertLeft ? "left" : "right")
-                ) {
-                  collapse = bias;
-                }
-                if (bias == "left" && start2 == 0) {
-                  while (
-                    i2 &&
-                    map3[i2 - 2] == map3[i2 - 3] &&
-                    map3[i2 - 1].insertLeft
-                  ) {
-                    node = map3[(i2 -= 3) + 2];
-                    collapse = "left";
-                  }
-                }
-                if (bias == "right" && start2 == mEnd - mStart) {
-                  while (
-                    i2 < map3.length - 3 &&
-                    map3[i2 + 3] == map3[i2 + 4] &&
-                    !map3[i2 + 5].insertLeft
-                  ) {
-                    node = map3[(i2 += 3) + 2];
-                    collapse = "right";
-                  }
-                }
-                break;
-              }
-            }
-            return {
-              node,
-              start: start2,
-              end: end2,
-              collapse,
-              coverStart: mStart,
-              coverEnd: mEnd,
-            };
-          }
-          function getUsefulRect(rects, bias) {
-            var rect2 = nullRect;
-            if (bias == "left") {
-              for (var i2 = 0; i2 < rects.length; i2++) {
-                if ((rect2 = rects[i2]).left != rect2.right) {
-                  break;
-                }
-              }
-            } else {
-              for (var i$12 = rects.length - 1; i$12 >= 0; i$12--) {
-                if ((rect2 = rects[i$12]).left != rect2.right) {
-                  break;
-                }
-              }
-            }
-            return rect2;
-          }
-          function measureCharInner(cm, prepared, ch2, bias) {
-            var place = nodeAndOffsetInLineMap(prepared.map, ch2, bias);
-            var node = place.node,
-              start2 = place.start,
-              end2 = place.end,
-              collapse = place.collapse;
-            var rect2;
-            if (node.nodeType == 3) {
-              for (var i$12 = 0; i$12 < 4; i$12++) {
-                while (
-                  start2 &&
-                  isExtendingChar(
-                    prepared.line.text.charAt(place.coverStart + start2)
-                  )
-                ) {
-                  --start2;
-                }
-                while (
-                  place.coverStart + end2 < place.coverEnd &&
-                  isExtendingChar(
-                    prepared.line.text.charAt(place.coverStart + end2)
-                  )
-                ) {
-                  ++end2;
-                }
-                if (
-                  ie2 &&
-                  ie_version < 9 &&
-                  start2 == 0 &&
-                  end2 == place.coverEnd - place.coverStart
-                ) {
-                  rect2 = node.parentNode.getBoundingClientRect();
-                } else {
-                  rect2 = getUsefulRect(
-                    range2(node, start2, end2).getClientRects(),
-                    bias
-                  );
-                }
-                if (rect2.left || rect2.right || start2 == 0) {
-                  break;
-                }
-                end2 = start2;
-                start2 = start2 - 1;
-                collapse = "right";
-              }
-              if (ie2 && ie_version < 11) {
-                rect2 = maybeUpdateRectForZooming(cm.display.measure, rect2);
-              }
-            } else {
-              if (start2 > 0) {
-                collapse = bias = "right";
-              }
-              var rects;
-              if (
-                cm.options.lineWrapping &&
-                (rects = node.getClientRects()).length > 1
-              ) {
-                rect2 = rects[bias == "right" ? rects.length - 1 : 0];
-              } else {
-                rect2 = node.getBoundingClientRect();
-              }
-            }
-            if (
-              ie2 &&
-              ie_version < 9 &&
-              !start2 &&
-              (!rect2 || (!rect2.left && !rect2.right))
-            ) {
-              var rSpan = node.parentNode.getClientRects()[0];
-              if (rSpan) {
-                rect2 = {
-                  left: rSpan.left,
-                  right: rSpan.left + charWidth(cm.display),
-                  top: rSpan.top,
-                  bottom: rSpan.bottom,
-                };
-              } else {
-                rect2 = nullRect;
-              }
-            }
-            var rtop = rect2.top - prepared.rect.top,
-              rbot = rect2.bottom - prepared.rect.top;
-            var mid2 = (rtop + rbot) / 2;
-            var heights = prepared.view.measure.heights;
-            var i2 = 0;
-            for (; i2 < heights.length - 1; i2++) {
-              if (mid2 < heights[i2]) {
-                break;
-              }
-            }
-            var top2 = i2 ? heights[i2 - 1] : 0,
-              bot2 = heights[i2];
-            var result2 = {
-              left:
-                (collapse == "right" ? rect2.right : rect2.left) -
-                prepared.rect.left,
-              right:
-                (collapse == "left" ? rect2.left : rect2.right) -
-                prepared.rect.left,
-              top: top2,
-              bottom: bot2,
-            };
-            if (!rect2.left && !rect2.right) {
-              result2.bogus = true;
-            }
-            if (!cm.options.singleCursorHeightPerLine) {
-              result2.rtop = rtop;
-              result2.rbottom = rbot;
-            }
-            return result2;
-          }
-          function maybeUpdateRectForZooming(measure, rect2) {
-            if (
-              !window.screen ||
-              screen.logicalXDPI == null ||
-              screen.logicalXDPI == screen.deviceXDPI ||
-              !hasBadZoomedRects(measure)
-            ) {
-              return rect2;
-            }
-            var scaleX = screen.logicalXDPI / screen.deviceXDPI;
-            var scaleY = screen.logicalYDPI / screen.deviceYDPI;
-            return {
-              left: rect2.left * scaleX,
-              right: rect2.right * scaleX,
-              top: rect2.top * scaleY,
-              bottom: rect2.bottom * scaleY,
-            };
-          }
-          function clearLineMeasurementCacheFor(lineView) {
-            if (lineView.measure) {
-              lineView.measure.cache = {};
-              lineView.measure.heights = null;
-              if (lineView.rest) {
-                for (var i2 = 0; i2 < lineView.rest.length; i2++) {
-                  lineView.measure.caches[i2] = {};
-                }
-              }
-            }
-          }
-          function clearLineMeasurementCache(cm) {
-            cm.display.externalMeasure = null;
-            removeChildren(cm.display.lineMeasure);
-            for (var i2 = 0; i2 < cm.display.view.length; i2++) {
-              clearLineMeasurementCacheFor(cm.display.view[i2]);
-            }
-          }
-          function clearCaches(cm) {
-            clearLineMeasurementCache(cm);
-            cm.display.cachedCharWidth =
-              cm.display.cachedTextHeight =
-              cm.display.cachedPaddingH =
-                null;
-            if (!cm.options.lineWrapping) {
-              cm.display.maxLineChanged = true;
-            }
-            cm.display.lineNumChars = null;
-          }
-          function pageScrollX() {
-            if (chrome && android) {
-              return -(
-                document.body.getBoundingClientRect().left -
-                parseInt(getComputedStyle(document.body).marginLeft)
-              );
-            }
-            return (
-              window.pageXOffset ||
-              (document.documentElement || document.body).scrollLeft
-            );
-          }
-          function pageScrollY() {
-            if (chrome && android) {
-              return -(
-                document.body.getBoundingClientRect().top -
-                parseInt(getComputedStyle(document.body).marginTop)
-              );
-            }
-            return (
-              window.pageYOffset ||
-              (document.documentElement || document.body).scrollTop
-            );
-          }
-          function widgetTopHeight(lineObj) {
-            var ref = visualLine(lineObj);
-            var widgets = ref.widgets;
-            var height = 0;
-            if (widgets) {
-              for (var i2 = 0; i2 < widgets.length; ++i2) {
-                if (widgets[i2].above) {
-                  height += widgetHeight(widgets[i2]);
-                }
-              }
-            }
-            return height;
-          }
-          function intoCoordSystem(
-            cm,
-            lineObj,
-            rect2,
-            context,
-            includeWidgets
-          ) {
-            if (!includeWidgets) {
-              var height = widgetTopHeight(lineObj);
-              rect2.top += height;
-              rect2.bottom += height;
-            }
-            if (context == "line") {
-              return rect2;
-            }
-            if (!context) {
-              context = "local";
-            }
-            var yOff = heightAtLine(lineObj);
-            if (context == "local") {
-              yOff += paddingTop(cm.display);
-            } else {
-              yOff -= cm.display.viewOffset;
-            }
-            if (context == "page" || context == "window") {
-              var lOff = cm.display.lineSpace.getBoundingClientRect();
-              yOff += lOff.top + (context == "window" ? 0 : pageScrollY());
-              var xOff = lOff.left + (context == "window" ? 0 : pageScrollX());
-              rect2.left += xOff;
-              rect2.right += xOff;
-            }
-            rect2.top += yOff;
-            rect2.bottom += yOff;
-            return rect2;
-          }
-          function fromCoordSystem(cm, coords, context) {
-            if (context == "div") {
-              return coords;
-            }
-            var left = coords.left,
-              top2 = coords.top;
-            if (context == "page") {
-              left -= pageScrollX();
-              top2 -= pageScrollY();
-            } else if (context == "local" || !context) {
-              var localBox = cm.display.sizer.getBoundingClientRect();
-              left += localBox.left;
-              top2 += localBox.top;
-            }
-            var lineSpaceBox = cm.display.lineSpace.getBoundingClientRect();
-            return {
-              left: left - lineSpaceBox.left,
-              top: top2 - lineSpaceBox.top,
-            };
-          }
-          function charCoords(cm, pos, context, lineObj, bias) {
-            if (!lineObj) {
-              lineObj = getLine2(cm.doc, pos.line);
-            }
-            return intoCoordSystem(
-              cm,
-              lineObj,
-              measureChar(cm, lineObj, pos.ch, bias),
-              context
-            );
-          }
-          function cursorCoords(
-            cm,
-            pos,
-            context,
-            lineObj,
-            preparedMeasure,
-            varHeight
-          ) {
-            lineObj = lineObj || getLine2(cm.doc, pos.line);
-            if (!preparedMeasure) {
-              preparedMeasure = prepareMeasureForLine(cm, lineObj);
-            }
-            function get(ch3, right) {
-              var m = measureCharPrepared(
-                cm,
-                preparedMeasure,
-                ch3,
-                right ? "right" : "left",
-                varHeight
-              );
-              if (right) {
-                m.left = m.right;
-              } else {
-                m.right = m.left;
-              }
-              return intoCoordSystem(cm, lineObj, m, context);
-            }
-            var order2 = getOrder(lineObj, cm.doc.direction),
-              ch2 = pos.ch,
-              sticky = pos.sticky;
-            if (ch2 >= lineObj.text.length) {
-              ch2 = lineObj.text.length;
-              sticky = "before";
-            } else if (ch2 <= 0) {
-              ch2 = 0;
-              sticky = "after";
-            }
-            if (!order2) {
-              return get(
-                sticky == "before" ? ch2 - 1 : ch2,
-                sticky == "before"
-              );
-            }
-            function getBidi(ch3, partPos2, invert) {
-              var part2 = order2[partPos2],
-                right = part2.level == 1;
-              return get(invert ? ch3 - 1 : ch3, right != invert);
-            }
-            var partPos = getBidiPartAt(order2, ch2, sticky);
-            var other = bidiOther;
-            var val = getBidi(ch2, partPos, sticky == "before");
-            if (other != null) {
-              val.other = getBidi(ch2, other, sticky != "before");
-            }
-            return val;
-          }
-          function estimateCoords(cm, pos) {
-            var left = 0;
-            pos = clipPos(cm.doc, pos);
-            if (!cm.options.lineWrapping) {
-              left = charWidth(cm.display) * pos.ch;
-            }
-            var lineObj = getLine2(cm.doc, pos.line);
-            var top2 = heightAtLine(lineObj) + paddingTop(cm.display);
-            return {
-              left,
-              right: left,
-              top: top2,
-              bottom: top2 + lineObj.height,
-            };
-          }
-          function PosWithInfo(line, ch2, sticky, outside, xRel) {
-            var pos = Pos(line, ch2, sticky);
-            pos.xRel = xRel;
-            if (outside) {
-              pos.outside = outside;
-            }
-            return pos;
-          }
-          function coordsChar(cm, x2, y2) {
-            var doc = cm.doc;
-            y2 += cm.display.viewOffset;
-            if (y2 < 0) {
-              return PosWithInfo(doc.first, 0, null, -1, -1);
-            }
-            var lineN = lineAtHeight(doc, y2),
-              last = doc.first + doc.size - 1;
-            if (lineN > last) {
-              return PosWithInfo(
-                doc.first + doc.size - 1,
-                getLine2(doc, last).text.length,
-                null,
-                1,
-                1
-              );
-            }
-            if (x2 < 0) {
-              x2 = 0;
-            }
-            var lineObj = getLine2(doc, lineN);
-            for (;;) {
-              var found = coordsCharInner(cm, lineObj, lineN, x2, y2);
-              var collapsed = collapsedSpanAround(
-                lineObj,
-                found.ch + (found.xRel > 0 || found.outside > 0 ? 1 : 0)
-              );
-              if (!collapsed) {
-                return found;
-              }
-              var rangeEnd = collapsed.find(1);
-              if (rangeEnd.line == lineN) {
-                return rangeEnd;
-              }
-              lineObj = getLine2(doc, (lineN = rangeEnd.line));
-            }
-          }
-          function wrappedLineExtent(cm, lineObj, preparedMeasure, y2) {
-            y2 -= widgetTopHeight(lineObj);
-            var end2 = lineObj.text.length;
-            var begin = findFirst(
-              function (ch2) {
-                return (
-                  measureCharPrepared(cm, preparedMeasure, ch2 - 1).bottom <= y2
-                );
-              },
-              end2,
-              0
-            );
-            end2 = findFirst(
-              function (ch2) {
-                return measureCharPrepared(cm, preparedMeasure, ch2).top > y2;
-              },
-              begin,
-              end2
-            );
-            return { begin, end: end2 };
-          }
-          function wrappedLineExtentChar(
-            cm,
-            lineObj,
-            preparedMeasure,
-            target2
-          ) {
-            if (!preparedMeasure) {
-              preparedMeasure = prepareMeasureForLine(cm, lineObj);
-            }
-            var targetTop = intoCoordSystem(
-              cm,
-              lineObj,
-              measureCharPrepared(cm, preparedMeasure, target2),
-              "line"
-            ).top;
-            return wrappedLineExtent(cm, lineObj, preparedMeasure, targetTop);
-          }
-          function boxIsAfter(box, x2, y2, left) {
-            return box.bottom <= y2
-              ? false
-              : box.top > y2
-              ? true
-              : (left ? box.left : box.right) > x2;
-          }
-          function coordsCharInner(cm, lineObj, lineNo2, x2, y2) {
-            y2 -= heightAtLine(lineObj);
-            var preparedMeasure = prepareMeasureForLine(cm, lineObj);
-            var widgetHeight2 = widgetTopHeight(lineObj);
-            var begin = 0,
-              end2 = lineObj.text.length,
-              ltr = true;
-            var order2 = getOrder(lineObj, cm.doc.direction);
-            if (order2) {
-              var part2 = (
-                cm.options.lineWrapping ? coordsBidiPartWrapped : coordsBidiPart
-              )(cm, lineObj, lineNo2, preparedMeasure, order2, x2, y2);
-              ltr = part2.level != 1;
-              begin = ltr ? part2.from : part2.to - 1;
-              end2 = ltr ? part2.to : part2.from - 1;
-            }
-            var chAround = null,
-              boxAround = null;
-            var ch2 = findFirst(
-              function (ch3) {
-                var box = measureCharPrepared(cm, preparedMeasure, ch3);
-                box.top += widgetHeight2;
-                box.bottom += widgetHeight2;
-                if (!boxIsAfter(box, x2, y2, false)) {
-                  return false;
-                }
-                if (box.top <= y2 && box.left <= x2) {
-                  chAround = ch3;
-                  boxAround = box;
-                }
-                return true;
-              },
-              begin,
-              end2
-            );
-            var baseX,
-              sticky,
-              outside = false;
-            if (boxAround) {
-              var atLeft = x2 - boxAround.left < boxAround.right - x2,
-                atStart = atLeft == ltr;
-              ch2 = chAround + (atStart ? 0 : 1);
-              sticky = atStart ? "after" : "before";
-              baseX = atLeft ? boxAround.left : boxAround.right;
-            } else {
-              if (!ltr && (ch2 == end2 || ch2 == begin)) {
-                ch2++;
-              }
-              sticky =
-                ch2 == 0
-                  ? "after"
-                  : ch2 == lineObj.text.length
-                  ? "before"
-                  : measureCharPrepared(
-                      cm,
-                      preparedMeasure,
-                      ch2 - (ltr ? 1 : 0)
-                    ).bottom +
-                      widgetHeight2 <=
-                      y2 ==
-                    ltr
-                  ? "after"
-                  : "before";
-              var coords = cursorCoords(
-                cm,
-                Pos(lineNo2, ch2, sticky),
-                "line",
-                lineObj,
-                preparedMeasure
-              );
-              baseX = coords.left;
-              outside = y2 < coords.top ? -1 : y2 >= coords.bottom ? 1 : 0;
-            }
-            ch2 = skipExtendingChars(lineObj.text, ch2, 1);
-            return PosWithInfo(lineNo2, ch2, sticky, outside, x2 - baseX);
-          }
-          function coordsBidiPart(
-            cm,
-            lineObj,
-            lineNo2,
-            preparedMeasure,
-            order2,
-            x2,
-            y2
-          ) {
-            var index = findFirst(
-              function (i2) {
-                var part3 = order2[i2],
-                  ltr2 = part3.level != 1;
-                return boxIsAfter(
-                  cursorCoords(
-                    cm,
-                    Pos(
-                      lineNo2,
-                      ltr2 ? part3.to : part3.from,
-                      ltr2 ? "before" : "after"
-                    ),
-                    "line",
-                    lineObj,
-                    preparedMeasure
-                  ),
-                  x2,
-                  y2,
-                  true
-                );
-              },
-              0,
-              order2.length - 1
-            );
-            var part2 = order2[index];
-            if (index > 0) {
-              var ltr = part2.level != 1;
-              var start2 = cursorCoords(
-                cm,
-                Pos(
-                  lineNo2,
-                  ltr ? part2.from : part2.to,
-                  ltr ? "after" : "before"
-                ),
-                "line",
-                lineObj,
-                preparedMeasure
-              );
-              if (boxIsAfter(start2, x2, y2, true) && start2.top > y2) {
-                part2 = order2[index - 1];
-              }
-            }
-            return part2;
-          }
-          function coordsBidiPartWrapped(
-            cm,
-            lineObj,
-            _lineNo,
-            preparedMeasure,
-            order2,
-            x2,
-            y2
-          ) {
-            var ref = wrappedLineExtent(cm, lineObj, preparedMeasure, y2);
-            var begin = ref.begin;
-            var end2 = ref.end;
-            if (/\s/.test(lineObj.text.charAt(end2 - 1))) {
-              end2--;
-            }
-            var part2 = null,
-              closestDist = null;
-            for (var i2 = 0; i2 < order2.length; i2++) {
-              var p2 = order2[i2];
-              if (p2.from >= end2 || p2.to <= begin) {
-                continue;
-              }
-              var ltr = p2.level != 1;
-              var endX = measureCharPrepared(
-                cm,
-                preparedMeasure,
-                ltr ? Math.min(end2, p2.to) - 1 : Math.max(begin, p2.from)
-              ).right;
-              var dist2 = endX < x2 ? x2 - endX + 1e9 : endX - x2;
-              if (!part2 || closestDist > dist2) {
-                part2 = p2;
-                closestDist = dist2;
-              }
-            }
-            if (!part2) {
-              part2 = order2[order2.length - 1];
-            }
-            if (part2.from < begin) {
-              part2 = { from: begin, to: part2.to, level: part2.level };
-            }
-            if (part2.to > end2) {
-              part2 = { from: part2.from, to: end2, level: part2.level };
-            }
-            return part2;
-          }
-          var measureText;
-          function textHeight(display) {
-            if (display.cachedTextHeight != null) {
-              return display.cachedTextHeight;
-            }
-            if (measureText == null) {
-              measureText = elt("pre", null, "CodeMirror-line-like");
-              for (var i2 = 0; i2 < 49; ++i2) {
-                measureText.appendChild(document.createTextNode("x"));
-                measureText.appendChild(elt("br"));
-              }
-              measureText.appendChild(document.createTextNode("x"));
-            }
-            removeChildrenAndAdd(display.measure, measureText);
-            var height = measureText.offsetHeight / 50;
-            if (height > 3) {
-              display.cachedTextHeight = height;
-            }
-            removeChildren(display.measure);
-            return height || 1;
-          }
-          function charWidth(display) {
-            if (display.cachedCharWidth != null) {
-              return display.cachedCharWidth;
-            }
-            var anchor = elt("span", "xxxxxxxxxx");
-            var pre2 = elt("pre", [anchor], "CodeMirror-line-like");
-            removeChildrenAndAdd(display.measure, pre2);
-            var rect2 = anchor.getBoundingClientRect(),
-              width = (rect2.right - rect2.left) / 10;
-            if (width > 2) {
-              display.cachedCharWidth = width;
-            }
-            return width || 10;
-          }
-          function getDimensions(cm) {
-            var d = cm.display,
-              left = {},
-              width = {};
-            var gutterLeft = d.gutters.clientLeft;
-            for (
-              var n2 = d.gutters.firstChild, i2 = 0;
-              n2;
-              n2 = n2.nextSibling, ++i2
-            ) {
-              var id2 = cm.display.gutterSpecs[i2].className;
-              left[id2] = n2.offsetLeft + n2.clientLeft + gutterLeft;
-              width[id2] = n2.clientWidth;
-            }
-            return {
-              fixedPos: compensateForHScroll(d),
-              gutterTotalWidth: d.gutters.offsetWidth,
-              gutterLeft: left,
-              gutterWidth: width,
-              wrapperWidth: d.wrapper.clientWidth,
-            };
-          }
-          function compensateForHScroll(display) {
-            return (
-              display.scroller.getBoundingClientRect().left -
-              display.sizer.getBoundingClientRect().left
-            );
-          }
-          function estimateHeight(cm) {
-            var th2 = textHeight(cm.display),
-              wrapping = cm.options.lineWrapping;
-            var perLine =
-              wrapping &&
-              Math.max(
-                5,
-                cm.display.scroller.clientWidth / charWidth(cm.display) - 3
-              );
-            return function (line) {
-              if (lineIsHidden(cm.doc, line)) {
-                return 0;
-              }
-              var widgetsHeight = 0;
-              if (line.widgets) {
-                for (var i2 = 0; i2 < line.widgets.length; i2++) {
-                  if (line.widgets[i2].height) {
-                    widgetsHeight += line.widgets[i2].height;
-                  }
-                }
-              }
-              if (wrapping) {
-                return (
-                  widgetsHeight +
-                  (Math.ceil(line.text.length / perLine) || 1) * th2
-                );
-              } else {
-                return widgetsHeight + th2;
-              }
-            };
-          }
-          function estimateLineHeights(cm) {
-            var doc = cm.doc,
-              est = estimateHeight(cm);
-            doc.iter(function (line) {
-              var estHeight = est(line);
-              if (estHeight != line.height) {
-                updateLineHeight(line, estHeight);
-              }
-            });
-          }
-          function posFromMouse(cm, e, liberal, forRect) {
-            var display = cm.display;
-            if (
-              !liberal &&
-              e_target(e).getAttribute("cm-not-content") == "true"
-            ) {
-              return null;
-            }
-            var x2,
-              y2,
-              space = display.lineSpace.getBoundingClientRect();
-            try {
-              x2 = e.clientX - space.left;
-              y2 = e.clientY - space.top;
-            } catch (e$1) {
-              return null;
-            }
-            var coords = coordsChar(cm, x2, y2),
-              line;
-            if (
-              forRect &&
-              coords.xRel > 0 &&
-              (line = getLine2(cm.doc, coords.line).text).length == coords.ch
-            ) {
-              var colDiff =
-                countColumn(line, line.length, cm.options.tabSize) -
-                line.length;
-              coords = Pos(
-                coords.line,
-                Math.max(
-                  0,
-                  Math.round(
-                    (x2 - paddingH(cm.display).left) / charWidth(cm.display)
-                  ) - colDiff
-                )
-              );
-            }
-            return coords;
-          }
-          function findViewIndex(cm, n2) {
-            if (n2 >= cm.display.viewTo) {
-              return null;
-            }
-            n2 -= cm.display.viewFrom;
-            if (n2 < 0) {
-              return null;
-            }
-            var view = cm.display.view;
-            for (var i2 = 0; i2 < view.length; i2++) {
-              n2 -= view[i2].size;
-              if (n2 < 0) {
-                return i2;
-              }
-            }
-          }
-          function regChange(cm, from, to, lendiff) {
-            if (from == null) {
-              from = cm.doc.first;
-            }
-            if (to == null) {
-              to = cm.doc.first + cm.doc.size;
-            }
-            if (!lendiff) {
-              lendiff = 0;
-            }
-            var display = cm.display;
-            if (
-              lendiff &&
-              to < display.viewTo &&
-              (display.updateLineNumbers == null ||
-                display.updateLineNumbers > from)
-            ) {
-              display.updateLineNumbers = from;
-            }
-            cm.curOp.viewChanged = true;
-            if (from >= display.viewTo) {
-              if (
-                sawCollapsedSpans &&
-                visualLineNo(cm.doc, from) < display.viewTo
-              ) {
-                resetView(cm);
-              }
-            } else if (to <= display.viewFrom) {
-              if (
-                sawCollapsedSpans &&
-                visualLineEndNo(cm.doc, to + lendiff) > display.viewFrom
-              ) {
-                resetView(cm);
-              } else {
-                display.viewFrom += lendiff;
-                display.viewTo += lendiff;
-              }
-            } else if (from <= display.viewFrom && to >= display.viewTo) {
-              resetView(cm);
-            } else if (from <= display.viewFrom) {
-              var cut = viewCuttingPoint(cm, to, to + lendiff, 1);
-              if (cut) {
-                display.view = display.view.slice(cut.index);
-                display.viewFrom = cut.lineN;
-                display.viewTo += lendiff;
-              } else {
-                resetView(cm);
-              }
-            } else if (to >= display.viewTo) {
-              var cut$1 = viewCuttingPoint(cm, from, from, -1);
-              if (cut$1) {
-                display.view = display.view.slice(0, cut$1.index);
-                display.viewTo = cut$1.lineN;
-              } else {
-                resetView(cm);
-              }
-            } else {
-              var cutTop = viewCuttingPoint(cm, from, from, -1);
-              var cutBot = viewCuttingPoint(cm, to, to + lendiff, 1);
-              if (cutTop && cutBot) {
-                display.view = display.view
-                  .slice(0, cutTop.index)
-                  .concat(buildViewArray(cm, cutTop.lineN, cutBot.lineN))
-                  .concat(display.view.slice(cutBot.index));
-                display.viewTo += lendiff;
-              } else {
-                resetView(cm);
-              }
-            }
-            var ext = display.externalMeasured;
-            if (ext) {
-              if (to < ext.lineN) {
-                ext.lineN += lendiff;
-              } else if (from < ext.lineN + ext.size) {
-                display.externalMeasured = null;
-              }
-            }
-          }
-          function regLineChange(cm, line, type2) {
-            cm.curOp.viewChanged = true;
-            var display = cm.display,
-              ext = cm.display.externalMeasured;
-            if (ext && line >= ext.lineN && line < ext.lineN + ext.size) {
-              display.externalMeasured = null;
-            }
-            if (line < display.viewFrom || line >= display.viewTo) {
-              return;
-            }
-            var lineView = display.view[findViewIndex(cm, line)];
-            if (lineView.node == null) {
-              return;
-            }
-            var arr = lineView.changes || (lineView.changes = []);
-            if (indexOf(arr, type2) == -1) {
-              arr.push(type2);
-            }
-          }
-          function resetView(cm) {
-            cm.display.viewFrom = cm.display.viewTo = cm.doc.first;
-            cm.display.view = [];
-            cm.display.viewOffset = 0;
-          }
-          function viewCuttingPoint(cm, oldN, newN, dir) {
-            var index = findViewIndex(cm, oldN),
-              diff2,
-              view = cm.display.view;
-            if (!sawCollapsedSpans || newN == cm.doc.first + cm.doc.size) {
-              return { index, lineN: newN };
-            }
-            var n2 = cm.display.viewFrom;
-            for (var i2 = 0; i2 < index; i2++) {
-              n2 += view[i2].size;
-            }
-            if (n2 != oldN) {
-              if (dir > 0) {
-                if (index == view.length - 1) {
-                  return null;
-                }
-                diff2 = n2 + view[index].size - oldN;
-                index++;
-              } else {
-                diff2 = n2 - oldN;
-              }
-              oldN += diff2;
-              newN += diff2;
-            }
-            while (visualLineNo(cm.doc, newN) != newN) {
-              if (index == (dir < 0 ? 0 : view.length - 1)) {
-                return null;
-              }
-              newN += dir * view[index - (dir < 0 ? 1 : 0)].size;
-              index += dir;
-            }
-            return { index, lineN: newN };
-          }
-          function adjustView(cm, from, to) {
-            var display = cm.display,
-              view = display.view;
-            if (
-              view.length == 0 ||
-              from >= display.viewTo ||
-              to <= display.viewFrom
-            ) {
-              display.view = buildViewArray(cm, from, to);
-              display.viewFrom = from;
-            } else {
-              if (display.viewFrom > from) {
-                display.view = buildViewArray(
-                  cm,
-                  from,
-                  display.viewFrom
-                ).concat(display.view);
-              } else if (display.viewFrom < from) {
-                display.view = display.view.slice(findViewIndex(cm, from));
-              }
-              display.viewFrom = from;
-              if (display.viewTo < to) {
-                display.view = display.view.concat(
-                  buildViewArray(cm, display.viewTo, to)
-                );
-              } else if (display.viewTo > to) {
-                display.view = display.view.slice(0, findViewIndex(cm, to));
-              }
-            }
-            display.viewTo = to;
-          }
-          function countDirtyView(cm) {
-            var view = cm.display.view,
-              dirty = 0;
-            for (var i2 = 0; i2 < view.length; i2++) {
-              var lineView = view[i2];
-              if (!lineView.hidden && (!lineView.node || lineView.changes)) {
-                ++dirty;
-              }
-            }
-            return dirty;
-          }
-          function updateSelection(cm) {
-            cm.display.input.showSelection(cm.display.input.prepareSelection());
-          }
-          function prepareSelection(cm, primary) {
-            if (primary === void 0) primary = true;
-            var doc = cm.doc,
-              result2 = {};
-            var curFragment = (result2.cursors =
-              document.createDocumentFragment());
-            var selFragment = (result2.selection =
-              document.createDocumentFragment());
-            var customCursor = cm.options.$customCursor;
-            if (customCursor) {
-              primary = true;
-            }
-            for (var i2 = 0; i2 < doc.sel.ranges.length; i2++) {
-              if (!primary && i2 == doc.sel.primIndex) {
-                continue;
-              }
-              var range3 = doc.sel.ranges[i2];
-              if (
-                range3.from().line >= cm.display.viewTo ||
-                range3.to().line < cm.display.viewFrom
-              ) {
-                continue;
-              }
-              var collapsed = range3.empty();
-              if (customCursor) {
-                var head = customCursor(cm, range3);
-                if (head) {
-                  drawSelectionCursor(cm, head, curFragment);
-                }
-              } else if (collapsed || cm.options.showCursorWhenSelecting) {
-                drawSelectionCursor(cm, range3.head, curFragment);
-              }
-              if (!collapsed) {
-                drawSelectionRange(cm, range3, selFragment);
-              }
-            }
-            return result2;
-          }
-          function drawSelectionCursor(cm, head, output) {
-            var pos = cursorCoords(
-              cm,
-              head,
-              "div",
-              null,
-              null,
-              !cm.options.singleCursorHeightPerLine
-            );
-            var cursor = output.appendChild(
-              elt("div", "\xA0", "CodeMirror-cursor")
-            );
-            cursor.style.left = pos.left + "px";
-            cursor.style.top = pos.top + "px";
-            cursor.style.height =
-              Math.max(0, pos.bottom - pos.top) * cm.options.cursorHeight +
-              "px";
-            if (/\bcm-fat-cursor\b/.test(cm.getWrapperElement().className)) {
-              var charPos = charCoords(cm, head, "div", null, null);
-              var width = charPos.right - charPos.left;
-              cursor.style.width =
-                (width > 0 ? width : cm.defaultCharWidth()) + "px";
-            }
-            if (pos.other) {
-              var otherCursor = output.appendChild(
-                elt(
-                  "div",
-                  "\xA0",
-                  "CodeMirror-cursor CodeMirror-secondarycursor"
-                )
-              );
-              otherCursor.style.display = "";
-              otherCursor.style.left = pos.other.left + "px";
-              otherCursor.style.top = pos.other.top + "px";
-              otherCursor.style.height =
-                (pos.other.bottom - pos.other.top) * 0.85 + "px";
-            }
-          }
-          function cmpCoords(a, b) {
-            return a.top - b.top || a.left - b.left;
-          }
-          function drawSelectionRange(cm, range3, output) {
-            var display = cm.display,
-              doc = cm.doc;
-            var fragment = document.createDocumentFragment();
-            var padding = paddingH(cm.display),
-              leftSide = padding.left;
-            var rightSide =
-              Math.max(
-                display.sizerWidth,
-                displayWidth(cm) - display.sizer.offsetLeft
-              ) - padding.right;
-            var docLTR = doc.direction == "ltr";
-            function add2(left, top2, width, bottom2) {
-              if (top2 < 0) {
-                top2 = 0;
-              }
-              top2 = Math.round(top2);
-              bottom2 = Math.round(bottom2);
-              fragment.appendChild(
-                elt(
-                  "div",
-                  null,
-                  "CodeMirror-selected",
-                  "position: absolute; left: " +
-                    left +
-                    "px;\n                             top: " +
-                    top2 +
-                    "px; width: " +
-                    (width == null ? rightSide - left : width) +
-                    "px;\n                             height: " +
-                    (bottom2 - top2) +
-                    "px"
-                )
-              );
-            }
-            function drawForLine(line, fromArg, toArg) {
-              var lineObj = getLine2(doc, line);
-              var lineLen = lineObj.text.length;
-              var start2, end2;
-              function coords(ch2, bias) {
-                return charCoords(cm, Pos(line, ch2), "div", lineObj, bias);
-              }
-              function wrapX(pos, dir, side) {
-                var extent = wrappedLineExtentChar(cm, lineObj, null, pos);
-                var prop3 =
-                  (dir == "ltr") == (side == "after") ? "left" : "right";
-                var ch2 =
-                  side == "after"
-                    ? extent.begin
-                    : extent.end -
-                      (/\s/.test(lineObj.text.charAt(extent.end - 1)) ? 2 : 1);
-                return coords(ch2, prop3)[prop3];
-              }
-              var order2 = getOrder(lineObj, doc.direction);
-              iterateBidiSections(
-                order2,
-                fromArg || 0,
-                toArg == null ? lineLen : toArg,
-                function (from, to, dir, i2) {
-                  var ltr = dir == "ltr";
-                  var fromPos = coords(from, ltr ? "left" : "right");
-                  var toPos = coords(to - 1, ltr ? "right" : "left");
-                  var openStart = fromArg == null && from == 0,
-                    openEnd = toArg == null && to == lineLen;
-                  var first = i2 == 0,
-                    last = !order2 || i2 == order2.length - 1;
-                  if (toPos.top - fromPos.top <= 3) {
-                    var openLeft = (docLTR ? openStart : openEnd) && first;
-                    var openRight = (docLTR ? openEnd : openStart) && last;
-                    var left = openLeft
-                      ? leftSide
-                      : (ltr ? fromPos : toPos).left;
-                    var right = openRight
-                      ? rightSide
-                      : (ltr ? toPos : fromPos).right;
-                    add2(left, fromPos.top, right - left, fromPos.bottom);
-                  } else {
-                    var topLeft, topRight, botLeft, botRight;
-                    if (ltr) {
-                      topLeft =
-                        docLTR && openStart && first ? leftSide : fromPos.left;
-                      topRight = docLTR
-                        ? rightSide
-                        : wrapX(from, dir, "before");
-                      botLeft = docLTR ? leftSide : wrapX(to, dir, "after");
-                      botRight =
-                        docLTR && openEnd && last ? rightSide : toPos.right;
-                    } else {
-                      topLeft = !docLTR ? leftSide : wrapX(from, dir, "before");
-                      topRight =
-                        !docLTR && openStart && first
-                          ? rightSide
-                          : fromPos.right;
-                      botLeft =
-                        !docLTR && openEnd && last ? leftSide : toPos.left;
-                      botRight = !docLTR ? rightSide : wrapX(to, dir, "after");
-                    }
-                    add2(
-                      topLeft,
-                      fromPos.top,
-                      topRight - topLeft,
-                      fromPos.bottom
-                    );
-                    if (fromPos.bottom < toPos.top) {
-                      add2(leftSide, fromPos.bottom, null, toPos.top);
-                    }
-                    add2(botLeft, toPos.top, botRight - botLeft, toPos.bottom);
-                  }
-                  if (!start2 || cmpCoords(fromPos, start2) < 0) {
-                    start2 = fromPos;
-                  }
-                  if (cmpCoords(toPos, start2) < 0) {
-                    start2 = toPos;
-                  }
-                  if (!end2 || cmpCoords(fromPos, end2) < 0) {
-                    end2 = fromPos;
-                  }
-                  if (cmpCoords(toPos, end2) < 0) {
-                    end2 = toPos;
-                  }
-                }
-              );
-              return { start: start2, end: end2 };
-            }
-            var sFrom = range3.from(),
-              sTo = range3.to();
-            if (sFrom.line == sTo.line) {
-              drawForLine(sFrom.line, sFrom.ch, sTo.ch);
-            } else {
-              var fromLine = getLine2(doc, sFrom.line),
-                toLine = getLine2(doc, sTo.line);
-              var singleVLine = visualLine(fromLine) == visualLine(toLine);
-              var leftEnd = drawForLine(
-                sFrom.line,
-                sFrom.ch,
-                singleVLine ? fromLine.text.length + 1 : null
-              ).end;
-              var rightStart = drawForLine(
-                sTo.line,
-                singleVLine ? 0 : null,
-                sTo.ch
-              ).start;
-              if (singleVLine) {
-                if (leftEnd.top < rightStart.top - 2) {
-                  add2(leftEnd.right, leftEnd.top, null, leftEnd.bottom);
-                  add2(
-                    leftSide,
-                    rightStart.top,
-                    rightStart.left,
-                    rightStart.bottom
-                  );
-                } else {
-                  add2(
-                    leftEnd.right,
-                    leftEnd.top,
-                    rightStart.left - leftEnd.right,
-                    leftEnd.bottom
-                  );
-                }
-              }
-              if (leftEnd.bottom < rightStart.top) {
-                add2(leftSide, leftEnd.bottom, null, rightStart.top);
-              }
-            }
-            output.appendChild(fragment);
-          }
-          function restartBlink(cm) {
-            if (!cm.state.focused) {
-              return;
-            }
-            var display = cm.display;
-            clearInterval(display.blinker);
-            var on2 = true;
-            display.cursorDiv.style.visibility = "";
-            if (cm.options.cursorBlinkRate > 0) {
-              display.blinker = setInterval(function () {
-                if (!cm.hasFocus()) {
-                  onBlur(cm);
-                }
-                display.cursorDiv.style.visibility = (on2 = !on2)
-                  ? ""
-                  : "hidden";
-              }, cm.options.cursorBlinkRate);
-            } else if (cm.options.cursorBlinkRate < 0) {
-              display.cursorDiv.style.visibility = "hidden";
-            }
-          }
-          function ensureFocus(cm) {
-            if (!cm.hasFocus()) {
-              cm.display.input.focus();
-              if (!cm.state.focused) {
-                onFocus(cm);
-              }
-            }
-          }
-          function delayBlurEvent(cm) {
-            cm.state.delayingBlurEvent = true;
-            setTimeout(function () {
-              if (cm.state.delayingBlurEvent) {
-                cm.state.delayingBlurEvent = false;
-                if (cm.state.focused) {
-                  onBlur(cm);
-                }
-              }
-            }, 100);
-          }
-          function onFocus(cm, e) {
-            if (cm.state.delayingBlurEvent && !cm.state.draggingText) {
-              cm.state.delayingBlurEvent = false;
-            }
-            if (cm.options.readOnly == "nocursor") {
-              return;
-            }
-            if (!cm.state.focused) {
-              signal(cm, "focus", cm, e);
-              cm.state.focused = true;
-              addClass(cm.display.wrapper, "CodeMirror-focused");
-              if (!cm.curOp && cm.display.selForContextMenu != cm.doc.sel) {
-                cm.display.input.reset();
-                if (webkit) {
-                  setTimeout(function () {
-                    return cm.display.input.reset(true);
-                  }, 20);
-                }
-              }
-              cm.display.input.receivedFocus();
-            }
-            restartBlink(cm);
-          }
-          function onBlur(cm, e) {
-            if (cm.state.delayingBlurEvent) {
-              return;
-            }
-            if (cm.state.focused) {
-              signal(cm, "blur", cm, e);
-              cm.state.focused = false;
-              rmClass(cm.display.wrapper, "CodeMirror-focused");
-            }
-            clearInterval(cm.display.blinker);
-            setTimeout(function () {
-              if (!cm.state.focused) {
-                cm.display.shift = false;
-              }
-            }, 150);
-          }
-          function updateHeightsInViewport(cm) {
-            var display = cm.display;
-            var prevBottom = display.lineDiv.offsetTop;
-            var viewTop = Math.max(
-              0,
-              display.scroller.getBoundingClientRect().top
-            );
-            var oldHeight = display.lineDiv.getBoundingClientRect().top;
-            var mustScroll = 0;
-            for (var i2 = 0; i2 < display.view.length; i2++) {
-              var cur = display.view[i2],
-                wrapping = cm.options.lineWrapping;
-              var height = void 0,
-                width = 0;
-              if (cur.hidden) {
-                continue;
-              }
-              oldHeight += cur.line.height;
-              if (ie2 && ie_version < 8) {
-                var bot2 = cur.node.offsetTop + cur.node.offsetHeight;
-                height = bot2 - prevBottom;
-                prevBottom = bot2;
-              } else {
-                var box = cur.node.getBoundingClientRect();
-                height = box.bottom - box.top;
-                if (!wrapping && cur.text.firstChild) {
-                  width =
-                    cur.text.firstChild.getBoundingClientRect().right -
-                    box.left -
-                    1;
-                }
-              }
-              var diff2 = cur.line.height - height;
-              if (diff2 > 5e-3 || diff2 < -5e-3) {
-                if (oldHeight < viewTop) {
-                  mustScroll -= diff2;
-                }
-                updateLineHeight(cur.line, height);
-                updateWidgetHeight(cur.line);
-                if (cur.rest) {
-                  for (var j = 0; j < cur.rest.length; j++) {
-                    updateWidgetHeight(cur.rest[j]);
-                  }
-                }
-              }
-              if (width > cm.display.sizerWidth) {
-                var chWidth = Math.ceil(width / charWidth(cm.display));
-                if (chWidth > cm.display.maxLineLength) {
-                  cm.display.maxLineLength = chWidth;
-                  cm.display.maxLine = cur.line;
-                  cm.display.maxLineChanged = true;
-                }
-              }
-            }
-            if (Math.abs(mustScroll) > 2) {
-              display.scroller.scrollTop += mustScroll;
-            }
-          }
-          function updateWidgetHeight(line) {
-            if (line.widgets) {
-              for (var i2 = 0; i2 < line.widgets.length; ++i2) {
-                var w2 = line.widgets[i2],
-                  parent = w2.node.parentNode;
-                if (parent) {
-                  w2.height = parent.offsetHeight;
-                }
-              }
-            }
-          }
-          function visibleLines(display, doc, viewport) {
-            var top2 =
-              viewport && viewport.top != null
-                ? Math.max(0, viewport.top)
-                : display.scroller.scrollTop;
-            top2 = Math.floor(top2 - paddingTop(display));
-            var bottom2 =
-              viewport && viewport.bottom != null
-                ? viewport.bottom
-                : top2 + display.wrapper.clientHeight;
-            var from = lineAtHeight(doc, top2),
-              to = lineAtHeight(doc, bottom2);
-            if (viewport && viewport.ensure) {
-              var ensureFrom = viewport.ensure.from.line,
-                ensureTo = viewport.ensure.to.line;
-              if (ensureFrom < from) {
-                from = ensureFrom;
-                to = lineAtHeight(
-                  doc,
-                  heightAtLine(getLine2(doc, ensureFrom)) +
-                    display.wrapper.clientHeight
-                );
-              } else if (Math.min(ensureTo, doc.lastLine()) >= to) {
-                from = lineAtHeight(
-                  doc,
-                  heightAtLine(getLine2(doc, ensureTo)) -
-                    display.wrapper.clientHeight
-                );
-                to = ensureTo;
-              }
-            }
-            return { from, to: Math.max(to, from + 1) };
-          }
-          function maybeScrollWindow(cm, rect2) {
-            if (signalDOMEvent(cm, "scrollCursorIntoView")) {
-              return;
-            }
-            var display = cm.display,
-              box = display.sizer.getBoundingClientRect(),
-              doScroll = null;
-            if (rect2.top + box.top < 0) {
-              doScroll = true;
-            } else if (
-              rect2.bottom + box.top >
-              (window.innerHeight || document.documentElement.clientHeight)
-            ) {
-              doScroll = false;
-            }
-            if (doScroll != null && !phantom) {
-              var scrollNode = elt(
-                "div",
-                "\u200B",
-                null,
-                "position: absolute;\n                         top: " +
-                  (rect2.top - display.viewOffset - paddingTop(cm.display)) +
-                  "px;\n                         height: " +
-                  (rect2.bottom -
-                    rect2.top +
-                    scrollGap(cm) +
-                    display.barHeight) +
-                  "px;\n                         left: " +
-                  rect2.left +
-                  "px; width: " +
-                  Math.max(2, rect2.right - rect2.left) +
-                  "px;"
-              );
-              cm.display.lineSpace.appendChild(scrollNode);
-              scrollNode.scrollIntoView(doScroll);
-              cm.display.lineSpace.removeChild(scrollNode);
-            }
-          }
-          function scrollPosIntoView(cm, pos, end2, margin) {
-            if (margin == null) {
-              margin = 0;
-            }
-            var rect2;
-            if (!cm.options.lineWrapping && pos == end2) {
-              end2 =
-                pos.sticky == "before"
-                  ? Pos(pos.line, pos.ch + 1, "before")
-                  : pos;
-              pos = pos.ch
-                ? Pos(
-                    pos.line,
-                    pos.sticky == "before" ? pos.ch - 1 : pos.ch,
-                    "after"
-                  )
-                : pos;
-            }
-            for (var limit = 0; limit < 5; limit++) {
-              var changed = false;
-              var coords = cursorCoords(cm, pos);
-              var endCoords =
-                !end2 || end2 == pos ? coords : cursorCoords(cm, end2);
-              rect2 = {
-                left: Math.min(coords.left, endCoords.left),
-                top: Math.min(coords.top, endCoords.top) - margin,
-                right: Math.max(coords.left, endCoords.left),
-                bottom: Math.max(coords.bottom, endCoords.bottom) + margin,
-              };
-              var scrollPos = calculateScrollPos(cm, rect2);
-              var startTop = cm.doc.scrollTop,
-                startLeft = cm.doc.scrollLeft;
-              if (scrollPos.scrollTop != null) {
-                updateScrollTop(cm, scrollPos.scrollTop);
-                if (Math.abs(cm.doc.scrollTop - startTop) > 1) {
-                  changed = true;
-                }
-              }
-              if (scrollPos.scrollLeft != null) {
-                setScrollLeft(cm, scrollPos.scrollLeft);
-                if (Math.abs(cm.doc.scrollLeft - startLeft) > 1) {
-                  changed = true;
-                }
-              }
-              if (!changed) {
-                break;
-              }
-            }
-            return rect2;
-          }
-          function scrollIntoView(cm, rect2) {
-            var scrollPos = calculateScrollPos(cm, rect2);
-            if (scrollPos.scrollTop != null) {
-              updateScrollTop(cm, scrollPos.scrollTop);
-            }
-            if (scrollPos.scrollLeft != null) {
-              setScrollLeft(cm, scrollPos.scrollLeft);
-            }
-          }
-          function calculateScrollPos(cm, rect2) {
-            var display = cm.display,
-              snapMargin = textHeight(cm.display);
-            if (rect2.top < 0) {
-              rect2.top = 0;
-            }
-            var screentop =
-              cm.curOp && cm.curOp.scrollTop != null
-                ? cm.curOp.scrollTop
-                : display.scroller.scrollTop;
-            var screen2 = displayHeight(cm),
-              result2 = {};
-            if (rect2.bottom - rect2.top > screen2) {
-              rect2.bottom = rect2.top + screen2;
-            }
-            var docBottom = cm.doc.height + paddingVert(display);
-            var atTop = rect2.top < snapMargin,
-              atBottom = rect2.bottom > docBottom - snapMargin;
-            if (rect2.top < screentop) {
-              result2.scrollTop = atTop ? 0 : rect2.top;
-            } else if (rect2.bottom > screentop + screen2) {
-              var newTop = Math.min(
-                rect2.top,
-                (atBottom ? docBottom : rect2.bottom) - screen2
-              );
-              if (newTop != screentop) {
-                result2.scrollTop = newTop;
-              }
-            }
-            var gutterSpace = cm.options.fixedGutter
-              ? 0
-              : display.gutters.offsetWidth;
-            var screenleft =
-              cm.curOp && cm.curOp.scrollLeft != null
-                ? cm.curOp.scrollLeft
-                : display.scroller.scrollLeft - gutterSpace;
-            var screenw = displayWidth(cm) - display.gutters.offsetWidth;
-            var tooWide = rect2.right - rect2.left > screenw;
-            if (tooWide) {
-              rect2.right = rect2.left + screenw;
-            }
-            if (rect2.left < 10) {
-              result2.scrollLeft = 0;
-            } else if (rect2.left < screenleft) {
-              result2.scrollLeft = Math.max(
-                0,
-                rect2.left + gutterSpace - (tooWide ? 0 : 10)
-              );
-            } else if (rect2.right > screenw + screenleft - 3) {
-              result2.scrollLeft = rect2.right + (tooWide ? 0 : 10) - screenw;
-            }
-            return result2;
-          }
-          function addToScrollTop(cm, top2) {
-            if (top2 == null) {
-              return;
-            }
-            resolveScrollToPos(cm);
-            cm.curOp.scrollTop =
-              (cm.curOp.scrollTop == null
-                ? cm.doc.scrollTop
-                : cm.curOp.scrollTop) + top2;
-          }
-          function ensureCursorVisible(cm) {
-            resolveScrollToPos(cm);
-            var cur = cm.getCursor();
-            cm.curOp.scrollToPos = {
-              from: cur,
-              to: cur,
-              margin: cm.options.cursorScrollMargin,
-            };
-          }
-          function scrollToCoords(cm, x2, y2) {
-            if (x2 != null || y2 != null) {
-              resolveScrollToPos(cm);
-            }
-            if (x2 != null) {
-              cm.curOp.scrollLeft = x2;
-            }
-            if (y2 != null) {
-              cm.curOp.scrollTop = y2;
-            }
-          }
-          function scrollToRange(cm, range3) {
-            resolveScrollToPos(cm);
-            cm.curOp.scrollToPos = range3;
-          }
-          function resolveScrollToPos(cm) {
-            var range3 = cm.curOp.scrollToPos;
-            if (range3) {
-              cm.curOp.scrollToPos = null;
-              var from = estimateCoords(cm, range3.from),
-                to = estimateCoords(cm, range3.to);
-              scrollToCoordsRange(cm, from, to, range3.margin);
-            }
-          }
-          function scrollToCoordsRange(cm, from, to, margin) {
-            var sPos = calculateScrollPos(cm, {
-              left: Math.min(from.left, to.left),
-              top: Math.min(from.top, to.top) - margin,
-              right: Math.max(from.right, to.right),
-              bottom: Math.max(from.bottom, to.bottom) + margin,
-            });
-            scrollToCoords(cm, sPos.scrollLeft, sPos.scrollTop);
-          }
-          function updateScrollTop(cm, val) {
-            if (Math.abs(cm.doc.scrollTop - val) < 2) {
-              return;
-            }
-            if (!gecko) {
-              updateDisplaySimple(cm, { top: val });
-            }
-            setScrollTop(cm, val, true);
-            if (gecko) {
-              updateDisplaySimple(cm);
-            }
-            startWorker(cm, 100);
-          }
-          function setScrollTop(cm, val, forceScroll) {
-            val = Math.max(
-              0,
-              Math.min(
-                cm.display.scroller.scrollHeight -
-                  cm.display.scroller.clientHeight,
-                val
-              )
-            );
-            if (cm.display.scroller.scrollTop == val && !forceScroll) {
-              return;
-            }
-            cm.doc.scrollTop = val;
-            cm.display.scrollbars.setScrollTop(val);
-            if (cm.display.scroller.scrollTop != val) {
-              cm.display.scroller.scrollTop = val;
-            }
-          }
-          function setScrollLeft(cm, val, isScroller, forceScroll) {
-            val = Math.max(
-              0,
-              Math.min(
-                val,
-                cm.display.scroller.scrollWidth -
-                  cm.display.scroller.clientWidth
-              )
-            );
-            if (
-              (isScroller
-                ? val == cm.doc.scrollLeft
-                : Math.abs(cm.doc.scrollLeft - val) < 2) &&
-              !forceScroll
-            ) {
-              return;
-            }
-            cm.doc.scrollLeft = val;
-            alignHorizontally(cm);
-            if (cm.display.scroller.scrollLeft != val) {
-              cm.display.scroller.scrollLeft = val;
-            }
-            cm.display.scrollbars.setScrollLeft(val);
-          }
-          function measureForScrollbars(cm) {
-            var d = cm.display,
-              gutterW = d.gutters.offsetWidth;
-            var docH = Math.round(cm.doc.height + paddingVert(cm.display));
-            return {
-              clientHeight: d.scroller.clientHeight,
-              viewHeight: d.wrapper.clientHeight,
-              scrollWidth: d.scroller.scrollWidth,
-              clientWidth: d.scroller.clientWidth,
-              viewWidth: d.wrapper.clientWidth,
-              barLeft: cm.options.fixedGutter ? gutterW : 0,
-              docHeight: docH,
-              scrollHeight: docH + scrollGap(cm) + d.barHeight,
-              nativeBarWidth: d.nativeBarWidth,
-              gutterWidth: gutterW,
-            };
-          }
-          var NativeScrollbars = function (place, scroll, cm) {
-            this.cm = cm;
-            var vert2 = (this.vert = elt(
-              "div",
-              [elt("div", null, null, "min-width: 1px")],
-              "CodeMirror-vscrollbar"
-            ));
-            var horiz = (this.horiz = elt(
-              "div",
-              [elt("div", null, null, "height: 100%; min-height: 1px")],
-              "CodeMirror-hscrollbar"
-            ));
-            vert2.tabIndex = horiz.tabIndex = -1;
-            place(vert2);
-            place(horiz);
-            on(vert2, "scroll", function () {
-              if (vert2.clientHeight) {
-                scroll(vert2.scrollTop, "vertical");
-              }
-            });
-            on(horiz, "scroll", function () {
-              if (horiz.clientWidth) {
-                scroll(horiz.scrollLeft, "horizontal");
-              }
-            });
-            this.checkedZeroWidth = false;
-            if (ie2 && ie_version < 8) {
-              this.horiz.style.minHeight = this.vert.style.minWidth = "18px";
-            }
-          };
-          NativeScrollbars.prototype.update = function (measure) {
-            var needsH = measure.scrollWidth > measure.clientWidth + 1;
-            var needsV = measure.scrollHeight > measure.clientHeight + 1;
-            var sWidth = measure.nativeBarWidth;
-            if (needsV) {
-              this.vert.style.display = "block";
-              this.vert.style.bottom = needsH ? sWidth + "px" : "0";
-              var totalHeight = measure.viewHeight - (needsH ? sWidth : 0);
-              this.vert.firstChild.style.height =
-                Math.max(
-                  0,
-                  measure.scrollHeight - measure.clientHeight + totalHeight
-                ) + "px";
-            } else {
-              this.vert.scrollTop = 0;
-              this.vert.style.display = "";
-              this.vert.firstChild.style.height = "0";
-            }
-            if (needsH) {
-              this.horiz.style.display = "block";
-              this.horiz.style.right = needsV ? sWidth + "px" : "0";
-              this.horiz.style.left = measure.barLeft + "px";
-              var totalWidth =
-                measure.viewWidth - measure.barLeft - (needsV ? sWidth : 0);
-              this.horiz.firstChild.style.width =
-                Math.max(
-                  0,
-                  measure.scrollWidth - measure.clientWidth + totalWidth
-                ) + "px";
-            } else {
-              this.horiz.style.display = "";
-              this.horiz.firstChild.style.width = "0";
-            }
-            if (!this.checkedZeroWidth && measure.clientHeight > 0) {
-              if (sWidth == 0) {
-                this.zeroWidthHack();
-              }
-              this.checkedZeroWidth = true;
-            }
-            return { right: needsV ? sWidth : 0, bottom: needsH ? sWidth : 0 };
-          };
-          NativeScrollbars.prototype.setScrollLeft = function (pos) {
-            if (this.horiz.scrollLeft != pos) {
-              this.horiz.scrollLeft = pos;
-            }
-            if (this.disableHoriz) {
-              this.enableZeroWidthBar(this.horiz, this.disableHoriz, "horiz");
-            }
-          };
-          NativeScrollbars.prototype.setScrollTop = function (pos) {
-            if (this.vert.scrollTop != pos) {
-              this.vert.scrollTop = pos;
-            }
-            if (this.disableVert) {
-              this.enableZeroWidthBar(this.vert, this.disableVert, "vert");
-            }
-          };
-          NativeScrollbars.prototype.zeroWidthHack = function () {
-            var w2 = mac && !mac_geMountainLion ? "12px" : "18px";
-            this.horiz.style.height = this.vert.style.width = w2;
-            this.horiz.style.pointerEvents = this.vert.style.pointerEvents =
-              "none";
-            this.disableHoriz = new Delayed();
-            this.disableVert = new Delayed();
-          };
-          NativeScrollbars.prototype.enableZeroWidthBar = function (
-            bar,
-            delay,
-            type2
-          ) {
-            bar.style.pointerEvents = "auto";
-            function maybeDisable() {
-              var box = bar.getBoundingClientRect();
-              var elt2 =
-                type2 == "vert"
-                  ? document.elementFromPoint(
-                      box.right - 1,
-                      (box.top + box.bottom) / 2
-                    )
-                  : document.elementFromPoint(
-                      (box.right + box.left) / 2,
-                      box.bottom - 1
-                    );
-              if (elt2 != bar) {
-                bar.style.pointerEvents = "none";
-              } else {
-                delay.set(1e3, maybeDisable);
-              }
-            }
-            delay.set(1e3, maybeDisable);
-          };
-          NativeScrollbars.prototype.clear = function () {
-            var parent = this.horiz.parentNode;
-            parent.removeChild(this.horiz);
-            parent.removeChild(this.vert);
-          };
-          var NullScrollbars = function () {};
-          NullScrollbars.prototype.update = function () {
-            return { bottom: 0, right: 0 };
-          };
-          NullScrollbars.prototype.setScrollLeft = function () {};
-          NullScrollbars.prototype.setScrollTop = function () {};
-          NullScrollbars.prototype.clear = function () {};
-          function updateScrollbars(cm, measure) {
-            if (!measure) {
-              measure = measureForScrollbars(cm);
-            }
-            var startWidth = cm.display.barWidth,
-              startHeight = cm.display.barHeight;
-            updateScrollbarsInner(cm, measure);
-            for (
-              var i2 = 0;
-              (i2 < 4 && startWidth != cm.display.barWidth) ||
-              startHeight != cm.display.barHeight;
-              i2++
-            ) {
-              if (
-                startWidth != cm.display.barWidth &&
-                cm.options.lineWrapping
-              ) {
-                updateHeightsInViewport(cm);
-              }
-              updateScrollbarsInner(cm, measureForScrollbars(cm));
-              startWidth = cm.display.barWidth;
-              startHeight = cm.display.barHeight;
-            }
-          }
-          function updateScrollbarsInner(cm, measure) {
-            var d = cm.display;
-            var sizes = d.scrollbars.update(measure);
-            d.sizer.style.paddingRight = (d.barWidth = sizes.right) + "px";
-            d.sizer.style.paddingBottom = (d.barHeight = sizes.bottom) + "px";
-            d.heightForcer.style.borderBottom =
-              sizes.bottom + "px solid transparent";
-            if (sizes.right && sizes.bottom) {
-              d.scrollbarFiller.style.display = "block";
-              d.scrollbarFiller.style.height = sizes.bottom + "px";
-              d.scrollbarFiller.style.width = sizes.right + "px";
-            } else {
-              d.scrollbarFiller.style.display = "";
-            }
-            if (
-              sizes.bottom &&
-              cm.options.coverGutterNextToScrollbar &&
-              cm.options.fixedGutter
-            ) {
-              d.gutterFiller.style.display = "block";
-              d.gutterFiller.style.height = sizes.bottom + "px";
-              d.gutterFiller.style.width = measure.gutterWidth + "px";
-            } else {
-              d.gutterFiller.style.display = "";
-            }
-          }
-          var scrollbarModel = {
-            native: NativeScrollbars,
-            null: NullScrollbars,
-          };
-          function initScrollbars(cm) {
-            if (cm.display.scrollbars) {
-              cm.display.scrollbars.clear();
-              if (cm.display.scrollbars.addClass) {
-                rmClass(cm.display.wrapper, cm.display.scrollbars.addClass);
-              }
-            }
-            cm.display.scrollbars = new scrollbarModel[
-              cm.options.scrollbarStyle
-            ](
-              function (node) {
-                cm.display.wrapper.insertBefore(
-                  node,
-                  cm.display.scrollbarFiller
-                );
-                on(node, "mousedown", function () {
-                  if (cm.state.focused) {
-                    setTimeout(function () {
-                      return cm.display.input.focus();
-                    }, 0);
-                  }
-                });
-                node.setAttribute("cm-not-content", "true");
-              },
-              function (pos, axis) {
-                if (axis == "horizontal") {
-                  setScrollLeft(cm, pos);
-                } else {
-                  updateScrollTop(cm, pos);
-                }
-              },
-              cm
-            );
-            if (cm.display.scrollbars.addClass) {
-              addClass(cm.display.wrapper, cm.display.scrollbars.addClass);
-            }
-          }
-          var nextOpId = 0;
-          function startOperation(cm) {
-            cm.curOp = {
-              cm,
-              viewChanged: false,
-              startHeight: cm.doc.height,
-              forceUpdate: false,
-              updateInput: 0,
-              typing: false,
-              changeObjs: null,
-              cursorActivityHandlers: null,
-              cursorActivityCalled: 0,
-              selectionChanged: false,
-              updateMaxLine: false,
-              scrollLeft: null,
-              scrollTop: null,
-              scrollToPos: null,
-              focus: false,
-              id: ++nextOpId,
-              markArrays: null,
-            };
-            pushOperation(cm.curOp);
-          }
-          function endOperation(cm) {
-            var op = cm.curOp;
-            if (op) {
-              finishOperation(op, function (group) {
-                for (var i2 = 0; i2 < group.ops.length; i2++) {
-                  group.ops[i2].cm.curOp = null;
-                }
-                endOperations(group);
-              });
-            }
-          }
-          function endOperations(group) {
-            var ops = group.ops;
-            for (var i2 = 0; i2 < ops.length; i2++) {
-              endOperation_R1(ops[i2]);
-            }
-            for (var i$12 = 0; i$12 < ops.length; i$12++) {
-              endOperation_W1(ops[i$12]);
-            }
-            for (var i$22 = 0; i$22 < ops.length; i$22++) {
-              endOperation_R2(ops[i$22]);
-            }
-            for (var i$3 = 0; i$3 < ops.length; i$3++) {
-              endOperation_W2(ops[i$3]);
-            }
-            for (var i$4 = 0; i$4 < ops.length; i$4++) {
-              endOperation_finish(ops[i$4]);
-            }
-          }
-          function endOperation_R1(op) {
-            var cm = op.cm,
-              display = cm.display;
-            maybeClipScrollbars(cm);
-            if (op.updateMaxLine) {
-              findMaxLine(cm);
-            }
-            op.mustUpdate =
-              op.viewChanged ||
-              op.forceUpdate ||
-              op.scrollTop != null ||
-              (op.scrollToPos &&
-                (op.scrollToPos.from.line < display.viewFrom ||
-                  op.scrollToPos.to.line >= display.viewTo)) ||
-              (display.maxLineChanged && cm.options.lineWrapping);
-            op.update =
-              op.mustUpdate &&
-              new DisplayUpdate(
-                cm,
-                op.mustUpdate && { top: op.scrollTop, ensure: op.scrollToPos },
-                op.forceUpdate
-              );
-          }
-          function endOperation_W1(op) {
-            op.updatedDisplay =
-              op.mustUpdate && updateDisplayIfNeeded(op.cm, op.update);
-          }
-          function endOperation_R2(op) {
-            var cm = op.cm,
-              display = cm.display;
-            if (op.updatedDisplay) {
-              updateHeightsInViewport(cm);
-            }
-            op.barMeasure = measureForScrollbars(cm);
-            if (display.maxLineChanged && !cm.options.lineWrapping) {
-              op.adjustWidthTo =
-                measureChar(cm, display.maxLine, display.maxLine.text.length)
-                  .left + 3;
-              cm.display.sizerWidth = op.adjustWidthTo;
-              op.barMeasure.scrollWidth = Math.max(
-                display.scroller.clientWidth,
-                display.sizer.offsetLeft +
-                  op.adjustWidthTo +
-                  scrollGap(cm) +
-                  cm.display.barWidth
-              );
-              op.maxScrollLeft = Math.max(
-                0,
-                display.sizer.offsetLeft + op.adjustWidthTo - displayWidth(cm)
-              );
-            }
-            if (op.updatedDisplay || op.selectionChanged) {
-              op.preparedSelection = display.input.prepareSelection();
-            }
-          }
-          function endOperation_W2(op) {
-            var cm = op.cm;
-            if (op.adjustWidthTo != null) {
-              cm.display.sizer.style.minWidth = op.adjustWidthTo + "px";
-              if (op.maxScrollLeft < cm.doc.scrollLeft) {
-                setScrollLeft(
-                  cm,
-                  Math.min(cm.display.scroller.scrollLeft, op.maxScrollLeft),
-                  true
-                );
-              }
-              cm.display.maxLineChanged = false;
-            }
-            var takeFocus = op.focus && op.focus == activeElt();
-            if (op.preparedSelection) {
-              cm.display.input.showSelection(op.preparedSelection, takeFocus);
-            }
-            if (op.updatedDisplay || op.startHeight != cm.doc.height) {
-              updateScrollbars(cm, op.barMeasure);
-            }
-            if (op.updatedDisplay) {
-              setDocumentHeight(cm, op.barMeasure);
-            }
-            if (op.selectionChanged) {
-              restartBlink(cm);
-            }
-            if (cm.state.focused && op.updateInput) {
-              cm.display.input.reset(op.typing);
-            }
-            if (takeFocus) {
-              ensureFocus(op.cm);
-            }
-          }
-          function endOperation_finish(op) {
-            var cm = op.cm,
-              display = cm.display,
-              doc = cm.doc;
-            if (op.updatedDisplay) {
-              postUpdateDisplay(cm, op.update);
-            }
-            if (
-              display.wheelStartX != null &&
-              (op.scrollTop != null || op.scrollLeft != null || op.scrollToPos)
-            ) {
-              display.wheelStartX = display.wheelStartY = null;
-            }
-            if (op.scrollTop != null) {
-              setScrollTop(cm, op.scrollTop, op.forceScroll);
-            }
-            if (op.scrollLeft != null) {
-              setScrollLeft(cm, op.scrollLeft, true, true);
-            }
-            if (op.scrollToPos) {
-              var rect2 = scrollPosIntoView(
-                cm,
-                clipPos(doc, op.scrollToPos.from),
-                clipPos(doc, op.scrollToPos.to),
-                op.scrollToPos.margin
-              );
-              maybeScrollWindow(cm, rect2);
-            }
-            var hidden = op.maybeHiddenMarkers,
-              unhidden = op.maybeUnhiddenMarkers;
-            if (hidden) {
-              for (var i2 = 0; i2 < hidden.length; ++i2) {
-                if (!hidden[i2].lines.length) {
-                  signal(hidden[i2], "hide");
-                }
-              }
-            }
-            if (unhidden) {
-              for (var i$12 = 0; i$12 < unhidden.length; ++i$12) {
-                if (unhidden[i$12].lines.length) {
-                  signal(unhidden[i$12], "unhide");
-                }
-              }
-            }
-            if (display.wrapper.offsetHeight) {
-              doc.scrollTop = cm.display.scroller.scrollTop;
-            }
-            if (op.changeObjs) {
-              signal(cm, "changes", cm, op.changeObjs);
-            }
-            if (op.update) {
-              op.update.finish();
-            }
-          }
-          function runInOp(cm, f) {
-            if (cm.curOp) {
-              return f();
-            }
-            startOperation(cm);
-            try {
-              return f();
-            } finally {
-              endOperation(cm);
-            }
-          }
-          function operation(cm, f) {
-            return function () {
-              if (cm.curOp) {
-                return f.apply(cm, arguments);
-              }
-              startOperation(cm);
-              try {
-                return f.apply(cm, arguments);
-              } finally {
-                endOperation(cm);
-              }
-            };
-          }
-          function methodOp(f) {
-            return function () {
-              if (this.curOp) {
-                return f.apply(this, arguments);
-              }
-              startOperation(this);
-              try {
-                return f.apply(this, arguments);
-              } finally {
-                endOperation(this);
-              }
-            };
-          }
-          function docMethodOp(f) {
-            return function () {
-              var cm = this.cm;
-              if (!cm || cm.curOp) {
-                return f.apply(this, arguments);
-              }
-              startOperation(cm);
-              try {
-                return f.apply(this, arguments);
-              } finally {
-                endOperation(cm);
-              }
-            };
-          }
-          function startWorker(cm, time) {
-            if (cm.doc.highlightFrontier < cm.display.viewTo) {
-              cm.state.highlight.set(time, bind(highlightWorker, cm));
-            }
-          }
-          function highlightWorker(cm) {
-            var doc = cm.doc;
-            if (doc.highlightFrontier >= cm.display.viewTo) {
-              return;
-            }
-            var end2 = +new Date() + cm.options.workTime;
-            var context = getContextBefore(cm, doc.highlightFrontier);
-            var changedLines = [];
-            doc.iter(
-              context.line,
-              Math.min(doc.first + doc.size, cm.display.viewTo + 500),
-              function (line) {
-                if (context.line >= cm.display.viewFrom) {
-                  var oldStyles = line.styles;
-                  var resetState =
-                    line.text.length > cm.options.maxHighlightLength
-                      ? copyState(doc.mode, context.state)
-                      : null;
-                  var highlighted = highlightLine(cm, line, context, true);
-                  if (resetState) {
-                    context.state = resetState;
-                  }
-                  line.styles = highlighted.styles;
-                  var oldCls = line.styleClasses,
-                    newCls = highlighted.classes;
-                  if (newCls) {
-                    line.styleClasses = newCls;
-                  } else if (oldCls) {
-                    line.styleClasses = null;
-                  }
-                  var ischange =
-                    !oldStyles ||
-                    oldStyles.length != line.styles.length ||
-                    (oldCls != newCls &&
-                      (!oldCls ||
-                        !newCls ||
-                        oldCls.bgClass != newCls.bgClass ||
-                        oldCls.textClass != newCls.textClass));
-                  for (var i2 = 0; !ischange && i2 < oldStyles.length; ++i2) {
-                    ischange = oldStyles[i2] != line.styles[i2];
-                  }
-                  if (ischange) {
-                    changedLines.push(context.line);
-                  }
-                  line.stateAfter = context.save();
-                  context.nextLine();
-                } else {
-                  if (line.text.length <= cm.options.maxHighlightLength) {
-                    processLine(cm, line.text, context);
-                  }
-                  line.stateAfter =
-                    context.line % 5 == 0 ? context.save() : null;
-                  context.nextLine();
-                }
-                if (+new Date() > end2) {
-                  startWorker(cm, cm.options.workDelay);
-                  return true;
-                }
-              }
-            );
-            doc.highlightFrontier = context.line;
-            doc.modeFrontier = Math.max(doc.modeFrontier, context.line);
-            if (changedLines.length) {
-              runInOp(cm, function () {
-                for (var i2 = 0; i2 < changedLines.length; i2++) {
-                  regLineChange(cm, changedLines[i2], "text");
-                }
-              });
-            }
-          }
-          var DisplayUpdate = function (cm, viewport, force) {
-            var display = cm.display;
-            this.viewport = viewport;
-            this.visible = visibleLines(display, cm.doc, viewport);
-            this.editorIsHidden = !display.wrapper.offsetWidth;
-            this.wrapperHeight = display.wrapper.clientHeight;
-            this.wrapperWidth = display.wrapper.clientWidth;
-            this.oldDisplayWidth = displayWidth(cm);
-            this.force = force;
-            this.dims = getDimensions(cm);
-            this.events = [];
-          };
-          DisplayUpdate.prototype.signal = function (emitter, type2) {
-            if (hasHandler(emitter, type2)) {
-              this.events.push(arguments);
-            }
-          };
-          DisplayUpdate.prototype.finish = function () {
-            for (var i2 = 0; i2 < this.events.length; i2++) {
-              signal.apply(null, this.events[i2]);
-            }
-          };
-          function maybeClipScrollbars(cm) {
-            var display = cm.display;
-            if (!display.scrollbarsClipped && display.scroller.offsetWidth) {
-              display.nativeBarWidth =
-                display.scroller.offsetWidth - display.scroller.clientWidth;
-              display.heightForcer.style.height = scrollGap(cm) + "px";
-              display.sizer.style.marginBottom = -display.nativeBarWidth + "px";
-              display.sizer.style.borderRightWidth = scrollGap(cm) + "px";
-              display.scrollbarsClipped = true;
-            }
-          }
-          function selectionSnapshot(cm) {
-            if (cm.hasFocus()) {
-              return null;
-            }
-            var active = activeElt();
-            if (!active || !contains(cm.display.lineDiv, active)) {
-              return null;
-            }
-            var result2 = { activeElt: active };
-            if (window.getSelection) {
-              var sel = window.getSelection();
-              if (
-                sel.anchorNode &&
-                sel.extend &&
-                contains(cm.display.lineDiv, sel.anchorNode)
-              ) {
-                result2.anchorNode = sel.anchorNode;
-                result2.anchorOffset = sel.anchorOffset;
-                result2.focusNode = sel.focusNode;
-                result2.focusOffset = sel.focusOffset;
-              }
-            }
-            return result2;
-          }
-          function restoreSelection(snapshot) {
-            if (
-              !snapshot ||
-              !snapshot.activeElt ||
-              snapshot.activeElt == activeElt()
-            ) {
-              return;
-            }
-            snapshot.activeElt.focus();
-            if (
-              !/^(INPUT|TEXTAREA)$/.test(snapshot.activeElt.nodeName) &&
-              snapshot.anchorNode &&
-              contains(document.body, snapshot.anchorNode) &&
-              contains(document.body, snapshot.focusNode)
-            ) {
-              var sel = window.getSelection(),
-                range3 = document.createRange();
-              range3.setEnd(snapshot.anchorNode, snapshot.anchorOffset);
-              range3.collapse(false);
-              sel.removeAllRanges();
-              sel.addRange(range3);
-              sel.extend(snapshot.focusNode, snapshot.focusOffset);
-            }
-          }
-          function updateDisplayIfNeeded(cm, update) {
-            var display = cm.display,
-              doc = cm.doc;
-            if (update.editorIsHidden) {
-              resetView(cm);
-              return false;
-            }
-            if (
-              !update.force &&
-              update.visible.from >= display.viewFrom &&
-              update.visible.to <= display.viewTo &&
-              (display.updateLineNumbers == null ||
-                display.updateLineNumbers >= display.viewTo) &&
-              display.renderedView == display.view &&
-              countDirtyView(cm) == 0
-            ) {
-              return false;
-            }
-            if (maybeUpdateLineNumberWidth(cm)) {
-              resetView(cm);
-              update.dims = getDimensions(cm);
-            }
-            var end2 = doc.first + doc.size;
-            var from = Math.max(
-              update.visible.from - cm.options.viewportMargin,
-              doc.first
-            );
-            var to = Math.min(
-              end2,
-              update.visible.to + cm.options.viewportMargin
-            );
-            if (display.viewFrom < from && from - display.viewFrom < 20) {
-              from = Math.max(doc.first, display.viewFrom);
-            }
-            if (display.viewTo > to && display.viewTo - to < 20) {
-              to = Math.min(end2, display.viewTo);
-            }
-            if (sawCollapsedSpans) {
-              from = visualLineNo(cm.doc, from);
-              to = visualLineEndNo(cm.doc, to);
-            }
-            var different =
-              from != display.viewFrom ||
-              to != display.viewTo ||
-              display.lastWrapHeight != update.wrapperHeight ||
-              display.lastWrapWidth != update.wrapperWidth;
-            adjustView(cm, from, to);
-            display.viewOffset = heightAtLine(
-              getLine2(cm.doc, display.viewFrom)
-            );
-            cm.display.mover.style.top = display.viewOffset + "px";
-            var toUpdate = countDirtyView(cm);
-            if (
-              !different &&
-              toUpdate == 0 &&
-              !update.force &&
-              display.renderedView == display.view &&
-              (display.updateLineNumbers == null ||
-                display.updateLineNumbers >= display.viewTo)
-            ) {
-              return false;
-            }
-            var selSnapshot = selectionSnapshot(cm);
-            if (toUpdate > 4) {
-              display.lineDiv.style.display = "none";
-            }
-            patchDisplay(cm, display.updateLineNumbers, update.dims);
-            if (toUpdate > 4) {
-              display.lineDiv.style.display = "";
-            }
-            display.renderedView = display.view;
-            restoreSelection(selSnapshot);
-            removeChildren(display.cursorDiv);
-            removeChildren(display.selectionDiv);
-            display.gutters.style.height = display.sizer.style.minHeight = 0;
-            if (different) {
-              display.lastWrapHeight = update.wrapperHeight;
-              display.lastWrapWidth = update.wrapperWidth;
-              startWorker(cm, 400);
-            }
-            display.updateLineNumbers = null;
-            return true;
-          }
-          function postUpdateDisplay(cm, update) {
-            var viewport = update.viewport;
-            for (var first = true; ; first = false) {
-              if (
-                !first ||
-                !cm.options.lineWrapping ||
-                update.oldDisplayWidth == displayWidth(cm)
-              ) {
-                if (viewport && viewport.top != null) {
-                  viewport = {
-                    top: Math.min(
-                      cm.doc.height +
-                        paddingVert(cm.display) -
-                        displayHeight(cm),
-                      viewport.top
-                    ),
-                  };
-                }
-                update.visible = visibleLines(cm.display, cm.doc, viewport);
-                if (
-                  update.visible.from >= cm.display.viewFrom &&
-                  update.visible.to <= cm.display.viewTo
-                ) {
-                  break;
-                }
-              } else if (first) {
-                update.visible = visibleLines(cm.display, cm.doc, viewport);
-              }
-              if (!updateDisplayIfNeeded(cm, update)) {
-                break;
-              }
-              updateHeightsInViewport(cm);
-              var barMeasure = measureForScrollbars(cm);
-              updateSelection(cm);
-              updateScrollbars(cm, barMeasure);
-              setDocumentHeight(cm, barMeasure);
-              update.force = false;
-            }
-            update.signal(cm, "update", cm);
-            if (
-              cm.display.viewFrom != cm.display.reportedViewFrom ||
-              cm.display.viewTo != cm.display.reportedViewTo
-            ) {
-              update.signal(
-                cm,
-                "viewportChange",
-                cm,
-                cm.display.viewFrom,
-                cm.display.viewTo
-              );
-              cm.display.reportedViewFrom = cm.display.viewFrom;
-              cm.display.reportedViewTo = cm.display.viewTo;
-            }
-          }
-          function updateDisplaySimple(cm, viewport) {
-            var update = new DisplayUpdate(cm, viewport);
-            if (updateDisplayIfNeeded(cm, update)) {
-              updateHeightsInViewport(cm);
-              postUpdateDisplay(cm, update);
-              var barMeasure = measureForScrollbars(cm);
-              updateSelection(cm);
-              updateScrollbars(cm, barMeasure);
-              setDocumentHeight(cm, barMeasure);
-              update.finish();
-            }
-          }
-          function patchDisplay(cm, updateNumbersFrom, dims) {
-            var display = cm.display,
-              lineNumbers = cm.options.lineNumbers;
-            var container = display.lineDiv,
-              cur = container.firstChild;
-            function rm(node2) {
-              var next = node2.nextSibling;
-              if (webkit && mac && cm.display.currentWheelTarget == node2) {
-                node2.style.display = "none";
-              } else {
-                node2.parentNode.removeChild(node2);
-              }
-              return next;
-            }
-            var view = display.view,
-              lineN = display.viewFrom;
-            for (var i2 = 0; i2 < view.length; i2++) {
-              var lineView = view[i2];
-              if (lineView.hidden);
-              else if (
-                !lineView.node ||
-                lineView.node.parentNode != container
-              ) {
-                var node = buildLineElement(cm, lineView, lineN, dims);
-                container.insertBefore(node, cur);
-              } else {
-                while (cur != lineView.node) {
-                  cur = rm(cur);
-                }
-                var updateNumber =
-                  lineNumbers &&
-                  updateNumbersFrom != null &&
-                  updateNumbersFrom <= lineN &&
-                  lineView.lineNumber;
-                if (lineView.changes) {
-                  if (indexOf(lineView.changes, "gutter") > -1) {
-                    updateNumber = false;
-                  }
-                  updateLineForChanges(cm, lineView, lineN, dims);
-                }
-                if (updateNumber) {
-                  removeChildren(lineView.lineNumber);
-                  lineView.lineNumber.appendChild(
-                    document.createTextNode(lineNumberFor(cm.options, lineN))
-                  );
-                }
-                cur = lineView.node.nextSibling;
-              }
-              lineN += lineView.size;
-            }
-            while (cur) {
-              cur = rm(cur);
-            }
-          }
-          function updateGutterSpace(display) {
-            var width = display.gutters.offsetWidth;
-            display.sizer.style.marginLeft = width + "px";
-            signalLater(display, "gutterChanged", display);
-          }
-          function setDocumentHeight(cm, measure) {
-            cm.display.sizer.style.minHeight = measure.docHeight + "px";
-            cm.display.heightForcer.style.top = measure.docHeight + "px";
-            cm.display.gutters.style.height =
-              measure.docHeight + cm.display.barHeight + scrollGap(cm) + "px";
-          }
-          function alignHorizontally(cm) {
-            var display = cm.display,
-              view = display.view;
-            if (
-              !display.alignWidgets &&
-              (!display.gutters.firstChild || !cm.options.fixedGutter)
-            ) {
-              return;
-            }
-            var comp2 =
-              compensateForHScroll(display) -
-              display.scroller.scrollLeft +
-              cm.doc.scrollLeft;
-            var gutterW = display.gutters.offsetWidth,
-              left = comp2 + "px";
-            for (var i2 = 0; i2 < view.length; i2++) {
-              if (!view[i2].hidden) {
-                if (cm.options.fixedGutter) {
-                  if (view[i2].gutter) {
-                    view[i2].gutter.style.left = left;
-                  }
-                  if (view[i2].gutterBackground) {
-                    view[i2].gutterBackground.style.left = left;
-                  }
-                }
-                var align = view[i2].alignable;
-                if (align) {
-                  for (var j = 0; j < align.length; j++) {
-                    align[j].style.left = left;
-                  }
-                }
-              }
-            }
-            if (cm.options.fixedGutter) {
-              display.gutters.style.left = comp2 + gutterW + "px";
-            }
-          }
-          function maybeUpdateLineNumberWidth(cm) {
-            if (!cm.options.lineNumbers) {
-              return false;
-            }
-            var doc = cm.doc,
-              last = lineNumberFor(cm.options, doc.first + doc.size - 1),
-              display = cm.display;
-            if (last.length != display.lineNumChars) {
-              var test2 = display.measure.appendChild(
-                elt(
-                  "div",
-                  [elt("div", last)],
-                  "CodeMirror-linenumber CodeMirror-gutter-elt"
-                )
-              );
-              var innerW = test2.firstChild.offsetWidth,
-                padding = test2.offsetWidth - innerW;
-              display.lineGutter.style.width = "";
-              display.lineNumInnerWidth =
-                Math.max(innerW, display.lineGutter.offsetWidth - padding) + 1;
-              display.lineNumWidth = display.lineNumInnerWidth + padding;
-              display.lineNumChars = display.lineNumInnerWidth
-                ? last.length
-                : -1;
-              display.lineGutter.style.width = display.lineNumWidth + "px";
-              updateGutterSpace(cm.display);
-              return true;
-            }
-            return false;
-          }
-          function getGutters(gutters, lineNumbers) {
-            var result2 = [],
-              sawLineNumbers = false;
-            for (var i2 = 0; i2 < gutters.length; i2++) {
-              var name2 = gutters[i2],
-                style = null;
-              if (typeof name2 != "string") {
-                style = name2.style;
-                name2 = name2.className;
-              }
-              if (name2 == "CodeMirror-linenumbers") {
-                if (!lineNumbers) {
-                  continue;
-                } else {
-                  sawLineNumbers = true;
-                }
-              }
-              result2.push({ className: name2, style });
-            }
-            if (lineNumbers && !sawLineNumbers) {
-              result2.push({
-                className: "CodeMirror-linenumbers",
-                style: null,
-              });
-            }
-            return result2;
-          }
-          function renderGutters(display) {
-            var gutters = display.gutters,
-              specs = display.gutterSpecs;
-            removeChildren(gutters);
-            display.lineGutter = null;
-            for (var i2 = 0; i2 < specs.length; ++i2) {
-              var ref = specs[i2];
-              var className = ref.className;
-              var style = ref.style;
-              var gElt = gutters.appendChild(
-                elt("div", null, "CodeMirror-gutter " + className)
-              );
-              if (style) {
-                gElt.style.cssText = style;
-              }
-              if (className == "CodeMirror-linenumbers") {
-                display.lineGutter = gElt;
-                gElt.style.width = (display.lineNumWidth || 1) + "px";
-              }
-            }
-            gutters.style.display = specs.length ? "" : "none";
-            updateGutterSpace(display);
-          }
-          function updateGutters(cm) {
-            renderGutters(cm.display);
-            regChange(cm);
-            alignHorizontally(cm);
-          }
-          function Display(place, doc, input, options) {
-            var d = this;
-            this.input = input;
-            d.scrollbarFiller = elt("div", null, "CodeMirror-scrollbar-filler");
-            d.scrollbarFiller.setAttribute("cm-not-content", "true");
-            d.gutterFiller = elt("div", null, "CodeMirror-gutter-filler");
-            d.gutterFiller.setAttribute("cm-not-content", "true");
-            d.lineDiv = eltP("div", null, "CodeMirror-code");
-            d.selectionDiv = elt(
-              "div",
-              null,
-              null,
-              "position: relative; z-index: 1"
-            );
-            d.cursorDiv = elt("div", null, "CodeMirror-cursors");
-            d.measure = elt("div", null, "CodeMirror-measure");
-            d.lineMeasure = elt("div", null, "CodeMirror-measure");
-            d.lineSpace = eltP(
-              "div",
-              [
-                d.measure,
-                d.lineMeasure,
-                d.selectionDiv,
-                d.cursorDiv,
-                d.lineDiv,
-              ],
-              null,
-              "position: relative; outline: none"
-            );
-            var lines = eltP("div", [d.lineSpace], "CodeMirror-lines");
-            d.mover = elt("div", [lines], null, "position: relative");
-            d.sizer = elt("div", [d.mover], "CodeMirror-sizer");
-            d.sizerWidth = null;
-            d.heightForcer = elt(
-              "div",
-              null,
-              null,
-              "position: absolute; height: " + scrollerGap + "px; width: 1px;"
-            );
-            d.gutters = elt("div", null, "CodeMirror-gutters");
-            d.lineGutter = null;
-            d.scroller = elt(
-              "div",
-              [d.sizer, d.heightForcer, d.gutters],
-              "CodeMirror-scroll"
-            );
-            d.scroller.setAttribute("tabIndex", "-1");
-            d.wrapper = elt(
-              "div",
-              [d.scrollbarFiller, d.gutterFiller, d.scroller],
-              "CodeMirror"
-            );
-            d.wrapper.setAttribute("translate", "no");
-            if (ie2 && ie_version < 8) {
-              d.gutters.style.zIndex = -1;
-              d.scroller.style.paddingRight = 0;
-            }
-            if (!webkit && !(gecko && mobile)) {
-              d.scroller.draggable = true;
-            }
-            if (place) {
-              if (place.appendChild) {
-                place.appendChild(d.wrapper);
-              } else {
-                place(d.wrapper);
-              }
-            }
-            d.viewFrom = d.viewTo = doc.first;
-            d.reportedViewFrom = d.reportedViewTo = doc.first;
-            d.view = [];
-            d.renderedView = null;
-            d.externalMeasured = null;
-            d.viewOffset = 0;
-            d.lastWrapHeight = d.lastWrapWidth = 0;
-            d.updateLineNumbers = null;
-            d.nativeBarWidth = d.barHeight = d.barWidth = 0;
-            d.scrollbarsClipped = false;
-            d.lineNumWidth = d.lineNumInnerWidth = d.lineNumChars = null;
-            d.alignWidgets = false;
-            d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;
-            d.maxLine = null;
-            d.maxLineLength = 0;
-            d.maxLineChanged = false;
-            d.wheelDX = d.wheelDY = d.wheelStartX = d.wheelStartY = null;
-            d.shift = false;
-            d.selForContextMenu = null;
-            d.activeTouch = null;
-            d.gutterSpecs = getGutters(options.gutters, options.lineNumbers);
-            renderGutters(d);
-            input.init(d);
-          }
-          var wheelSamples = 0,
-            wheelPixelsPerUnit = null;
-          if (ie2) {
-            wheelPixelsPerUnit = -0.53;
-          } else if (gecko) {
-            wheelPixelsPerUnit = 15;
-          } else if (chrome) {
-            wheelPixelsPerUnit = -0.7;
-          } else if (safari) {
-            wheelPixelsPerUnit = -1 / 3;
-          }
-          function wheelEventDelta(e) {
-            var dx = e.wheelDeltaX,
-              dy = e.wheelDeltaY;
-            if (dx == null && e.detail && e.axis == e.HORIZONTAL_AXIS) {
-              dx = e.detail;
-            }
-            if (dy == null && e.detail && e.axis == e.VERTICAL_AXIS) {
-              dy = e.detail;
-            } else if (dy == null) {
-              dy = e.wheelDelta;
-            }
-            return { x: dx, y: dy };
-          }
-          function wheelEventPixels(e) {
-            var delta2 = wheelEventDelta(e);
-            delta2.x *= wheelPixelsPerUnit;
-            delta2.y *= wheelPixelsPerUnit;
-            return delta2;
-          }
-          function onScrollWheel(cm, e) {
-            var delta2 = wheelEventDelta(e),
-              dx = delta2.x,
-              dy = delta2.y;
-            var pixelsPerUnit = wheelPixelsPerUnit;
-            if (e.deltaMode === 0) {
-              dx = e.deltaX;
-              dy = e.deltaY;
-              pixelsPerUnit = 1;
-            }
-            var display = cm.display,
-              scroll = display.scroller;
-            var canScrollX = scroll.scrollWidth > scroll.clientWidth;
-            var canScrollY = scroll.scrollHeight > scroll.clientHeight;
-            if (!((dx && canScrollX) || (dy && canScrollY))) {
-              return;
-            }
-            if (dy && mac && webkit) {
-              outer: for (
-                var cur = e.target, view = display.view;
-                cur != scroll;
-                cur = cur.parentNode
-              ) {
-                for (var i2 = 0; i2 < view.length; i2++) {
-                  if (view[i2].node == cur) {
-                    cm.display.currentWheelTarget = cur;
-                    break outer;
-                  }
-                }
-              }
-            }
-            if (dx && !gecko && !presto && pixelsPerUnit != null) {
-              if (dy && canScrollY) {
-                updateScrollTop(
-                  cm,
-                  Math.max(0, scroll.scrollTop + dy * pixelsPerUnit)
-                );
-              }
-              setScrollLeft(
-                cm,
-                Math.max(0, scroll.scrollLeft + dx * pixelsPerUnit)
-              );
-              if (!dy || (dy && canScrollY)) {
-                e_preventDefault(e);
-              }
-              display.wheelStartX = null;
-              return;
-            }
-            if (dy && pixelsPerUnit != null) {
-              var pixels = dy * pixelsPerUnit;
-              var top2 = cm.doc.scrollTop,
-                bot2 = top2 + display.wrapper.clientHeight;
-              if (pixels < 0) {
-                top2 = Math.max(0, top2 + pixels - 50);
-              } else {
-                bot2 = Math.min(cm.doc.height, bot2 + pixels + 50);
-              }
-              updateDisplaySimple(cm, { top: top2, bottom: bot2 });
-            }
-            if (wheelSamples < 20 && e.deltaMode !== 0) {
-              if (display.wheelStartX == null) {
-                display.wheelStartX = scroll.scrollLeft;
-                display.wheelStartY = scroll.scrollTop;
-                display.wheelDX = dx;
-                display.wheelDY = dy;
-                setTimeout(function () {
-                  if (display.wheelStartX == null) {
-                    return;
-                  }
-                  var movedX = scroll.scrollLeft - display.wheelStartX;
-                  var movedY = scroll.scrollTop - display.wheelStartY;
-                  var sample =
-                    (movedY && display.wheelDY && movedY / display.wheelDY) ||
-                    (movedX && display.wheelDX && movedX / display.wheelDX);
-                  display.wheelStartX = display.wheelStartY = null;
-                  if (!sample) {
-                    return;
-                  }
-                  wheelPixelsPerUnit =
-                    (wheelPixelsPerUnit * wheelSamples + sample) /
-                    (wheelSamples + 1);
-                  ++wheelSamples;
-                }, 200);
-              } else {
-                display.wheelDX += dx;
-                display.wheelDY += dy;
-              }
-            }
-          }
-          var Selection = function (ranges, primIndex) {
-            this.ranges = ranges;
-            this.primIndex = primIndex;
-          };
-          Selection.prototype.primary = function () {
-            return this.ranges[this.primIndex];
-          };
-          Selection.prototype.equals = function (other) {
-            if (other == this) {
-              return true;
-            }
-            if (
-              other.primIndex != this.primIndex ||
-              other.ranges.length != this.ranges.length
-            ) {
-              return false;
-            }
-            for (var i2 = 0; i2 < this.ranges.length; i2++) {
-              var here = this.ranges[i2],
-                there = other.ranges[i2];
-              if (
-                !equalCursorPos(here.anchor, there.anchor) ||
-                !equalCursorPos(here.head, there.head)
-              ) {
-                return false;
-              }
-            }
-            return true;
-          };
-          Selection.prototype.deepCopy = function () {
-            var out = [];
-            for (var i2 = 0; i2 < this.ranges.length; i2++) {
-              out[i2] = new Range2(
-                copyPos(this.ranges[i2].anchor),
-                copyPos(this.ranges[i2].head)
-              );
-            }
-            return new Selection(out, this.primIndex);
-          };
-          Selection.prototype.somethingSelected = function () {
-            for (var i2 = 0; i2 < this.ranges.length; i2++) {
-              if (!this.ranges[i2].empty()) {
-                return true;
-              }
-            }
-            return false;
-          };
-          Selection.prototype.contains = function (pos, end2) {
-            if (!end2) {
-              end2 = pos;
-            }
-            for (var i2 = 0; i2 < this.ranges.length; i2++) {
-              var range3 = this.ranges[i2];
-              if (cmp(end2, range3.from()) >= 0 && cmp(pos, range3.to()) <= 0) {
-                return i2;
-              }
-            }
-            return -1;
-          };
-          var Range2 = function (anchor, head) {
-            this.anchor = anchor;
-            this.head = head;
-          };
-          Range2.prototype.from = function () {
-            return minPos(this.anchor, this.head);
-          };
-          Range2.prototype.to = function () {
-            return maxPos(this.anchor, this.head);
-          };
-          Range2.prototype.empty = function () {
-            return (
-              this.head.line == this.anchor.line &&
-              this.head.ch == this.anchor.ch
-            );
-          };
-          function normalizeSelection(cm, ranges, primIndex) {
-            var mayTouch = cm && cm.options.selectionsMayTouch;
-            var prim = ranges[primIndex];
-            ranges.sort(function (a, b) {
-              return cmp(a.from(), b.from());
-            });
-            primIndex = indexOf(ranges, prim);
-            for (var i2 = 1; i2 < ranges.length; i2++) {
-              var cur = ranges[i2],
-                prev = ranges[i2 - 1];
-              var diff2 = cmp(prev.to(), cur.from());
-              if (mayTouch && !cur.empty() ? diff2 > 0 : diff2 >= 0) {
-                var from = minPos(prev.from(), cur.from()),
-                  to = maxPos(prev.to(), cur.to());
-                var inv = prev.empty()
-                  ? cur.from() == cur.head
-                  : prev.from() == prev.head;
-                if (i2 <= primIndex) {
-                  --primIndex;
-                }
-                ranges.splice(
-                  --i2,
-                  2,
-                  new Range2(inv ? to : from, inv ? from : to)
-                );
-              }
-            }
-            return new Selection(ranges, primIndex);
-          }
-          function simpleSelection(anchor, head) {
-            return new Selection([new Range2(anchor, head || anchor)], 0);
-          }
-          function changeEnd(change) {
-            if (!change.text) {
-              return change.to;
-            }
-            return Pos(
-              change.from.line + change.text.length - 1,
-              lst(change.text).length +
-                (change.text.length == 1 ? change.from.ch : 0)
-            );
-          }
-          function adjustForChange(pos, change) {
-            if (cmp(pos, change.from) < 0) {
-              return pos;
-            }
-            if (cmp(pos, change.to) <= 0) {
-              return changeEnd(change);
-            }
-            var line =
-                pos.line +
-                change.text.length -
-                (change.to.line - change.from.line) -
-                1,
-              ch2 = pos.ch;
-            if (pos.line == change.to.line) {
-              ch2 += changeEnd(change).ch - change.to.ch;
-            }
-            return Pos(line, ch2);
-          }
-          function computeSelAfterChange(doc, change) {
-            var out = [];
-            for (var i2 = 0; i2 < doc.sel.ranges.length; i2++) {
-              var range3 = doc.sel.ranges[i2];
-              out.push(
-                new Range2(
-                  adjustForChange(range3.anchor, change),
-                  adjustForChange(range3.head, change)
-                )
-              );
-            }
-            return normalizeSelection(doc.cm, out, doc.sel.primIndex);
-          }
-          function offsetPos(pos, old, nw) {
-            if (pos.line == old.line) {
-              return Pos(nw.line, pos.ch - old.ch + nw.ch);
-            } else {
-              return Pos(nw.line + (pos.line - old.line), pos.ch);
-            }
-          }
-          function computeReplacedSel(doc, changes, hint2) {
-            var out = [];
-            var oldPrev = Pos(doc.first, 0),
-              newPrev = oldPrev;
-            for (var i2 = 0; i2 < changes.length; i2++) {
-              var change = changes[i2];
-              var from = offsetPos(change.from, oldPrev, newPrev);
-              var to = offsetPos(changeEnd(change), oldPrev, newPrev);
-              oldPrev = change.to;
-              newPrev = to;
-              if (hint2 == "around") {
-                var range3 = doc.sel.ranges[i2],
-                  inv = cmp(range3.head, range3.anchor) < 0;
-                out[i2] = new Range2(inv ? to : from, inv ? from : to);
-              } else {
-                out[i2] = new Range2(from, from);
-              }
-            }
-            return new Selection(out, doc.sel.primIndex);
-          }
-          function loadMode(cm) {
-            cm.doc.mode = getMode(cm.options, cm.doc.modeOption);
-            resetModeState(cm);
-          }
-          function resetModeState(cm) {
-            cm.doc.iter(function (line) {
-              if (line.stateAfter) {
-                line.stateAfter = null;
-              }
-              if (line.styles) {
-                line.styles = null;
-              }
-            });
-            cm.doc.modeFrontier = cm.doc.highlightFrontier = cm.doc.first;
-            startWorker(cm, 100);
-            cm.state.modeGen++;
-            if (cm.curOp) {
-              regChange(cm);
-            }
-          }
-          function isWholeLineUpdate(doc, change) {
-            return (
-              change.from.ch == 0 &&
-              change.to.ch == 0 &&
-              lst(change.text) == "" &&
-              (!doc.cm || doc.cm.options.wholeLineUpdateBefore)
-            );
-          }
-          function updateDoc(doc, change, markedSpans, estimateHeight2) {
-            function spansFor(n2) {
-              return markedSpans ? markedSpans[n2] : null;
-            }
-            function update(line, text4, spans) {
-              updateLine(line, text4, spans, estimateHeight2);
-              signalLater(line, "change", line, change);
-            }
-            function linesFor(start2, end2) {
-              var result2 = [];
-              for (var i2 = start2; i2 < end2; ++i2) {
-                result2.push(
-                  new Line(text3[i2], spansFor(i2), estimateHeight2)
-                );
-              }
-              return result2;
-            }
-            var from = change.from,
-              to = change.to,
-              text3 = change.text;
-            var firstLine = getLine2(doc, from.line),
-              lastLine = getLine2(doc, to.line);
-            var lastText = lst(text3),
-              lastSpans = spansFor(text3.length - 1),
-              nlines = to.line - from.line;
-            if (change.full) {
-              doc.insert(0, linesFor(0, text3.length));
-              doc.remove(text3.length, doc.size - text3.length);
-            } else if (isWholeLineUpdate(doc, change)) {
-              var added = linesFor(0, text3.length - 1);
-              update(lastLine, lastLine.text, lastSpans);
-              if (nlines) {
-                doc.remove(from.line, nlines);
-              }
-              if (added.length) {
-                doc.insert(from.line, added);
-              }
-            } else if (firstLine == lastLine) {
-              if (text3.length == 1) {
-                update(
-                  firstLine,
-                  firstLine.text.slice(0, from.ch) +
-                    lastText +
-                    firstLine.text.slice(to.ch),
-                  lastSpans
-                );
-              } else {
-                var added$1 = linesFor(1, text3.length - 1);
-                added$1.push(
-                  new Line(
-                    lastText + firstLine.text.slice(to.ch),
-                    lastSpans,
-                    estimateHeight2
-                  )
-                );
-                update(
-                  firstLine,
-                  firstLine.text.slice(0, from.ch) + text3[0],
-                  spansFor(0)
-                );
-                doc.insert(from.line + 1, added$1);
-              }
-            } else if (text3.length == 1) {
-              update(
-                firstLine,
-                firstLine.text.slice(0, from.ch) +
-                  text3[0] +
-                  lastLine.text.slice(to.ch),
-                spansFor(0)
-              );
-              doc.remove(from.line + 1, nlines);
-            } else {
-              update(
-                firstLine,
-                firstLine.text.slice(0, from.ch) + text3[0],
-                spansFor(0)
-              );
-              update(
-                lastLine,
-                lastText + lastLine.text.slice(to.ch),
-                lastSpans
-              );
-              var added$2 = linesFor(1, text3.length - 1);
-              if (nlines > 1) {
-                doc.remove(from.line + 1, nlines - 1);
-              }
-              doc.insert(from.line + 1, added$2);
-            }
-            signalLater(doc, "change", doc, change);
-          }
-          function linkedDocs(doc, f, sharedHistOnly) {
-            function propagate(doc2, skip2, sharedHist) {
-              if (doc2.linked) {
-                for (var i2 = 0; i2 < doc2.linked.length; ++i2) {
-                  var rel = doc2.linked[i2];
-                  if (rel.doc == skip2) {
-                    continue;
-                  }
-                  var shared = sharedHist && rel.sharedHist;
-                  if (sharedHistOnly && !shared) {
-                    continue;
-                  }
-                  f(rel.doc, shared);
-                  propagate(rel.doc, doc2, shared);
-                }
-              }
-            }
-            propagate(doc, null, true);
-          }
-          function attachDoc(cm, doc) {
-            if (doc.cm) {
-              throw new Error("This document is already in use.");
-            }
-            cm.doc = doc;
-            doc.cm = cm;
-            estimateLineHeights(cm);
-            loadMode(cm);
-            setDirectionClass(cm);
-            cm.options.direction = doc.direction;
-            if (!cm.options.lineWrapping) {
-              findMaxLine(cm);
-            }
-            cm.options.mode = doc.modeOption;
-            regChange(cm);
-          }
-          function setDirectionClass(cm) {
-            (cm.doc.direction == "rtl"
-              ? addClass
-              : rmClass)(cm.display.lineDiv, "CodeMirror-rtl");
-          }
-          function directionChanged(cm) {
-            runInOp(cm, function () {
-              setDirectionClass(cm);
-              regChange(cm);
-            });
-          }
-          function History(prev) {
-            this.done = [];
-            this.undone = [];
-            this.undoDepth = prev ? prev.undoDepth : Infinity;
-            this.lastModTime = this.lastSelTime = 0;
-            this.lastOp = this.lastSelOp = null;
-            this.lastOrigin = this.lastSelOrigin = null;
-            this.generation = this.maxGeneration = prev
-              ? prev.maxGeneration
-              : 1;
-          }
-          function historyChangeFromChange(doc, change) {
-            var histChange = {
-              from: copyPos(change.from),
-              to: changeEnd(change),
-              text: getBetween(doc, change.from, change.to),
-            };
-            attachLocalSpans(
-              doc,
-              histChange,
-              change.from.line,
-              change.to.line + 1
-            );
-            linkedDocs(
-              doc,
-              function (doc2) {
-                return attachLocalSpans(
-                  doc2,
-                  histChange,
-                  change.from.line,
-                  change.to.line + 1
-                );
-              },
-              true
-            );
-            return histChange;
-          }
-          function clearSelectionEvents(array) {
-            while (array.length) {
-              var last = lst(array);
-              if (last.ranges) {
-                array.pop();
-              } else {
-                break;
-              }
-            }
-          }
-          function lastChangeEvent(hist, force) {
-            if (force) {
-              clearSelectionEvents(hist.done);
-              return lst(hist.done);
-            } else if (hist.done.length && !lst(hist.done).ranges) {
-              return lst(hist.done);
-            } else if (
-              hist.done.length > 1 &&
-              !hist.done[hist.done.length - 2].ranges
-            ) {
-              hist.done.pop();
-              return lst(hist.done);
-            }
-          }
-          function addChangeToHistory(doc, change, selAfter, opId) {
-            var hist = doc.history;
-            hist.undone.length = 0;
-            var time = +new Date(),
-              cur;
-            var last;
-            if (
-              (hist.lastOp == opId ||
-                (hist.lastOrigin == change.origin &&
-                  change.origin &&
-                  ((change.origin.charAt(0) == "+" &&
-                    hist.lastModTime >
-                      time -
-                        (doc.cm ? doc.cm.options.historyEventDelay : 500)) ||
-                    change.origin.charAt(0) == "*"))) &&
-              (cur = lastChangeEvent(hist, hist.lastOp == opId))
-            ) {
-              last = lst(cur.changes);
-              if (
-                cmp(change.from, change.to) == 0 &&
-                cmp(change.from, last.to) == 0
-              ) {
-                last.to = changeEnd(change);
-              } else {
-                cur.changes.push(historyChangeFromChange(doc, change));
-              }
-            } else {
-              var before = lst(hist.done);
-              if (!before || !before.ranges) {
-                pushSelectionToHistory(doc.sel, hist.done);
-              }
-              cur = {
-                changes: [historyChangeFromChange(doc, change)],
-                generation: hist.generation,
-              };
-              hist.done.push(cur);
-              while (hist.done.length > hist.undoDepth) {
-                hist.done.shift();
-                if (!hist.done[0].ranges) {
-                  hist.done.shift();
-                }
-              }
-            }
-            hist.done.push(selAfter);
-            hist.generation = ++hist.maxGeneration;
-            hist.lastModTime = hist.lastSelTime = time;
-            hist.lastOp = hist.lastSelOp = opId;
-            hist.lastOrigin = hist.lastSelOrigin = change.origin;
-            if (!last) {
-              signal(doc, "historyAdded");
-            }
-          }
-          function selectionEventCanBeMerged(doc, origin, prev, sel) {
-            var ch2 = origin.charAt(0);
-            return (
-              ch2 == "*" ||
-              (ch2 == "+" &&
-                prev.ranges.length == sel.ranges.length &&
-                prev.somethingSelected() == sel.somethingSelected() &&
-                new Date() - doc.history.lastSelTime <=
-                  (doc.cm ? doc.cm.options.historyEventDelay : 500))
-            );
-          }
-          function addSelectionToHistory(doc, sel, opId, options) {
-            var hist = doc.history,
-              origin = options && options.origin;
-            if (
-              opId == hist.lastSelOp ||
-              (origin &&
-                hist.lastSelOrigin == origin &&
-                ((hist.lastModTime == hist.lastSelTime &&
-                  hist.lastOrigin == origin) ||
-                  selectionEventCanBeMerged(doc, origin, lst(hist.done), sel)))
-            ) {
-              hist.done[hist.done.length - 1] = sel;
-            } else {
-              pushSelectionToHistory(sel, hist.done);
-            }
-            hist.lastSelTime = +new Date();
-            hist.lastSelOrigin = origin;
-            hist.lastSelOp = opId;
-            if (options && options.clearRedo !== false) {
-              clearSelectionEvents(hist.undone);
-            }
-          }
-          function pushSelectionToHistory(sel, dest) {
-            var top2 = lst(dest);
-            if (!(top2 && top2.ranges && top2.equals(sel))) {
-              dest.push(sel);
-            }
-          }
-          function attachLocalSpans(doc, change, from, to) {
-            var existing = change["spans_" + doc.id],
-              n2 = 0;
-            doc.iter(
-              Math.max(doc.first, from),
-              Math.min(doc.first + doc.size, to),
-              function (line) {
-                if (line.markedSpans) {
-                  (existing || (existing = change["spans_" + doc.id] = {}))[
-                    n2
-                  ] = line.markedSpans;
-                }
-                ++n2;
-              }
-            );
-          }
-          function removeClearedSpans(spans) {
-            if (!spans) {
-              return null;
-            }
-            var out;
-            for (var i2 = 0; i2 < spans.length; ++i2) {
-              if (spans[i2].marker.explicitlyCleared) {
-                if (!out) {
-                  out = spans.slice(0, i2);
-                }
-              } else if (out) {
-                out.push(spans[i2]);
-              }
-            }
-            return !out ? spans : out.length ? out : null;
-          }
-          function getOldSpans(doc, change) {
-            var found = change["spans_" + doc.id];
-            if (!found) {
-              return null;
-            }
-            var nw = [];
-            for (var i2 = 0; i2 < change.text.length; ++i2) {
-              nw.push(removeClearedSpans(found[i2]));
-            }
-            return nw;
-          }
-          function mergeOldSpans(doc, change) {
-            var old = getOldSpans(doc, change);
-            var stretched = stretchSpansOverChange(doc, change);
-            if (!old) {
-              return stretched;
-            }
-            if (!stretched) {
-              return old;
-            }
-            for (var i2 = 0; i2 < old.length; ++i2) {
-              var oldCur = old[i2],
-                stretchCur = stretched[i2];
-              if (oldCur && stretchCur) {
-                spans: for (var j = 0; j < stretchCur.length; ++j) {
-                  var span = stretchCur[j];
-                  for (var k = 0; k < oldCur.length; ++k) {
-                    if (oldCur[k].marker == span.marker) {
-                      continue spans;
-                    }
-                  }
-                  oldCur.push(span);
-                }
-              } else if (stretchCur) {
-                old[i2] = stretchCur;
-              }
-            }
-            return old;
-          }
-          function copyHistoryArray(events, newGroup, instantiateSel) {
-            var copy2 = [];
-            for (var i2 = 0; i2 < events.length; ++i2) {
-              var event = events[i2];
-              if (event.ranges) {
-                copy2.push(
-                  instantiateSel
-                    ? Selection.prototype.deepCopy.call(event)
-                    : event
-                );
-                continue;
-              }
-              var changes = event.changes,
-                newChanges = [];
-              copy2.push({ changes: newChanges });
-              for (var j = 0; j < changes.length; ++j) {
-                var change = changes[j],
-                  m = void 0;
-                newChanges.push({
-                  from: change.from,
-                  to: change.to,
-                  text: change.text,
-                });
-                if (newGroup) {
-                  for (var prop3 in change) {
-                    if ((m = prop3.match(/^spans_(\d+)$/))) {
-                      if (indexOf(newGroup, Number(m[1])) > -1) {
-                        lst(newChanges)[prop3] = change[prop3];
-                        delete change[prop3];
-                      }
-                    }
-                  }
-                }
-              }
-            }
-            return copy2;
-          }
-          function extendRange(range3, head, other, extend) {
-            if (extend) {
-              var anchor = range3.anchor;
-              if (other) {
-                var posBefore = cmp(head, anchor) < 0;
-                if (posBefore != cmp(other, anchor) < 0) {
-                  anchor = head;
-                  head = other;
-                } else if (posBefore != cmp(head, other) < 0) {
-                  head = other;
-                }
-              }
-              return new Range2(anchor, head);
-            } else {
-              return new Range2(other || head, head);
-            }
-          }
-          function extendSelection(doc, head, other, options, extend) {
-            if (extend == null) {
-              extend = doc.cm && (doc.cm.display.shift || doc.extend);
-            }
-            setSelection(
-              doc,
-              new Selection(
-                [extendRange(doc.sel.primary(), head, other, extend)],
-                0
-              ),
-              options
-            );
-          }
-          function extendSelections(doc, heads, options) {
-            var out = [];
-            var extend = doc.cm && (doc.cm.display.shift || doc.extend);
-            for (var i2 = 0; i2 < doc.sel.ranges.length; i2++) {
-              out[i2] = extendRange(
-                doc.sel.ranges[i2],
-                heads[i2],
-                null,
-                extend
-              );
-            }
-            var newSel = normalizeSelection(doc.cm, out, doc.sel.primIndex);
-            setSelection(doc, newSel, options);
-          }
-          function replaceOneSelection(doc, i2, range3, options) {
-            var ranges = doc.sel.ranges.slice(0);
-            ranges[i2] = range3;
-            setSelection(
-              doc,
-              normalizeSelection(doc.cm, ranges, doc.sel.primIndex),
-              options
-            );
-          }
-          function setSimpleSelection(doc, anchor, head, options) {
-            setSelection(doc, simpleSelection(anchor, head), options);
-          }
-          function filterSelectionChange(doc, sel, options) {
-            var obj = {
-              ranges: sel.ranges,
-              update: function (ranges) {
-                this.ranges = [];
-                for (var i2 = 0; i2 < ranges.length; i2++) {
-                  this.ranges[i2] = new Range2(
-                    clipPos(doc, ranges[i2].anchor),
-                    clipPos(doc, ranges[i2].head)
-                  );
-                }
-              },
-              origin: options && options.origin,
-            };
-            signal(doc, "beforeSelectionChange", doc, obj);
-            if (doc.cm) {
-              signal(doc.cm, "beforeSelectionChange", doc.cm, obj);
-            }
-            if (obj.ranges != sel.ranges) {
-              return normalizeSelection(
-                doc.cm,
-                obj.ranges,
-                obj.ranges.length - 1
-              );
-            } else {
-              return sel;
-            }
-          }
-          function setSelectionReplaceHistory(doc, sel, options) {
-            var done = doc.history.done,
-              last = lst(done);
-            if (last && last.ranges) {
-              done[done.length - 1] = sel;
-              setSelectionNoUndo(doc, sel, options);
-            } else {
-              setSelection(doc, sel, options);
-            }
-          }
-          function setSelection(doc, sel, options) {
-            setSelectionNoUndo(doc, sel, options);
-            addSelectionToHistory(
-              doc,
-              doc.sel,
-              doc.cm ? doc.cm.curOp.id : NaN,
-              options
-            );
-          }
-          function setSelectionNoUndo(doc, sel, options) {
-            if (
-              hasHandler(doc, "beforeSelectionChange") ||
-              (doc.cm && hasHandler(doc.cm, "beforeSelectionChange"))
-            ) {
-              sel = filterSelectionChange(doc, sel, options);
-            }
-            var bias =
-              (options && options.bias) ||
-              (cmp(sel.primary().head, doc.sel.primary().head) < 0 ? -1 : 1);
-            setSelectionInner(doc, skipAtomicInSelection(doc, sel, bias, true));
-            if (
-              !(options && options.scroll === false) &&
-              doc.cm &&
-              doc.cm.getOption("readOnly") != "nocursor"
-            ) {
-              ensureCursorVisible(doc.cm);
-            }
-          }
-          function setSelectionInner(doc, sel) {
-            if (sel.equals(doc.sel)) {
-              return;
-            }
-            doc.sel = sel;
-            if (doc.cm) {
-              doc.cm.curOp.updateInput = 1;
-              doc.cm.curOp.selectionChanged = true;
-              signalCursorActivity(doc.cm);
-            }
-            signalLater(doc, "cursorActivity", doc);
-          }
-          function reCheckSelection(doc) {
-            setSelectionInner(
-              doc,
-              skipAtomicInSelection(doc, doc.sel, null, false)
-            );
-          }
-          function skipAtomicInSelection(doc, sel, bias, mayClear) {
-            var out;
-            for (var i2 = 0; i2 < sel.ranges.length; i2++) {
-              var range3 = sel.ranges[i2];
-              var old =
-                sel.ranges.length == doc.sel.ranges.length &&
-                doc.sel.ranges[i2];
-              var newAnchor = skipAtomic(
-                doc,
-                range3.anchor,
-                old && old.anchor,
-                bias,
-                mayClear
-              );
-              var newHead = skipAtomic(
-                doc,
-                range3.head,
-                old && old.head,
-                bias,
-                mayClear
-              );
-              if (out || newAnchor != range3.anchor || newHead != range3.head) {
-                if (!out) {
-                  out = sel.ranges.slice(0, i2);
-                }
-                out[i2] = new Range2(newAnchor, newHead);
-              }
-            }
-            return out ? normalizeSelection(doc.cm, out, sel.primIndex) : sel;
-          }
-          function skipAtomicInner(doc, pos, oldPos, dir, mayClear) {
-            var line = getLine2(doc, pos.line);
-            if (line.markedSpans) {
-              for (var i2 = 0; i2 < line.markedSpans.length; ++i2) {
-                var sp = line.markedSpans[i2],
-                  m = sp.marker;
-                var preventCursorLeft =
-                  "selectLeft" in m ? !m.selectLeft : m.inclusiveLeft;
-                var preventCursorRight =
-                  "selectRight" in m ? !m.selectRight : m.inclusiveRight;
-                if (
-                  (sp.from == null ||
-                    (preventCursorLeft
-                      ? sp.from <= pos.ch
-                      : sp.from < pos.ch)) &&
-                  (sp.to == null ||
-                    (preventCursorRight ? sp.to >= pos.ch : sp.to > pos.ch))
-                ) {
-                  if (mayClear) {
-                    signal(m, "beforeCursorEnter");
-                    if (m.explicitlyCleared) {
-                      if (!line.markedSpans) {
-                        break;
-                      } else {
-                        --i2;
-                        continue;
-                      }
-                    }
-                  }
-                  if (!m.atomic) {
-                    continue;
-                  }
-                  if (oldPos) {
-                    var near = m.find(dir < 0 ? 1 : -1),
-                      diff2 = void 0;
-                    if (dir < 0 ? preventCursorRight : preventCursorLeft) {
-                      near = movePos(
-                        doc,
-                        near,
-                        -dir,
-                        near && near.line == pos.line ? line : null
-                      );
-                    }
-                    if (
-                      near &&
-                      near.line == pos.line &&
-                      (diff2 = cmp(near, oldPos)) &&
-                      (dir < 0 ? diff2 < 0 : diff2 > 0)
-                    ) {
-                      return skipAtomicInner(doc, near, pos, dir, mayClear);
-                    }
-                  }
-                  var far = m.find(dir < 0 ? -1 : 1);
-                  if (dir < 0 ? preventCursorLeft : preventCursorRight) {
-                    far = movePos(
-                      doc,
-                      far,
-                      dir,
-                      far.line == pos.line ? line : null
-                    );
-                  }
-                  return far
-                    ? skipAtomicInner(doc, far, pos, dir, mayClear)
-                    : null;
-                }
-              }
-            }
-            return pos;
-          }
-          function skipAtomic(doc, pos, oldPos, bias, mayClear) {
-            var dir = bias || 1;
-            var found =
-              skipAtomicInner(doc, pos, oldPos, dir, mayClear) ||
-              (!mayClear && skipAtomicInner(doc, pos, oldPos, dir, true)) ||
-              skipAtomicInner(doc, pos, oldPos, -dir, mayClear) ||
-              (!mayClear && skipAtomicInner(doc, pos, oldPos, -dir, true));
-            if (!found) {
-              doc.cantEdit = true;
-              return Pos(doc.first, 0);
-            }
-            return found;
-          }
-          function movePos(doc, pos, dir, line) {
-            if (dir < 0 && pos.ch == 0) {
-              if (pos.line > doc.first) {
-                return clipPos(doc, Pos(pos.line - 1));
-              } else {
-                return null;
-              }
-            } else if (
-              dir > 0 &&
-              pos.ch == (line || getLine2(doc, pos.line)).text.length
-            ) {
-              if (pos.line < doc.first + doc.size - 1) {
-                return Pos(pos.line + 1, 0);
-              } else {
-                return null;
-              }
-            } else {
-              return new Pos(pos.line, pos.ch + dir);
-            }
-          }
-          function selectAll(cm) {
-            cm.setSelection(
-              Pos(cm.firstLine(), 0),
-              Pos(cm.lastLine()),
-              sel_dontScroll
-            );
-          }
-          function filterChange(doc, change, update) {
-            var obj = {
-              canceled: false,
-              from: change.from,
-              to: change.to,
-              text: change.text,
-              origin: change.origin,
-              cancel: function () {
-                return (obj.canceled = true);
-              },
-            };
-            if (update) {
-              obj.update = function (from, to, text3, origin) {
-                if (from) {
-                  obj.from = clipPos(doc, from);
-                }
-                if (to) {
-                  obj.to = clipPos(doc, to);
-                }
-                if (text3) {
-                  obj.text = text3;
-                }
-                if (origin !== void 0) {
-                  obj.origin = origin;
-                }
-              };
-            }
-            signal(doc, "beforeChange", doc, obj);
-            if (doc.cm) {
-              signal(doc.cm, "beforeChange", doc.cm, obj);
-            }
-            if (obj.canceled) {
-              if (doc.cm) {
-                doc.cm.curOp.updateInput = 2;
-              }
-              return null;
-            }
-            return {
-              from: obj.from,
-              to: obj.to,
-              text: obj.text,
-              origin: obj.origin,
-            };
-          }
-          function makeChange(doc, change, ignoreReadOnly) {
-            if (doc.cm) {
-              if (!doc.cm.curOp) {
-                return operation(doc.cm, makeChange)(
-                  doc,
-                  change,
-                  ignoreReadOnly
-                );
-              }
-              if (doc.cm.state.suppressEdits) {
-                return;
-              }
-            }
-            if (
-              hasHandler(doc, "beforeChange") ||
-              (doc.cm && hasHandler(doc.cm, "beforeChange"))
-            ) {
-              change = filterChange(doc, change, true);
-              if (!change) {
-                return;
-              }
-            }
-            var split2 =
-              sawReadOnlySpans &&
-              !ignoreReadOnly &&
-              removeReadOnlyRanges(doc, change.from, change.to);
-            if (split2) {
-              for (var i2 = split2.length - 1; i2 >= 0; --i2) {
-                makeChangeInner(doc, {
-                  from: split2[i2].from,
-                  to: split2[i2].to,
-                  text: i2 ? [""] : change.text,
-                  origin: change.origin,
-                });
-              }
-            } else {
-              makeChangeInner(doc, change);
-            }
-          }
-          function makeChangeInner(doc, change) {
-            if (
-              change.text.length == 1 &&
-              change.text[0] == "" &&
-              cmp(change.from, change.to) == 0
-            ) {
-              return;
-            }
-            var selAfter = computeSelAfterChange(doc, change);
-            addChangeToHistory(
-              doc,
-              change,
-              selAfter,
-              doc.cm ? doc.cm.curOp.id : NaN
-            );
-            makeChangeSingleDoc(
-              doc,
-              change,
-              selAfter,
-              stretchSpansOverChange(doc, change)
-            );
-            var rebased = [];
-            linkedDocs(doc, function (doc2, sharedHist) {
-              if (!sharedHist && indexOf(rebased, doc2.history) == -1) {
-                rebaseHist(doc2.history, change);
-                rebased.push(doc2.history);
-              }
-              makeChangeSingleDoc(
-                doc2,
-                change,
-                null,
-                stretchSpansOverChange(doc2, change)
-              );
-            });
-          }
-          function makeChangeFromHistory(doc, type2, allowSelectionOnly) {
-            var suppress = doc.cm && doc.cm.state.suppressEdits;
-            if (suppress && !allowSelectionOnly) {
-              return;
-            }
-            var hist = doc.history,
-              event,
-              selAfter = doc.sel;
-            var source = type2 == "undo" ? hist.done : hist.undone,
-              dest = type2 == "undo" ? hist.undone : hist.done;
-            var i2 = 0;
-            for (; i2 < source.length; i2++) {
-              event = source[i2];
-              if (
-                allowSelectionOnly
-                  ? event.ranges && !event.equals(doc.sel)
-                  : !event.ranges
-              ) {
-                break;
-              }
-            }
-            if (i2 == source.length) {
-              return;
-            }
-            hist.lastOrigin = hist.lastSelOrigin = null;
-            for (;;) {
-              event = source.pop();
-              if (event.ranges) {
-                pushSelectionToHistory(event, dest);
-                if (allowSelectionOnly && !event.equals(doc.sel)) {
-                  setSelection(doc, event, { clearRedo: false });
-                  return;
-                }
-                selAfter = event;
-              } else if (suppress) {
-                source.push(event);
-                return;
-              } else {
-                break;
-              }
-            }
-            var antiChanges = [];
-            pushSelectionToHistory(selAfter, dest);
-            dest.push({ changes: antiChanges, generation: hist.generation });
-            hist.generation = event.generation || ++hist.maxGeneration;
-            var filter =
-              hasHandler(doc, "beforeChange") ||
-              (doc.cm && hasHandler(doc.cm, "beforeChange"));
-            var loop = function (i3) {
-              var change = event.changes[i3];
-              change.origin = type2;
-              if (filter && !filterChange(doc, change, false)) {
-                source.length = 0;
-                return {};
-              }
-              antiChanges.push(historyChangeFromChange(doc, change));
-              var after = i3 ? computeSelAfterChange(doc, change) : lst(source);
-              makeChangeSingleDoc(
-                doc,
-                change,
-                after,
-                mergeOldSpans(doc, change)
-              );
-              if (!i3 && doc.cm) {
-                doc.cm.scrollIntoView({
-                  from: change.from,
-                  to: changeEnd(change),
-                });
-              }
-              var rebased = [];
-              linkedDocs(doc, function (doc2, sharedHist) {
-                if (!sharedHist && indexOf(rebased, doc2.history) == -1) {
-                  rebaseHist(doc2.history, change);
-                  rebased.push(doc2.history);
-                }
-                makeChangeSingleDoc(
-                  doc2,
-                  change,
-                  null,
-                  mergeOldSpans(doc2, change)
-                );
-              });
-            };
-            for (var i$12 = event.changes.length - 1; i$12 >= 0; --i$12) {
-              var returned = loop(i$12);
-              if (returned) return returned.v;
-            }
-          }
-          function shiftDoc(doc, distance) {
-            if (distance == 0) {
-              return;
-            }
-            doc.first += distance;
-            doc.sel = new Selection(
-              map2(doc.sel.ranges, function (range3) {
-                return new Range2(
-                  Pos(range3.anchor.line + distance, range3.anchor.ch),
-                  Pos(range3.head.line + distance, range3.head.ch)
-                );
-              }),
-              doc.sel.primIndex
-            );
-            if (doc.cm) {
-              regChange(doc.cm, doc.first, doc.first - distance, distance);
-              for (
-                var d = doc.cm.display, l2 = d.viewFrom;
-                l2 < d.viewTo;
-                l2++
-              ) {
-                regLineChange(doc.cm, l2, "gutter");
-              }
-            }
-          }
-          function makeChangeSingleDoc(doc, change, selAfter, spans) {
-            if (doc.cm && !doc.cm.curOp) {
-              return operation(doc.cm, makeChangeSingleDoc)(
-                doc,
-                change,
-                selAfter,
-                spans
-              );
-            }
-            if (change.to.line < doc.first) {
-              shiftDoc(
-                doc,
-                change.text.length - 1 - (change.to.line - change.from.line)
-              );
-              return;
-            }
-            if (change.from.line > doc.lastLine()) {
-              return;
-            }
-            if (change.from.line < doc.first) {
-              var shift =
-                change.text.length - 1 - (doc.first - change.from.line);
-              shiftDoc(doc, shift);
-              change = {
-                from: Pos(doc.first, 0),
-                to: Pos(change.to.line + shift, change.to.ch),
-                text: [lst(change.text)],
-                origin: change.origin,
-              };
-            }
-            var last = doc.lastLine();
-            if (change.to.line > last) {
-              change = {
-                from: change.from,
-                to: Pos(last, getLine2(doc, last).text.length),
-                text: [change.text[0]],
-                origin: change.origin,
-              };
-            }
-            change.removed = getBetween(doc, change.from, change.to);
-            if (!selAfter) {
-              selAfter = computeSelAfterChange(doc, change);
-            }
-            if (doc.cm) {
-              makeChangeSingleDocInEditor(doc.cm, change, spans);
-            } else {
-              updateDoc(doc, change, spans);
-            }
-            setSelectionNoUndo(doc, selAfter, sel_dontScroll);
-            if (doc.cantEdit && skipAtomic(doc, Pos(doc.firstLine(), 0))) {
-              doc.cantEdit = false;
-            }
-          }
-          function makeChangeSingleDocInEditor(cm, change, spans) {
-            var doc = cm.doc,
-              display = cm.display,
-              from = change.from,
-              to = change.to;
-            var recomputeMaxLength = false,
-              checkWidthStart = from.line;
-            if (!cm.options.lineWrapping) {
-              checkWidthStart = lineNo(visualLine(getLine2(doc, from.line)));
-              doc.iter(checkWidthStart, to.line + 1, function (line) {
-                if (line == display.maxLine) {
-                  recomputeMaxLength = true;
-                  return true;
-                }
-              });
-            }
-            if (doc.sel.contains(change.from, change.to) > -1) {
-              signalCursorActivity(cm);
-            }
-            updateDoc(doc, change, spans, estimateHeight(cm));
-            if (!cm.options.lineWrapping) {
-              doc.iter(
-                checkWidthStart,
-                from.line + change.text.length,
-                function (line) {
-                  var len = lineLength(line);
-                  if (len > display.maxLineLength) {
-                    display.maxLine = line;
-                    display.maxLineLength = len;
-                    display.maxLineChanged = true;
-                    recomputeMaxLength = false;
-                  }
-                }
-              );
-              if (recomputeMaxLength) {
-                cm.curOp.updateMaxLine = true;
-              }
-            }
-            retreatFrontier(doc, from.line);
-            startWorker(cm, 400);
-            var lendiff = change.text.length - (to.line - from.line) - 1;
-            if (change.full) {
-              regChange(cm);
-            } else if (
-              from.line == to.line &&
-              change.text.length == 1 &&
-              !isWholeLineUpdate(cm.doc, change)
-            ) {
-              regLineChange(cm, from.line, "text");
-            } else {
-              regChange(cm, from.line, to.line + 1, lendiff);
-            }
-            var changesHandler = hasHandler(cm, "changes"),
-              changeHandler = hasHandler(cm, "change");
-            if (changeHandler || changesHandler) {
-              var obj = {
-                from,
-                to,
-                text: change.text,
-                removed: change.removed,
-                origin: change.origin,
-              };
-              if (changeHandler) {
-                signalLater(cm, "change", cm, obj);
-              }
-              if (changesHandler) {
-                (cm.curOp.changeObjs || (cm.curOp.changeObjs = [])).push(obj);
-              }
-            }
-            cm.display.selForContextMenu = null;
-          }
-          function replaceRange(doc, code3, from, to, origin) {
-            var assign2;
-            if (!to) {
-              to = from;
-            }
-            if (cmp(to, from) < 0) {
-              (assign2 = [to, from]), (from = assign2[0]), (to = assign2[1]);
-            }
-            if (typeof code3 == "string") {
-              code3 = doc.splitLines(code3);
-            }
-            makeChange(doc, { from, to, text: code3, origin });
-          }
-          function rebaseHistSelSingle(pos, from, to, diff2) {
-            if (to < pos.line) {
-              pos.line += diff2;
-            } else if (from < pos.line) {
-              pos.line = from;
-              pos.ch = 0;
-            }
-          }
-          function rebaseHistArray(array, from, to, diff2) {
-            for (var i2 = 0; i2 < array.length; ++i2) {
-              var sub2 = array[i2],
-                ok2 = true;
-              if (sub2.ranges) {
-                if (!sub2.copied) {
-                  sub2 = array[i2] = sub2.deepCopy();
-                  sub2.copied = true;
-                }
-                for (var j = 0; j < sub2.ranges.length; j++) {
-                  rebaseHistSelSingle(sub2.ranges[j].anchor, from, to, diff2);
-                  rebaseHistSelSingle(sub2.ranges[j].head, from, to, diff2);
-                }
-                continue;
-              }
-              for (var j$1 = 0; j$1 < sub2.changes.length; ++j$1) {
-                var cur = sub2.changes[j$1];
-                if (to < cur.from.line) {
-                  cur.from = Pos(cur.from.line + diff2, cur.from.ch);
-                  cur.to = Pos(cur.to.line + diff2, cur.to.ch);
-                } else if (from <= cur.to.line) {
-                  ok2 = false;
-                  break;
-                }
-              }
-              if (!ok2) {
-                array.splice(0, i2 + 1);
-                i2 = 0;
-              }
-            }
-          }
-          function rebaseHist(hist, change) {
-            var from = change.from.line,
-              to = change.to.line,
-              diff2 = change.text.length - (to - from) - 1;
-            rebaseHistArray(hist.done, from, to, diff2);
-            rebaseHistArray(hist.undone, from, to, diff2);
-          }
-          function changeLine(doc, handle, changeType, op) {
-            var no = handle,
-              line = handle;
-            if (typeof handle == "number") {
-              line = getLine2(doc, clipLine(doc, handle));
-            } else {
-              no = lineNo(handle);
-            }
-            if (no == null) {
-              return null;
-            }
-            if (op(line, no) && doc.cm) {
-              regLineChange(doc.cm, no, changeType);
-            }
-            return line;
-          }
-          function LeafChunk(lines) {
-            this.lines = lines;
-            this.parent = null;
-            var height = 0;
-            for (var i2 = 0; i2 < lines.length; ++i2) {
-              lines[i2].parent = this;
-              height += lines[i2].height;
-            }
-            this.height = height;
-          }
-          LeafChunk.prototype = {
-            chunkSize: function () {
-              return this.lines.length;
-            },
-            removeInner: function (at, n2) {
-              for (var i2 = at, e = at + n2; i2 < e; ++i2) {
-                var line = this.lines[i2];
-                this.height -= line.height;
-                cleanUpLine(line);
-                signalLater(line, "delete");
-              }
-              this.lines.splice(at, n2);
-            },
-            collapse: function (lines) {
-              lines.push.apply(lines, this.lines);
-            },
-            insertInner: function (at, lines, height) {
-              this.height += height;
-              this.lines = this.lines
-                .slice(0, at)
-                .concat(lines)
-                .concat(this.lines.slice(at));
-              for (var i2 = 0; i2 < lines.length; ++i2) {
-                lines[i2].parent = this;
-              }
-            },
-            iterN: function (at, n2, op) {
-              for (var e = at + n2; at < e; ++at) {
-                if (op(this.lines[at])) {
-                  return true;
-                }
-              }
-            },
-          };
-          function BranchChunk(children) {
-            this.children = children;
-            var size = 0,
-              height = 0;
-            for (var i2 = 0; i2 < children.length; ++i2) {
-              var ch2 = children[i2];
-              size += ch2.chunkSize();
-              height += ch2.height;
-              ch2.parent = this;
-            }
-            this.size = size;
-            this.height = height;
-            this.parent = null;
-          }
-          BranchChunk.prototype = {
-            chunkSize: function () {
-              return this.size;
-            },
-            removeInner: function (at, n2) {
-              this.size -= n2;
-              for (var i2 = 0; i2 < this.children.length; ++i2) {
-                var child = this.children[i2],
-                  sz = child.chunkSize();
-                if (at < sz) {
-                  var rm = Math.min(n2, sz - at),
-                    oldHeight = child.height;
-                  child.removeInner(at, rm);
-                  this.height -= oldHeight - child.height;
-                  if (sz == rm) {
-                    this.children.splice(i2--, 1);
-                    child.parent = null;
-                  }
-                  if ((n2 -= rm) == 0) {
-                    break;
-                  }
-                  at = 0;
-                } else {
-                  at -= sz;
-                }
-              }
-              if (
-                this.size - n2 < 25 &&
-                (this.children.length > 1 ||
-                  !(this.children[0] instanceof LeafChunk))
-              ) {
-                var lines = [];
-                this.collapse(lines);
-                this.children = [new LeafChunk(lines)];
-                this.children[0].parent = this;
-              }
-            },
-            collapse: function (lines) {
-              for (var i2 = 0; i2 < this.children.length; ++i2) {
-                this.children[i2].collapse(lines);
-              }
-            },
-            insertInner: function (at, lines, height) {
-              this.size += lines.length;
-              this.height += height;
-              for (var i2 = 0; i2 < this.children.length; ++i2) {
-                var child = this.children[i2],
-                  sz = child.chunkSize();
-                if (at <= sz) {
-                  child.insertInner(at, lines, height);
-                  if (child.lines && child.lines.length > 50) {
-                    var remaining = (child.lines.length % 25) + 25;
-                    for (var pos = remaining; pos < child.lines.length; ) {
-                      var leaf = new LeafChunk(
-                        child.lines.slice(pos, (pos += 25))
-                      );
-                      child.height -= leaf.height;
-                      this.children.splice(++i2, 0, leaf);
-                      leaf.parent = this;
-                    }
-                    child.lines = child.lines.slice(0, remaining);
-                    this.maybeSpill();
-                  }
-                  break;
-                }
-                at -= sz;
-              }
-            },
-            maybeSpill: function () {
-              if (this.children.length <= 10) {
-                return;
-              }
-              var me2 = this;
-              do {
-                var spilled = me2.children.splice(me2.children.length - 5, 5);
-                var sibling = new BranchChunk(spilled);
-                if (!me2.parent) {
-                  var copy2 = new BranchChunk(me2.children);
-                  copy2.parent = me2;
-                  me2.children = [copy2, sibling];
-                  me2 = copy2;
-                } else {
-                  me2.size -= sibling.size;
-                  me2.height -= sibling.height;
-                  var myIndex = indexOf(me2.parent.children, me2);
-                  me2.parent.children.splice(myIndex + 1, 0, sibling);
-                }
-                sibling.parent = me2.parent;
-              } while (me2.children.length > 10);
-              me2.parent.maybeSpill();
-            },
-            iterN: function (at, n2, op) {
-              for (var i2 = 0; i2 < this.children.length; ++i2) {
-                var child = this.children[i2],
-                  sz = child.chunkSize();
-                if (at < sz) {
-                  var used = Math.min(n2, sz - at);
-                  if (child.iterN(at, used, op)) {
-                    return true;
-                  }
-                  if ((n2 -= used) == 0) {
-                    break;
-                  }
-                  at = 0;
-                } else {
-                  at -= sz;
-                }
-              }
-            },
-          };
-          var LineWidget = function (doc, node, options) {
-            if (options) {
-              for (var opt2 in options) {
-                if (options.hasOwnProperty(opt2)) {
-                  this[opt2] = options[opt2];
-                }
-              }
-            }
-            this.doc = doc;
-            this.node = node;
-          };
-          LineWidget.prototype.clear = function () {
-            var cm = this.doc.cm,
-              ws2 = this.line.widgets,
-              line = this.line,
-              no = lineNo(line);
-            if (no == null || !ws2) {
-              return;
-            }
-            for (var i2 = 0; i2 < ws2.length; ++i2) {
-              if (ws2[i2] == this) {
-                ws2.splice(i2--, 1);
-              }
-            }
-            if (!ws2.length) {
-              line.widgets = null;
-            }
-            var height = widgetHeight(this);
-            updateLineHeight(line, Math.max(0, line.height - height));
-            if (cm) {
-              runInOp(cm, function () {
-                adjustScrollWhenAboveVisible(cm, line, -height);
-                regLineChange(cm, no, "widget");
-              });
-              signalLater(cm, "lineWidgetCleared", cm, this, no);
-            }
-          };
-          LineWidget.prototype.changed = function () {
-            var this$1$1 = this;
-            var oldH = this.height,
-              cm = this.doc.cm,
-              line = this.line;
-            this.height = null;
-            var diff2 = widgetHeight(this) - oldH;
-            if (!diff2) {
-              return;
-            }
-            if (!lineIsHidden(this.doc, line)) {
-              updateLineHeight(line, line.height + diff2);
-            }
-            if (cm) {
-              runInOp(cm, function () {
-                cm.curOp.forceUpdate = true;
-                adjustScrollWhenAboveVisible(cm, line, diff2);
-                signalLater(
-                  cm,
-                  "lineWidgetChanged",
-                  cm,
-                  this$1$1,
-                  lineNo(line)
-                );
-              });
-            }
-          };
-          eventMixin(LineWidget);
-          function adjustScrollWhenAboveVisible(cm, line, diff2) {
-            if (
-              heightAtLine(line) <
-              ((cm.curOp && cm.curOp.scrollTop) || cm.doc.scrollTop)
-            ) {
-              addToScrollTop(cm, diff2);
-            }
-          }
-          function addLineWidget(doc, handle, node, options) {
-            var widget = new LineWidget(doc, node, options);
-            var cm = doc.cm;
-            if (cm && widget.noHScroll) {
-              cm.display.alignWidgets = true;
-            }
-            changeLine(doc, handle, "widget", function (line) {
-              var widgets = line.widgets || (line.widgets = []);
-              if (widget.insertAt == null) {
-                widgets.push(widget);
-              } else {
-                widgets.splice(
-                  Math.min(widgets.length, Math.max(0, widget.insertAt)),
-                  0,
-                  widget
-                );
-              }
-              widget.line = line;
-              if (cm && !lineIsHidden(doc, line)) {
-                var aboveVisible = heightAtLine(line) < doc.scrollTop;
-                updateLineHeight(line, line.height + widgetHeight(widget));
-                if (aboveVisible) {
-                  addToScrollTop(cm, widget.height);
-                }
-                cm.curOp.forceUpdate = true;
-              }
-              return true;
-            });
-            if (cm) {
-              signalLater(
-                cm,
-                "lineWidgetAdded",
-                cm,
-                widget,
-                typeof handle == "number" ? handle : lineNo(handle)
-              );
-            }
-            return widget;
-          }
-          var nextMarkerId = 0;
-          var TextMarker = function (doc, type2) {
-            this.lines = [];
-            this.type = type2;
-            this.doc = doc;
-            this.id = ++nextMarkerId;
-          };
-          TextMarker.prototype.clear = function () {
-            if (this.explicitlyCleared) {
-              return;
-            }
-            var cm = this.doc.cm,
-              withOp = cm && !cm.curOp;
-            if (withOp) {
-              startOperation(cm);
-            }
-            if (hasHandler(this, "clear")) {
-              var found = this.find();
-              if (found) {
-                signalLater(this, "clear", found.from, found.to);
-              }
-            }
-            var min = null,
-              max = null;
-            for (var i2 = 0; i2 < this.lines.length; ++i2) {
-              var line = this.lines[i2];
-              var span = getMarkedSpanFor(line.markedSpans, this);
-              if (cm && !this.collapsed) {
-                regLineChange(cm, lineNo(line), "text");
-              } else if (cm) {
-                if (span.to != null) {
-                  max = lineNo(line);
-                }
-                if (span.from != null) {
-                  min = lineNo(line);
-                }
-              }
-              line.markedSpans = removeMarkedSpan(line.markedSpans, span);
-              if (
-                span.from == null &&
-                this.collapsed &&
-                !lineIsHidden(this.doc, line) &&
-                cm
-              ) {
-                updateLineHeight(line, textHeight(cm.display));
-              }
-            }
-            if (cm && this.collapsed && !cm.options.lineWrapping) {
-              for (var i$12 = 0; i$12 < this.lines.length; ++i$12) {
-                var visual = visualLine(this.lines[i$12]),
-                  len = lineLength(visual);
-                if (len > cm.display.maxLineLength) {
-                  cm.display.maxLine = visual;
-                  cm.display.maxLineLength = len;
-                  cm.display.maxLineChanged = true;
-                }
-              }
-            }
-            if (min != null && cm && this.collapsed) {
-              regChange(cm, min, max + 1);
-            }
-            this.lines.length = 0;
-            this.explicitlyCleared = true;
-            if (this.atomic && this.doc.cantEdit) {
-              this.doc.cantEdit = false;
-              if (cm) {
-                reCheckSelection(cm.doc);
-              }
-            }
-            if (cm) {
-              signalLater(cm, "markerCleared", cm, this, min, max);
-            }
-            if (withOp) {
-              endOperation(cm);
-            }
-            if (this.parent) {
-              this.parent.clear();
-            }
-          };
-          TextMarker.prototype.find = function (side, lineObj) {
-            if (side == null && this.type == "bookmark") {
-              side = 1;
-            }
-            var from, to;
-            for (var i2 = 0; i2 < this.lines.length; ++i2) {
-              var line = this.lines[i2];
-              var span = getMarkedSpanFor(line.markedSpans, this);
-              if (span.from != null) {
-                from = Pos(lineObj ? line : lineNo(line), span.from);
-                if (side == -1) {
-                  return from;
-                }
-              }
-              if (span.to != null) {
-                to = Pos(lineObj ? line : lineNo(line), span.to);
-                if (side == 1) {
-                  return to;
-                }
-              }
-            }
-            return from && { from, to };
-          };
-          TextMarker.prototype.changed = function () {
-            var this$1$1 = this;
-            var pos = this.find(-1, true),
-              widget = this,
-              cm = this.doc.cm;
-            if (!pos || !cm) {
-              return;
-            }
-            runInOp(cm, function () {
-              var line = pos.line,
-                lineN = lineNo(pos.line);
-              var view = findViewForLine(cm, lineN);
-              if (view) {
-                clearLineMeasurementCacheFor(view);
-                cm.curOp.selectionChanged = cm.curOp.forceUpdate = true;
-              }
-              cm.curOp.updateMaxLine = true;
-              if (!lineIsHidden(widget.doc, line) && widget.height != null) {
-                var oldHeight = widget.height;
-                widget.height = null;
-                var dHeight = widgetHeight(widget) - oldHeight;
-                if (dHeight) {
-                  updateLineHeight(line, line.height + dHeight);
-                }
-              }
-              signalLater(cm, "markerChanged", cm, this$1$1);
-            });
-          };
-          TextMarker.prototype.attachLine = function (line) {
-            if (!this.lines.length && this.doc.cm) {
-              var op = this.doc.cm.curOp;
-              if (
-                !op.maybeHiddenMarkers ||
-                indexOf(op.maybeHiddenMarkers, this) == -1
-              ) {
-                (
-                  op.maybeUnhiddenMarkers || (op.maybeUnhiddenMarkers = [])
-                ).push(this);
-              }
-            }
-            this.lines.push(line);
-          };
-          TextMarker.prototype.detachLine = function (line) {
-            this.lines.splice(indexOf(this.lines, line), 1);
-            if (!this.lines.length && this.doc.cm) {
-              var op = this.doc.cm.curOp;
-              (op.maybeHiddenMarkers || (op.maybeHiddenMarkers = [])).push(
-                this
-              );
-            }
-          };
-          eventMixin(TextMarker);
-          function markText(doc, from, to, options, type2) {
-            if (options && options.shared) {
-              return markTextShared(doc, from, to, options, type2);
-            }
-            if (doc.cm && !doc.cm.curOp) {
-              return operation(doc.cm, markText)(doc, from, to, options, type2);
-            }
-            var marker2 = new TextMarker(doc, type2),
-              diff2 = cmp(from, to);
-            if (options) {
-              copyObj(options, marker2, false);
-            }
-            if (diff2 > 0 || (diff2 == 0 && marker2.clearWhenEmpty !== false)) {
-              return marker2;
-            }
-            if (marker2.replacedWith) {
-              marker2.collapsed = true;
-              marker2.widgetNode = eltP(
-                "span",
-                [marker2.replacedWith],
-                "CodeMirror-widget"
-              );
-              if (!options.handleMouseEvents) {
-                marker2.widgetNode.setAttribute("cm-ignore-events", "true");
-              }
-              if (options.insertLeft) {
-                marker2.widgetNode.insertLeft = true;
-              }
-            }
-            if (marker2.collapsed) {
-              if (
-                conflictingCollapsedRange(doc, from.line, from, to, marker2) ||
-                (from.line != to.line &&
-                  conflictingCollapsedRange(doc, to.line, from, to, marker2))
-              ) {
-                throw new Error(
-                  "Inserting collapsed marker partially overlapping an existing one"
-                );
-              }
-              seeCollapsedSpans();
-            }
-            if (marker2.addToHistory) {
-              addChangeToHistory(
-                doc,
-                { from, to, origin: "markText" },
-                doc.sel,
-                NaN
-              );
-            }
-            var curLine = from.line,
-              cm = doc.cm,
-              updateMaxLine;
-            doc.iter(curLine, to.line + 1, function (line) {
-              if (
-                cm &&
-                marker2.collapsed &&
-                !cm.options.lineWrapping &&
-                visualLine(line) == cm.display.maxLine
-              ) {
-                updateMaxLine = true;
-              }
-              if (marker2.collapsed && curLine != from.line) {
-                updateLineHeight(line, 0);
-              }
-              addMarkedSpan(
-                line,
-                new MarkedSpan(
-                  marker2,
-                  curLine == from.line ? from.ch : null,
-                  curLine == to.line ? to.ch : null
-                ),
-                doc.cm && doc.cm.curOp
-              );
-              ++curLine;
-            });
-            if (marker2.collapsed) {
-              doc.iter(from.line, to.line + 1, function (line) {
-                if (lineIsHidden(doc, line)) {
-                  updateLineHeight(line, 0);
-                }
-              });
-            }
-            if (marker2.clearOnEnter) {
-              on(marker2, "beforeCursorEnter", function () {
-                return marker2.clear();
-              });
-            }
-            if (marker2.readOnly) {
-              seeReadOnlySpans();
-              if (doc.history.done.length || doc.history.undone.length) {
-                doc.clearHistory();
-              }
-            }
-            if (marker2.collapsed) {
-              marker2.id = ++nextMarkerId;
-              marker2.atomic = true;
-            }
-            if (cm) {
-              if (updateMaxLine) {
-                cm.curOp.updateMaxLine = true;
-              }
-              if (marker2.collapsed) {
-                regChange(cm, from.line, to.line + 1);
-              } else if (
-                marker2.className ||
-                marker2.startStyle ||
-                marker2.endStyle ||
-                marker2.css ||
-                marker2.attributes ||
-                marker2.title
-              ) {
-                for (var i2 = from.line; i2 <= to.line; i2++) {
-                  regLineChange(cm, i2, "text");
-                }
-              }
-              if (marker2.atomic) {
-                reCheckSelection(cm.doc);
-              }
-              signalLater(cm, "markerAdded", cm, marker2);
-            }
-            return marker2;
-          }
-          var SharedTextMarker = function (markers, primary) {
-            this.markers = markers;
-            this.primary = primary;
-            for (var i2 = 0; i2 < markers.length; ++i2) {
-              markers[i2].parent = this;
-            }
-          };
-          SharedTextMarker.prototype.clear = function () {
-            if (this.explicitlyCleared) {
-              return;
-            }
-            this.explicitlyCleared = true;
-            for (var i2 = 0; i2 < this.markers.length; ++i2) {
-              this.markers[i2].clear();
-            }
-            signalLater(this, "clear");
-          };
-          SharedTextMarker.prototype.find = function (side, lineObj) {
-            return this.primary.find(side, lineObj);
-          };
-          eventMixin(SharedTextMarker);
-          function markTextShared(doc, from, to, options, type2) {
-            options = copyObj(options);
-            options.shared = false;
-            var markers = [markText(doc, from, to, options, type2)],
-              primary = markers[0];
-            var widget = options.widgetNode;
-            linkedDocs(doc, function (doc2) {
-              if (widget) {
-                options.widgetNode = widget.cloneNode(true);
-              }
-              markers.push(
-                markText(
-                  doc2,
-                  clipPos(doc2, from),
-                  clipPos(doc2, to),
-                  options,
-                  type2
-                )
-              );
-              for (var i2 = 0; i2 < doc2.linked.length; ++i2) {
-                if (doc2.linked[i2].isParent) {
-                  return;
-                }
-              }
-              primary = lst(markers);
-            });
-            return new SharedTextMarker(markers, primary);
-          }
-          function findSharedMarkers(doc) {
-            return doc.findMarks(
-              Pos(doc.first, 0),
-              doc.clipPos(Pos(doc.lastLine())),
-              function (m) {
-                return m.parent;
-              }
-            );
-          }
-          function copySharedMarkers(doc, markers) {
-            for (var i2 = 0; i2 < markers.length; i2++) {
-              var marker2 = markers[i2],
-                pos = marker2.find();
-              var mFrom = doc.clipPos(pos.from),
-                mTo = doc.clipPos(pos.to);
-              if (cmp(mFrom, mTo)) {
-                var subMark = markText(
-                  doc,
-                  mFrom,
-                  mTo,
-                  marker2.primary,
-                  marker2.primary.type
-                );
-                marker2.markers.push(subMark);
-                subMark.parent = marker2;
-              }
-            }
-          }
-          function detachSharedMarkers(markers) {
-            var loop = function (i3) {
-              var marker2 = markers[i3],
-                linked = [marker2.primary.doc];
-              linkedDocs(marker2.primary.doc, function (d) {
-                return linked.push(d);
-              });
-              for (var j = 0; j < marker2.markers.length; j++) {
-                var subMarker = marker2.markers[j];
-                if (indexOf(linked, subMarker.doc) == -1) {
-                  subMarker.parent = null;
-                  marker2.markers.splice(j--, 1);
-                }
-              }
-            };
-            for (var i2 = 0; i2 < markers.length; i2++) loop(i2);
-          }
-          var nextDocId = 0;
-          var Doc = function (text3, mode2, firstLine, lineSep, direction) {
-            if (!(this instanceof Doc)) {
-              return new Doc(text3, mode2, firstLine, lineSep, direction);
-            }
-            if (firstLine == null) {
-              firstLine = 0;
-            }
-            BranchChunk.call(this, [new LeafChunk([new Line("", null)])]);
-            this.first = firstLine;
-            this.scrollTop = this.scrollLeft = 0;
-            this.cantEdit = false;
-            this.cleanGeneration = 1;
-            this.modeFrontier = this.highlightFrontier = firstLine;
-            var start2 = Pos(firstLine, 0);
-            this.sel = simpleSelection(start2);
-            this.history = new History(null);
-            this.id = ++nextDocId;
-            this.modeOption = mode2;
-            this.lineSep = lineSep;
-            this.direction = direction == "rtl" ? "rtl" : "ltr";
-            this.extend = false;
-            if (typeof text3 == "string") {
-              text3 = this.splitLines(text3);
-            }
-            updateDoc(this, { from: start2, to: start2, text: text3 });
-            setSelection(this, simpleSelection(start2), sel_dontScroll);
-          };
-          Doc.prototype = createObj(BranchChunk.prototype, {
-            constructor: Doc,
-            iter: function (from, to, op) {
-              if (op) {
-                this.iterN(from - this.first, to - from, op);
-              } else {
-                this.iterN(this.first, this.first + this.size, from);
-              }
-            },
-            insert: function (at, lines) {
-              var height = 0;
-              for (var i2 = 0; i2 < lines.length; ++i2) {
-                height += lines[i2].height;
-              }
-              this.insertInner(at - this.first, lines, height);
-            },
-            remove: function (at, n2) {
-              this.removeInner(at - this.first, n2);
-            },
-            getValue: function (lineSep) {
-              var lines = getLines2(this, this.first, this.first + this.size);
-              if (lineSep === false) {
-                return lines;
-              }
-              return lines.join(lineSep || this.lineSeparator());
-            },
-            setValue: docMethodOp(function (code3) {
-              var top2 = Pos(this.first, 0),
-                last = this.first + this.size - 1;
-              makeChange(
-                this,
-                {
-                  from: top2,
-                  to: Pos(last, getLine2(this, last).text.length),
-                  text: this.splitLines(code3),
-                  origin: "setValue",
-                  full: true,
-                },
-                true
-              );
-              if (this.cm) {
-                scrollToCoords(this.cm, 0, 0);
-              }
-              setSelection(this, simpleSelection(top2), sel_dontScroll);
-            }),
-            replaceRange: function (code3, from, to, origin) {
-              from = clipPos(this, from);
-              to = to ? clipPos(this, to) : from;
-              replaceRange(this, code3, from, to, origin);
-            },
-            getRange: function (from, to, lineSep) {
-              var lines = getBetween(
-                this,
-                clipPos(this, from),
-                clipPos(this, to)
-              );
-              if (lineSep === false) {
-                return lines;
-              }
-              if (lineSep === "") {
-                return lines.join("");
-              }
-              return lines.join(lineSep || this.lineSeparator());
-            },
-            getLine: function (line) {
-              var l2 = this.getLineHandle(line);
-              return l2 && l2.text;
-            },
-            getLineHandle: function (line) {
-              if (isLine(this, line)) {
-                return getLine2(this, line);
-              }
-            },
-            getLineNumber: function (line) {
-              return lineNo(line);
-            },
-            getLineHandleVisualStart: function (line) {
-              if (typeof line == "number") {
-                line = getLine2(this, line);
-              }
-              return visualLine(line);
-            },
-            lineCount: function () {
-              return this.size;
-            },
-            firstLine: function () {
-              return this.first;
-            },
-            lastLine: function () {
-              return this.first + this.size - 1;
-            },
-            clipPos: function (pos) {
-              return clipPos(this, pos);
-            },
-            getCursor: function (start2) {
-              var range3 = this.sel.primary(),
-                pos;
-              if (start2 == null || start2 == "head") {
-                pos = range3.head;
-              } else if (start2 == "anchor") {
-                pos = range3.anchor;
-              } else if (
-                start2 == "end" ||
-                start2 == "to" ||
-                start2 === false
-              ) {
-                pos = range3.to();
-              } else {
-                pos = range3.from();
-              }
-              return pos;
-            },
-            listSelections: function () {
-              return this.sel.ranges;
-            },
-            somethingSelected: function () {
-              return this.sel.somethingSelected();
-            },
-            setCursor: docMethodOp(function (line, ch2, options) {
-              setSimpleSelection(
-                this,
-                clipPos(
-                  this,
-                  typeof line == "number" ? Pos(line, ch2 || 0) : line
-                ),
-                null,
-                options
-              );
-            }),
-            setSelection: docMethodOp(function (anchor, head, options) {
-              setSimpleSelection(
-                this,
-                clipPos(this, anchor),
-                clipPos(this, head || anchor),
-                options
-              );
-            }),
-            extendSelection: docMethodOp(function (head, other, options) {
-              extendSelection(
-                this,
-                clipPos(this, head),
-                other && clipPos(this, other),
-                options
-              );
-            }),
-            extendSelections: docMethodOp(function (heads, options) {
-              extendSelections(this, clipPosArray(this, heads), options);
-            }),
-            extendSelectionsBy: docMethodOp(function (f, options) {
-              var heads = map2(this.sel.ranges, f);
-              extendSelections(this, clipPosArray(this, heads), options);
-            }),
-            setSelections: docMethodOp(function (ranges, primary, options) {
-              if (!ranges.length) {
-                return;
-              }
-              var out = [];
-              for (var i2 = 0; i2 < ranges.length; i2++) {
-                out[i2] = new Range2(
-                  clipPos(this, ranges[i2].anchor),
-                  clipPos(this, ranges[i2].head || ranges[i2].anchor)
-                );
-              }
-              if (primary == null) {
-                primary = Math.min(ranges.length - 1, this.sel.primIndex);
-              }
-              setSelection(
-                this,
-                normalizeSelection(this.cm, out, primary),
-                options
-              );
-            }),
-            addSelection: docMethodOp(function (anchor, head, options) {
-              var ranges = this.sel.ranges.slice(0);
-              ranges.push(
-                new Range2(clipPos(this, anchor), clipPos(this, head || anchor))
-              );
-              setSelection(
-                this,
-                normalizeSelection(this.cm, ranges, ranges.length - 1),
-                options
-              );
-            }),
-            getSelection: function (lineSep) {
-              var ranges = this.sel.ranges,
-                lines;
-              for (var i2 = 0; i2 < ranges.length; i2++) {
-                var sel = getBetween(this, ranges[i2].from(), ranges[i2].to());
-                lines = lines ? lines.concat(sel) : sel;
-              }
-              if (lineSep === false) {
-                return lines;
-              } else {
-                return lines.join(lineSep || this.lineSeparator());
-              }
-            },
-            getSelections: function (lineSep) {
-              var parts = [],
-                ranges = this.sel.ranges;
-              for (var i2 = 0; i2 < ranges.length; i2++) {
-                var sel = getBetween(this, ranges[i2].from(), ranges[i2].to());
-                if (lineSep !== false) {
-                  sel = sel.join(lineSep || this.lineSeparator());
-                }
-                parts[i2] = sel;
-              }
-              return parts;
-            },
-            replaceSelection: function (code3, collapse, origin) {
-              var dup = [];
-              for (var i2 = 0; i2 < this.sel.ranges.length; i2++) {
-                dup[i2] = code3;
-              }
-              this.replaceSelections(dup, collapse, origin || "+input");
-            },
-            replaceSelections: docMethodOp(function (code3, collapse, origin) {
-              var changes = [],
-                sel = this.sel;
-              for (var i2 = 0; i2 < sel.ranges.length; i2++) {
-                var range3 = sel.ranges[i2];
-                changes[i2] = {
-                  from: range3.from(),
-                  to: range3.to(),
-                  text: this.splitLines(code3[i2]),
-                  origin,
-                };
-              }
-              var newSel =
-                collapse &&
-                collapse != "end" &&
-                computeReplacedSel(this, changes, collapse);
-              for (var i$12 = changes.length - 1; i$12 >= 0; i$12--) {
-                makeChange(this, changes[i$12]);
-              }
-              if (newSel) {
-                setSelectionReplaceHistory(this, newSel);
-              } else if (this.cm) {
-                ensureCursorVisible(this.cm);
-              }
-            }),
-            undo: docMethodOp(function () {
-              makeChangeFromHistory(this, "undo");
-            }),
-            redo: docMethodOp(function () {
-              makeChangeFromHistory(this, "redo");
-            }),
-            undoSelection: docMethodOp(function () {
-              makeChangeFromHistory(this, "undo", true);
-            }),
-            redoSelection: docMethodOp(function () {
-              makeChangeFromHistory(this, "redo", true);
-            }),
-            setExtending: function (val) {
-              this.extend = val;
-            },
-            getExtending: function () {
-              return this.extend;
-            },
-            historySize: function () {
-              var hist = this.history,
-                done = 0,
-                undone = 0;
-              for (var i2 = 0; i2 < hist.done.length; i2++) {
-                if (!hist.done[i2].ranges) {
-                  ++done;
-                }
-              }
-              for (var i$12 = 0; i$12 < hist.undone.length; i$12++) {
-                if (!hist.undone[i$12].ranges) {
-                  ++undone;
-                }
-              }
-              return { undo: done, redo: undone };
-            },
-            clearHistory: function () {
-              var this$1$1 = this;
-              this.history = new History(this.history);
-              linkedDocs(
-                this,
-                function (doc) {
-                  return (doc.history = this$1$1.history);
-                },
-                true
-              );
-            },
-            markClean: function () {
-              this.cleanGeneration = this.changeGeneration(true);
-            },
-            changeGeneration: function (forceSplit) {
-              if (forceSplit) {
-                this.history.lastOp =
-                  this.history.lastSelOp =
-                  this.history.lastOrigin =
-                    null;
-              }
-              return this.history.generation;
-            },
-            isClean: function (gen) {
-              return this.history.generation == (gen || this.cleanGeneration);
-            },
-            getHistory: function () {
-              return {
-                done: copyHistoryArray(this.history.done),
-                undone: copyHistoryArray(this.history.undone),
-              };
-            },
-            setHistory: function (histData) {
-              var hist = (this.history = new History(this.history));
-              hist.done = copyHistoryArray(histData.done.slice(0), null, true);
-              hist.undone = copyHistoryArray(
-                histData.undone.slice(0),
-                null,
-                true
-              );
-            },
-            setGutterMarker: docMethodOp(function (line, gutterID, value) {
-              return changeLine(this, line, "gutter", function (line2) {
-                var markers = line2.gutterMarkers || (line2.gutterMarkers = {});
-                markers[gutterID] = value;
-                if (!value && isEmpty2(markers)) {
-                  line2.gutterMarkers = null;
-                }
-                return true;
-              });
-            }),
-            clearGutter: docMethodOp(function (gutterID) {
-              var this$1$1 = this;
-              this.iter(function (line) {
-                if (line.gutterMarkers && line.gutterMarkers[gutterID]) {
-                  changeLine(this$1$1, line, "gutter", function () {
-                    line.gutterMarkers[gutterID] = null;
-                    if (isEmpty2(line.gutterMarkers)) {
-                      line.gutterMarkers = null;
-                    }
-                    return true;
-                  });
-                }
-              });
-            }),
-            lineInfo: function (line) {
-              var n2;
-              if (typeof line == "number") {
-                if (!isLine(this, line)) {
-                  return null;
-                }
-                n2 = line;
-                line = getLine2(this, line);
-                if (!line) {
-                  return null;
-                }
-              } else {
-                n2 = lineNo(line);
-                if (n2 == null) {
-                  return null;
-                }
-              }
-              return {
-                line: n2,
-                handle: line,
-                text: line.text,
-                gutterMarkers: line.gutterMarkers,
-                textClass: line.textClass,
-                bgClass: line.bgClass,
-                wrapClass: line.wrapClass,
-                widgets: line.widgets,
-              };
-            },
-            addLineClass: docMethodOp(function (handle, where, cls) {
-              return changeLine(
-                this,
-                handle,
-                where == "gutter" ? "gutter" : "class",
-                function (line) {
-                  var prop3 =
-                    where == "text"
-                      ? "textClass"
-                      : where == "background"
-                      ? "bgClass"
-                      : where == "gutter"
-                      ? "gutterClass"
-                      : "wrapClass";
-                  if (!line[prop3]) {
-                    line[prop3] = cls;
-                  } else if (classTest(cls).test(line[prop3])) {
-                    return false;
-                  } else {
-                    line[prop3] += " " + cls;
-                  }
-                  return true;
-                }
-              );
-            }),
-            removeLineClass: docMethodOp(function (handle, where, cls) {
-              return changeLine(
-                this,
-                handle,
-                where == "gutter" ? "gutter" : "class",
-                function (line) {
-                  var prop3 =
-                    where == "text"
-                      ? "textClass"
-                      : where == "background"
-                      ? "bgClass"
-                      : where == "gutter"
-                      ? "gutterClass"
-                      : "wrapClass";
-                  var cur = line[prop3];
-                  if (!cur) {
-                    return false;
-                  } else if (cls == null) {
-                    line[prop3] = null;
-                  } else {
-                    var found = cur.match(classTest(cls));
-                    if (!found) {
-                      return false;
-                    }
-                    var end2 = found.index + found[0].length;
-                    line[prop3] =
-                      cur.slice(0, found.index) +
-                        (!found.index || end2 == cur.length ? "" : " ") +
-                        cur.slice(end2) || null;
-                  }
-                  return true;
-                }
-              );
-            }),
-            addLineWidget: docMethodOp(function (handle, node, options) {
-              return addLineWidget(this, handle, node, options);
-            }),
-            removeLineWidget: function (widget) {
-              widget.clear();
-            },
-            markText: function (from, to, options) {
-              return markText(
-                this,
-                clipPos(this, from),
-                clipPos(this, to),
-                options,
-                (options && options.type) || "range"
-              );
-            },
-            setBookmark: function (pos, options) {
-              var realOpts = {
-                replacedWith:
-                  options &&
-                  (options.nodeType == null ? options.widget : options),
-                insertLeft: options && options.insertLeft,
-                clearWhenEmpty: false,
-                shared: options && options.shared,
-                handleMouseEvents: options && options.handleMouseEvents,
-              };
-              pos = clipPos(this, pos);
-              return markText(this, pos, pos, realOpts, "bookmark");
-            },
-            findMarksAt: function (pos) {
-              pos = clipPos(this, pos);
-              var markers = [],
-                spans = getLine2(this, pos.line).markedSpans;
-              if (spans) {
-                for (var i2 = 0; i2 < spans.length; ++i2) {
-                  var span = spans[i2];
-                  if (
-                    (span.from == null || span.from <= pos.ch) &&
-                    (span.to == null || span.to >= pos.ch)
-                  ) {
-                    markers.push(span.marker.parent || span.marker);
-                  }
-                }
-              }
-              return markers;
-            },
-            findMarks: function (from, to, filter) {
-              from = clipPos(this, from);
-              to = clipPos(this, to);
-              var found = [],
-                lineNo2 = from.line;
-              this.iter(from.line, to.line + 1, function (line) {
-                var spans = line.markedSpans;
-                if (spans) {
-                  for (var i2 = 0; i2 < spans.length; i2++) {
-                    var span = spans[i2];
-                    if (
-                      !(
-                        (span.to != null &&
-                          lineNo2 == from.line &&
-                          from.ch >= span.to) ||
-                        (span.from == null && lineNo2 != from.line) ||
-                        (span.from != null &&
-                          lineNo2 == to.line &&
-                          span.from >= to.ch)
-                      ) &&
-                      (!filter || filter(span.marker))
-                    ) {
-                      found.push(span.marker.parent || span.marker);
-                    }
-                  }
-                }
-                ++lineNo2;
-              });
-              return found;
-            },
-            getAllMarks: function () {
-              var markers = [];
-              this.iter(function (line) {
-                var sps = line.markedSpans;
-                if (sps) {
-                  for (var i2 = 0; i2 < sps.length; ++i2) {
-                    if (sps[i2].from != null) {
-                      markers.push(sps[i2].marker);
-                    }
-                  }
-                }
-              });
-              return markers;
-            },
-            posFromIndex: function (off2) {
-              var ch2,
-                lineNo2 = this.first,
-                sepSize = this.lineSeparator().length;
-              this.iter(function (line) {
-                var sz = line.text.length + sepSize;
-                if (sz > off2) {
-                  ch2 = off2;
-                  return true;
-                }
-                off2 -= sz;
-                ++lineNo2;
-              });
-              return clipPos(this, Pos(lineNo2, ch2));
-            },
-            indexFromPos: function (coords) {
-              coords = clipPos(this, coords);
-              var index = coords.ch;
-              if (coords.line < this.first || coords.ch < 0) {
-                return 0;
-              }
-              var sepSize = this.lineSeparator().length;
-              this.iter(this.first, coords.line, function (line) {
-                index += line.text.length + sepSize;
-              });
-              return index;
-            },
-            copy: function (copyHistory) {
-              var doc = new Doc(
-                getLines2(this, this.first, this.first + this.size),
-                this.modeOption,
-                this.first,
-                this.lineSep,
-                this.direction
-              );
-              doc.scrollTop = this.scrollTop;
-              doc.scrollLeft = this.scrollLeft;
-              doc.sel = this.sel;
-              doc.extend = false;
-              if (copyHistory) {
-                doc.history.undoDepth = this.history.undoDepth;
-                doc.setHistory(this.getHistory());
-              }
-              return doc;
-            },
-            linkedDoc: function (options) {
-              if (!options) {
-                options = {};
-              }
-              var from = this.first,
-                to = this.first + this.size;
-              if (options.from != null && options.from > from) {
-                from = options.from;
-              }
-              if (options.to != null && options.to < to) {
-                to = options.to;
-              }
-              var copy2 = new Doc(
-                getLines2(this, from, to),
-                options.mode || this.modeOption,
-                from,
-                this.lineSep,
-                this.direction
-              );
-              if (options.sharedHist) {
-                copy2.history = this.history;
-              }
-              (this.linked || (this.linked = [])).push({
-                doc: copy2,
-                sharedHist: options.sharedHist,
-              });
-              copy2.linked = [
-                { doc: this, isParent: true, sharedHist: options.sharedHist },
-              ];
-              copySharedMarkers(copy2, findSharedMarkers(this));
-              return copy2;
-            },
-            unlinkDoc: function (other) {
-              if (other instanceof CodeMirror) {
-                other = other.doc;
-              }
-              if (this.linked) {
-                for (var i2 = 0; i2 < this.linked.length; ++i2) {
-                  var link3 = this.linked[i2];
-                  if (link3.doc != other) {
-                    continue;
-                  }
-                  this.linked.splice(i2, 1);
-                  other.unlinkDoc(this);
-                  detachSharedMarkers(findSharedMarkers(this));
-                  break;
-                }
-              }
-              if (other.history == this.history) {
-                var splitIds = [other.id];
-                linkedDocs(
-                  other,
-                  function (doc) {
-                    return splitIds.push(doc.id);
-                  },
-                  true
-                );
-                other.history = new History(null);
-                other.history.done = copyHistoryArray(
-                  this.history.done,
-                  splitIds
-                );
-                other.history.undone = copyHistoryArray(
-                  this.history.undone,
-                  splitIds
-                );
-              }
-            },
-            iterLinkedDocs: function (f) {
-              linkedDocs(this, f);
-            },
-            getMode: function () {
-              return this.mode;
-            },
-            getEditor: function () {
-              return this.cm;
-            },
-            splitLines: function (str) {
-              if (this.lineSep) {
-                return str.split(this.lineSep);
-              }
-              return splitLinesAuto(str);
-            },
-            lineSeparator: function () {
-              return this.lineSep || "\n";
-            },
-            setDirection: docMethodOp(function (dir) {
-              if (dir != "rtl") {
-                dir = "ltr";
-              }
-              if (dir == this.direction) {
-                return;
-              }
-              this.direction = dir;
-              this.iter(function (line) {
-                return (line.order = null);
-              });
-              if (this.cm) {
-                directionChanged(this.cm);
-              }
-            }),
-          });
-          Doc.prototype.eachLine = Doc.prototype.iter;
-          var lastDrop = 0;
-          function onDrop(e) {
-            var cm = this;
-            clearDragCursor(cm);
-            if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) {
-              return;
-            }
-            e_preventDefault(e);
-            if (ie2) {
-              lastDrop = +new Date();
-            }
-            var pos = posFromMouse(cm, e, true),
-              files = e.dataTransfer.files;
-            if (!pos || cm.isReadOnly()) {
-              return;
-            }
-            if (files && files.length && window.FileReader && window.File) {
-              var n2 = files.length,
-                text3 = Array(n2),
-                read = 0;
-              var markAsReadAndPasteIfAllFilesAreRead = function () {
-                if (++read == n2) {
-                  operation(cm, function () {
-                    pos = clipPos(cm.doc, pos);
-                    var change = {
-                      from: pos,
-                      to: pos,
-                      text: cm.doc.splitLines(
-                        text3
-                          .filter(function (t2) {
-                            return t2 != null;
-                          })
-                          .join(cm.doc.lineSeparator())
-                      ),
-                      origin: "paste",
-                    };
-                    makeChange(cm.doc, change);
-                    setSelectionReplaceHistory(
-                      cm.doc,
-                      simpleSelection(
-                        clipPos(cm.doc, pos),
-                        clipPos(cm.doc, changeEnd(change))
-                      )
-                    );
-                  })();
-                }
-              };
-              var readTextFromFile = function (file, i3) {
-                if (
-                  cm.options.allowDropFileTypes &&
-                  indexOf(cm.options.allowDropFileTypes, file.type) == -1
-                ) {
-                  markAsReadAndPasteIfAllFilesAreRead();
-                  return;
-                }
-                var reader = new FileReader();
-                reader.onerror = function () {
-                  return markAsReadAndPasteIfAllFilesAreRead();
-                };
-                reader.onload = function () {
-                  var content = reader.result;
-                  if (/[\x00-\x08\x0e-\x1f]{2}/.test(content)) {
-                    markAsReadAndPasteIfAllFilesAreRead();
-                    return;
-                  }
-                  text3[i3] = content;
-                  markAsReadAndPasteIfAllFilesAreRead();
-                };
-                reader.readAsText(file);
-              };
-              for (var i2 = 0; i2 < files.length; i2++) {
-                readTextFromFile(files[i2], i2);
-              }
-            } else {
-              if (cm.state.draggingText && cm.doc.sel.contains(pos) > -1) {
-                cm.state.draggingText(e);
-                setTimeout(function () {
-                  return cm.display.input.focus();
-                }, 20);
-                return;
-              }
-              try {
-                var text$12 = e.dataTransfer.getData("Text");
-                if (text$12) {
-                  var selected;
-                  if (cm.state.draggingText && !cm.state.draggingText.copy) {
-                    selected = cm.listSelections();
-                  }
-                  setSelectionNoUndo(cm.doc, simpleSelection(pos, pos));
-                  if (selected) {
-                    for (var i$12 = 0; i$12 < selected.length; ++i$12) {
-                      replaceRange(
-                        cm.doc,
-                        "",
-                        selected[i$12].anchor,
-                        selected[i$12].head,
-                        "drag"
-                      );
-                    }
-                  }
-                  cm.replaceSelection(text$12, "around", "paste");
-                  cm.display.input.focus();
-                }
-              } catch (e$1) {}
-            }
-          }
-          function onDragStart(cm, e) {
-            if (
-              ie2 &&
-              (!cm.state.draggingText || +new Date() - lastDrop < 100)
-            ) {
-              e_stop(e);
-              return;
-            }
-            if (signalDOMEvent(cm, e) || eventInWidget(cm.display, e)) {
-              return;
-            }
-            e.dataTransfer.setData("Text", cm.getSelection());
-            e.dataTransfer.effectAllowed = "copyMove";
-            if (e.dataTransfer.setDragImage && !safari) {
-              var img = elt(
-                "img",
-                null,
-                null,
-                "position: fixed; left: 0; top: 0;"
-              );
-              img.src =
-                "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw==";
-              if (presto) {
-                img.width = img.height = 1;
-                cm.display.wrapper.appendChild(img);
-                img._top = img.offsetTop;
-              }
-              e.dataTransfer.setDragImage(img, 0, 0);
-              if (presto) {
-                img.parentNode.removeChild(img);
-              }
-            }
-          }
-          function onDragOver(cm, e) {
-            var pos = posFromMouse(cm, e);
-            if (!pos) {
-              return;
-            }
-            var frag = document.createDocumentFragment();
-            drawSelectionCursor(cm, pos, frag);
-            if (!cm.display.dragCursor) {
-              cm.display.dragCursor = elt(
-                "div",
-                null,
-                "CodeMirror-cursors CodeMirror-dragcursors"
-              );
-              cm.display.lineSpace.insertBefore(
-                cm.display.dragCursor,
-                cm.display.cursorDiv
-              );
-            }
-            removeChildrenAndAdd(cm.display.dragCursor, frag);
-          }
-          function clearDragCursor(cm) {
-            if (cm.display.dragCursor) {
-              cm.display.lineSpace.removeChild(cm.display.dragCursor);
-              cm.display.dragCursor = null;
-            }
-          }
-          function forEachCodeMirror(f) {
-            if (!document.getElementsByClassName) {
-              return;
-            }
-            var byClass = document.getElementsByClassName("CodeMirror"),
-              editors = [];
-            for (var i2 = 0; i2 < byClass.length; i2++) {
-              var cm = byClass[i2].CodeMirror;
-              if (cm) {
-                editors.push(cm);
-              }
-            }
-            if (editors.length) {
-              editors[0].operation(function () {
-                for (var i3 = 0; i3 < editors.length; i3++) {
-                  f(editors[i3]);
-                }
-              });
-            }
-          }
-          var globalsRegistered = false;
-          function ensureGlobalHandlers() {
-            if (globalsRegistered) {
-              return;
-            }
-            registerGlobalHandlers();
-            globalsRegistered = true;
-          }
-          function registerGlobalHandlers() {
-            var resizeTimer;
-            on(window, "resize", function () {
-              if (resizeTimer == null) {
-                resizeTimer = setTimeout(function () {
-                  resizeTimer = null;
-                  forEachCodeMirror(onResize);
-                }, 100);
-              }
-            });
-            on(window, "blur", function () {
-              return forEachCodeMirror(onBlur);
-            });
-          }
-          function onResize(cm) {
-            var d = cm.display;
-            d.cachedCharWidth = d.cachedTextHeight = d.cachedPaddingH = null;
-            d.scrollbarsClipped = false;
-            cm.setSize();
-          }
-          var keyNames = {
-            3: "Pause",
-            8: "Backspace",
-            9: "Tab",
-            13: "Enter",
-            16: "Shift",
-            17: "Ctrl",
-            18: "Alt",
-            19: "Pause",
-            20: "CapsLock",
-            27: "Esc",
-            32: "Space",
-            33: "PageUp",
-            34: "PageDown",
-            35: "End",
-            36: "Home",
-            37: "Left",
-            38: "Up",
-            39: "Right",
-            40: "Down",
-            44: "PrintScrn",
-            45: "Insert",
-            46: "Delete",
-            59: ";",
-            61: "=",
-            91: "Mod",
-            92: "Mod",
-            93: "Mod",
-            106: "*",
-            107: "=",
-            109: "-",
-            110: ".",
-            111: "/",
-            145: "ScrollLock",
-            173: "-",
-            186: ";",
-            187: "=",
-            188: ",",
-            189: "-",
-            190: ".",
-            191: "/",
-            192: "`",
-            219: "[",
-            220: "\\",
-            221: "]",
-            222: "'",
-            224: "Mod",
-            63232: "Up",
-            63233: "Down",
-            63234: "Left",
-            63235: "Right",
-            63272: "Delete",
-            63273: "Home",
-            63275: "End",
-            63276: "PageUp",
-            63277: "PageDown",
-            63302: "Insert",
-          };
-          for (var i = 0; i < 10; i++) {
-            keyNames[i + 48] = keyNames[i + 96] = String(i);
-          }
-          for (var i$1 = 65; i$1 <= 90; i$1++) {
-            keyNames[i$1] = String.fromCharCode(i$1);
-          }
-          for (var i$2 = 1; i$2 <= 12; i$2++) {
-            keyNames[i$2 + 111] = keyNames[i$2 + 63235] = "F" + i$2;
-          }
-          var keyMap2 = {};
-          keyMap2.basic = {
-            Left: "goCharLeft",
-            Right: "goCharRight",
-            Up: "goLineUp",
-            Down: "goLineDown",
-            End: "goLineEnd",
-            Home: "goLineStartSmart",
-            PageUp: "goPageUp",
-            PageDown: "goPageDown",
-            Delete: "delCharAfter",
-            Backspace: "delCharBefore",
-            "Shift-Backspace": "delCharBefore",
-            Tab: "defaultTab",
-            "Shift-Tab": "indentAuto",
-            Enter: "newlineAndIndent",
-            Insert: "toggleOverwrite",
-            Esc: "singleSelection",
-          };
-          keyMap2.pcDefault = {
-            "Ctrl-A": "selectAll",
-            "Ctrl-D": "deleteLine",
-            "Ctrl-Z": "undo",
-            "Shift-Ctrl-Z": "redo",
-            "Ctrl-Y": "redo",
-            "Ctrl-Home": "goDocStart",
-            "Ctrl-End": "goDocEnd",
-            "Ctrl-Up": "goLineUp",
-            "Ctrl-Down": "goLineDown",
-            "Ctrl-Left": "goGroupLeft",
-            "Ctrl-Right": "goGroupRight",
-            "Alt-Left": "goLineStart",
-            "Alt-Right": "goLineEnd",
-            "Ctrl-Backspace": "delGroupBefore",
-            "Ctrl-Delete": "delGroupAfter",
-            "Ctrl-S": "save",
-            "Ctrl-F": "find",
-            "Ctrl-G": "findNext",
-            "Shift-Ctrl-G": "findPrev",
-            "Shift-Ctrl-F": "replace",
-            "Shift-Ctrl-R": "replaceAll",
-            "Ctrl-[": "indentLess",
-            "Ctrl-]": "indentMore",
-            "Ctrl-U": "undoSelection",
-            "Shift-Ctrl-U": "redoSelection",
-            "Alt-U": "redoSelection",
-            fallthrough: "basic",
-          };
-          keyMap2.emacsy = {
-            "Ctrl-F": "goCharRight",
-            "Ctrl-B": "goCharLeft",
-            "Ctrl-P": "goLineUp",
-            "Ctrl-N": "goLineDown",
-            "Ctrl-A": "goLineStart",
-            "Ctrl-E": "goLineEnd",
-            "Ctrl-V": "goPageDown",
-            "Shift-Ctrl-V": "goPageUp",
-            "Ctrl-D": "delCharAfter",
-            "Ctrl-H": "delCharBefore",
-            "Alt-Backspace": "delWordBefore",
-            "Ctrl-K": "killLine",
-            "Ctrl-T": "transposeChars",
-            "Ctrl-O": "openLine",
-          };
-          keyMap2.macDefault = {
-            "Cmd-A": "selectAll",
-            "Cmd-D": "deleteLine",
-            "Cmd-Z": "undo",
-            "Shift-Cmd-Z": "redo",
-            "Cmd-Y": "redo",
-            "Cmd-Home": "goDocStart",
-            "Cmd-Up": "goDocStart",
-            "Cmd-End": "goDocEnd",
-            "Cmd-Down": "goDocEnd",
-            "Alt-Left": "goGroupLeft",
-            "Alt-Right": "goGroupRight",
-            "Cmd-Left": "goLineLeft",
-            "Cmd-Right": "goLineRight",
-            "Alt-Backspace": "delGroupBefore",
-            "Ctrl-Alt-Backspace": "delGroupAfter",
-            "Alt-Delete": "delGroupAfter",
-            "Cmd-S": "save",
-            "Cmd-F": "find",
-            "Cmd-G": "findNext",
-            "Shift-Cmd-G": "findPrev",
-            "Cmd-Alt-F": "replace",
-            "Shift-Cmd-Alt-F": "replaceAll",
-            "Cmd-[": "indentLess",
-            "Cmd-]": "indentMore",
-            "Cmd-Backspace": "delWrappedLineLeft",
-            "Cmd-Delete": "delWrappedLineRight",
-            "Cmd-U": "undoSelection",
-            "Shift-Cmd-U": "redoSelection",
-            "Ctrl-Up": "goDocStart",
-            "Ctrl-Down": "goDocEnd",
-            fallthrough: ["basic", "emacsy"],
-          };
-          keyMap2["default"] = mac ? keyMap2.macDefault : keyMap2.pcDefault;
-          function normalizeKeyName(name2) {
-            var parts = name2.split(/-(?!$)/);
-            name2 = parts[parts.length - 1];
-            var alt, ctrl, shift, cmd;
-            for (var i2 = 0; i2 < parts.length - 1; i2++) {
-              var mod = parts[i2];
-              if (/^(cmd|meta|m)$/i.test(mod)) {
-                cmd = true;
-              } else if (/^a(lt)?$/i.test(mod)) {
-                alt = true;
-              } else if (/^(c|ctrl|control)$/i.test(mod)) {
-                ctrl = true;
-              } else if (/^s(hift)?$/i.test(mod)) {
-                shift = true;
-              } else {
-                throw new Error("Unrecognized modifier name: " + mod);
-              }
-            }
-            if (alt) {
-              name2 = "Alt-" + name2;
-            }
-            if (ctrl) {
-              name2 = "Ctrl-" + name2;
-            }
-            if (cmd) {
-              name2 = "Cmd-" + name2;
-            }
-            if (shift) {
-              name2 = "Shift-" + name2;
-            }
-            return name2;
-          }
-          function normalizeKeyMap(keymap) {
-            var copy2 = {};
-            for (var keyname in keymap) {
-              if (keymap.hasOwnProperty(keyname)) {
-                var value = keymap[keyname];
-                if (/^(name|fallthrough|(de|at)tach)$/.test(keyname)) {
-                  continue;
-                }
-                if (value == "...") {
-                  delete keymap[keyname];
-                  continue;
-                }
-                var keys = map2(keyname.split(" "), normalizeKeyName);
-                for (var i2 = 0; i2 < keys.length; i2++) {
-                  var val = void 0,
-                    name2 = void 0;
-                  if (i2 == keys.length - 1) {
-                    name2 = keys.join(" ");
-                    val = value;
-                  } else {
-                    name2 = keys.slice(0, i2 + 1).join(" ");
-                    val = "...";
-                  }
-                  var prev = copy2[name2];
-                  if (!prev) {
-                    copy2[name2] = val;
-                  } else if (prev != val) {
-                    throw new Error("Inconsistent bindings for " + name2);
-                  }
-                }
-                delete keymap[keyname];
-              }
-            }
-            for (var prop3 in copy2) {
-              keymap[prop3] = copy2[prop3];
-            }
-            return keymap;
-          }
-          function lookupKey(key, map3, handle, context) {
-            map3 = getKeyMap(map3);
-            var found = map3.call ? map3.call(key, context) : map3[key];
-            if (found === false) {
-              return "nothing";
-            }
-            if (found === "...") {
-              return "multi";
-            }
-            if (found != null && handle(found)) {
-              return "handled";
-            }
-            if (map3.fallthrough) {
-              if (
-                Object.prototype.toString.call(map3.fallthrough) !=
-                "[object Array]"
-              ) {
-                return lookupKey(key, map3.fallthrough, handle, context);
-              }
-              for (var i2 = 0; i2 < map3.fallthrough.length; i2++) {
-                var result2 = lookupKey(
-                  key,
-                  map3.fallthrough[i2],
-                  handle,
-                  context
-                );
-                if (result2) {
-                  return result2;
-                }
-              }
-            }
-          }
-          function isModifierKey(value) {
-            var name2 =
-              typeof value == "string" ? value : keyNames[value.keyCode];
-            return (
-              name2 == "Ctrl" ||
-              name2 == "Alt" ||
-              name2 == "Shift" ||
-              name2 == "Mod"
-            );
-          }
-          function addModifierNames(name2, event, noShift) {
-            var base2 = name2;
-            if (event.altKey && base2 != "Alt") {
-              name2 = "Alt-" + name2;
-            }
-            if (
-              (flipCtrlCmd ? event.metaKey : event.ctrlKey) &&
-              base2 != "Ctrl"
-            ) {
-              name2 = "Ctrl-" + name2;
-            }
-            if (
-              (flipCtrlCmd ? event.ctrlKey : event.metaKey) &&
-              base2 != "Mod"
-            ) {
-              name2 = "Cmd-" + name2;
-            }
-            if (!noShift && event.shiftKey && base2 != "Shift") {
-              name2 = "Shift-" + name2;
-            }
-            return name2;
-          }
-          function keyName(event, noShift) {
-            if (presto && event.keyCode == 34 && event["char"]) {
-              return false;
-            }
-            var name2 = keyNames[event.keyCode];
-            if (name2 == null || event.altGraphKey) {
-              return false;
-            }
-            if (event.keyCode == 3 && event.code) {
-              name2 = event.code;
-            }
-            return addModifierNames(name2, event, noShift);
-          }
-          function getKeyMap(val) {
-            return typeof val == "string" ? keyMap2[val] : val;
-          }
-          function deleteNearSelection(cm, compute) {
-            var ranges = cm.doc.sel.ranges,
-              kill = [];
-            for (var i2 = 0; i2 < ranges.length; i2++) {
-              var toKill = compute(ranges[i2]);
-              while (kill.length && cmp(toKill.from, lst(kill).to) <= 0) {
-                var replaced = kill.pop();
-                if (cmp(replaced.from, toKill.from) < 0) {
-                  toKill.from = replaced.from;
-                  break;
-                }
-              }
-              kill.push(toKill);
-            }
-            runInOp(cm, function () {
-              for (var i3 = kill.length - 1; i3 >= 0; i3--) {
-                replaceRange(cm.doc, "", kill[i3].from, kill[i3].to, "+delete");
-              }
-              ensureCursorVisible(cm);
-            });
-          }
-          function moveCharLogically(line, ch2, dir) {
-            var target2 = skipExtendingChars(line.text, ch2 + dir, dir);
-            return target2 < 0 || target2 > line.text.length ? null : target2;
-          }
-          function moveLogically(line, start2, dir) {
-            var ch2 = moveCharLogically(line, start2.ch, dir);
-            return ch2 == null
-              ? null
-              : new Pos(start2.line, ch2, dir < 0 ? "after" : "before");
-          }
-          function endOfLine(visually, cm, lineObj, lineNo2, dir) {
-            if (visually) {
-              if (cm.doc.direction == "rtl") {
-                dir = -dir;
-              }
-              var order2 = getOrder(lineObj, cm.doc.direction);
-              if (order2) {
-                var part2 = dir < 0 ? lst(order2) : order2[0];
-                var moveInStorageOrder = dir < 0 == (part2.level == 1);
-                var sticky = moveInStorageOrder ? "after" : "before";
-                var ch2;
-                if (part2.level > 0 || cm.doc.direction == "rtl") {
-                  var prep = prepareMeasureForLine(cm, lineObj);
-                  ch2 = dir < 0 ? lineObj.text.length - 1 : 0;
-                  var targetTop = measureCharPrepared(cm, prep, ch2).top;
-                  ch2 = findFirst(
-                    function (ch3) {
-                      return (
-                        measureCharPrepared(cm, prep, ch3).top == targetTop
-                      );
-                    },
-                    dir < 0 == (part2.level == 1) ? part2.from : part2.to - 1,
-                    ch2
-                  );
-                  if (sticky == "before") {
-                    ch2 = moveCharLogically(lineObj, ch2, 1);
-                  }
-                } else {
-                  ch2 = dir < 0 ? part2.to : part2.from;
-                }
-                return new Pos(lineNo2, ch2, sticky);
-              }
-            }
-            return new Pos(
-              lineNo2,
-              dir < 0 ? lineObj.text.length : 0,
-              dir < 0 ? "before" : "after"
-            );
-          }
-          function moveVisually(cm, line, start2, dir) {
-            var bidi = getOrder(line, cm.doc.direction);
-            if (!bidi) {
-              return moveLogically(line, start2, dir);
-            }
-            if (start2.ch >= line.text.length) {
-              start2.ch = line.text.length;
-              start2.sticky = "before";
-            } else if (start2.ch <= 0) {
-              start2.ch = 0;
-              start2.sticky = "after";
-            }
-            var partPos = getBidiPartAt(bidi, start2.ch, start2.sticky),
-              part2 = bidi[partPos];
-            if (
-              cm.doc.direction == "ltr" &&
-              part2.level % 2 == 0 &&
-              (dir > 0 ? part2.to > start2.ch : part2.from < start2.ch)
-            ) {
-              return moveLogically(line, start2, dir);
-            }
-            var mv = function (pos, dir2) {
-              return moveCharLogically(
-                line,
-                pos instanceof Pos ? pos.ch : pos,
-                dir2
-              );
-            };
-            var prep;
-            var getWrappedLineExtent = function (ch3) {
-              if (!cm.options.lineWrapping) {
-                return { begin: 0, end: line.text.length };
-              }
-              prep = prep || prepareMeasureForLine(cm, line);
-              return wrappedLineExtentChar(cm, line, prep, ch3);
-            };
-            var wrappedLineExtent2 = getWrappedLineExtent(
-              start2.sticky == "before" ? mv(start2, -1) : start2.ch
-            );
-            if (cm.doc.direction == "rtl" || part2.level == 1) {
-              var moveInStorageOrder = (part2.level == 1) == dir < 0;
-              var ch2 = mv(start2, moveInStorageOrder ? 1 : -1);
-              if (
-                ch2 != null &&
-                (!moveInStorageOrder
-                  ? ch2 >= part2.from && ch2 >= wrappedLineExtent2.begin
-                  : ch2 <= part2.to && ch2 <= wrappedLineExtent2.end)
-              ) {
-                var sticky = moveInStorageOrder ? "before" : "after";
-                return new Pos(start2.line, ch2, sticky);
-              }
-            }
-            var searchInVisualLine = function (
-              partPos2,
-              dir2,
-              wrappedLineExtent3
-            ) {
-              var getRes = function (ch4, moveInStorageOrder3) {
-                return moveInStorageOrder3
-                  ? new Pos(start2.line, mv(ch4, 1), "before")
-                  : new Pos(start2.line, ch4, "after");
-              };
-              for (
-                ;
-                partPos2 >= 0 && partPos2 < bidi.length;
-                partPos2 += dir2
-              ) {
-                var part3 = bidi[partPos2];
-                var moveInStorageOrder2 = dir2 > 0 == (part3.level != 1);
-                var ch3 = moveInStorageOrder2
-                  ? wrappedLineExtent3.begin
-                  : mv(wrappedLineExtent3.end, -1);
-                if (part3.from <= ch3 && ch3 < part3.to) {
-                  return getRes(ch3, moveInStorageOrder2);
-                }
-                ch3 = moveInStorageOrder2 ? part3.from : mv(part3.to, -1);
-                if (
-                  wrappedLineExtent3.begin <= ch3 &&
-                  ch3 < wrappedLineExtent3.end
-                ) {
-                  return getRes(ch3, moveInStorageOrder2);
-                }
-              }
-            };
-            var res = searchInVisualLine(
-              partPos + dir,
-              dir,
-              wrappedLineExtent2
-            );
-            if (res) {
-              return res;
-            }
-            var nextCh =
-              dir > 0
-                ? wrappedLineExtent2.end
-                : mv(wrappedLineExtent2.begin, -1);
-            if (nextCh != null && !(dir > 0 && nextCh == line.text.length)) {
-              res = searchInVisualLine(
-                dir > 0 ? 0 : bidi.length - 1,
-                dir,
-                getWrappedLineExtent(nextCh)
-              );
-              if (res) {
-                return res;
-              }
-            }
-            return null;
-          }
-          var commands = {
-            selectAll,
-            singleSelection: function (cm) {
-              return cm.setSelection(
-                cm.getCursor("anchor"),
-                cm.getCursor("head"),
-                sel_dontScroll
-              );
-            },
-            killLine: function (cm) {
-              return deleteNearSelection(cm, function (range3) {
-                if (range3.empty()) {
-                  var len = getLine2(cm.doc, range3.head.line).text.length;
-                  if (
-                    range3.head.ch == len &&
-                    range3.head.line < cm.lastLine()
-                  ) {
-                    return {
-                      from: range3.head,
-                      to: Pos(range3.head.line + 1, 0),
-                    };
-                  } else {
-                    return {
-                      from: range3.head,
-                      to: Pos(range3.head.line, len),
-                    };
-                  }
-                } else {
-                  return { from: range3.from(), to: range3.to() };
-                }
-              });
-            },
-            deleteLine: function (cm) {
-              return deleteNearSelection(cm, function (range3) {
-                return {
-                  from: Pos(range3.from().line, 0),
-                  to: clipPos(cm.doc, Pos(range3.to().line + 1, 0)),
-                };
-              });
-            },
-            delLineLeft: function (cm) {
-              return deleteNearSelection(cm, function (range3) {
-                return {
-                  from: Pos(range3.from().line, 0),
-                  to: range3.from(),
-                };
-              });
-            },
-            delWrappedLineLeft: function (cm) {
-              return deleteNearSelection(cm, function (range3) {
-                var top2 = cm.charCoords(range3.head, "div").top + 5;
-                var leftPos = cm.coordsChar({ left: 0, top: top2 }, "div");
-                return { from: leftPos, to: range3.from() };
-              });
-            },
-            delWrappedLineRight: function (cm) {
-              return deleteNearSelection(cm, function (range3) {
-                var top2 = cm.charCoords(range3.head, "div").top + 5;
-                var rightPos = cm.coordsChar(
-                  { left: cm.display.lineDiv.offsetWidth + 100, top: top2 },
-                  "div"
-                );
-                return { from: range3.from(), to: rightPos };
-              });
-            },
-            undo: function (cm) {
-              return cm.undo();
-            },
-            redo: function (cm) {
-              return cm.redo();
-            },
-            undoSelection: function (cm) {
-              return cm.undoSelection();
-            },
-            redoSelection: function (cm) {
-              return cm.redoSelection();
-            },
-            goDocStart: function (cm) {
-              return cm.extendSelection(Pos(cm.firstLine(), 0));
-            },
-            goDocEnd: function (cm) {
-              return cm.extendSelection(Pos(cm.lastLine()));
-            },
-            goLineStart: function (cm) {
-              return cm.extendSelectionsBy(
-                function (range3) {
-                  return lineStart(cm, range3.head.line);
-                },
-                { origin: "+move", bias: 1 }
-              );
-            },
-            goLineStartSmart: function (cm) {
-              return cm.extendSelectionsBy(
-                function (range3) {
-                  return lineStartSmart(cm, range3.head);
-                },
-                { origin: "+move", bias: 1 }
-              );
-            },
-            goLineEnd: function (cm) {
-              return cm.extendSelectionsBy(
-                function (range3) {
-                  return lineEnd(cm, range3.head.line);
-                },
-                { origin: "+move", bias: -1 }
-              );
-            },
-            goLineRight: function (cm) {
-              return cm.extendSelectionsBy(function (range3) {
-                var top2 = cm.cursorCoords(range3.head, "div").top + 5;
-                return cm.coordsChar(
-                  { left: cm.display.lineDiv.offsetWidth + 100, top: top2 },
-                  "div"
-                );
-              }, sel_move);
-            },
-            goLineLeft: function (cm) {
-              return cm.extendSelectionsBy(function (range3) {
-                var top2 = cm.cursorCoords(range3.head, "div").top + 5;
-                return cm.coordsChar({ left: 0, top: top2 }, "div");
-              }, sel_move);
-            },
-            goLineLeftSmart: function (cm) {
-              return cm.extendSelectionsBy(function (range3) {
-                var top2 = cm.cursorCoords(range3.head, "div").top + 5;
-                var pos = cm.coordsChar({ left: 0, top: top2 }, "div");
-                if (pos.ch < cm.getLine(pos.line).search(/\S/)) {
-                  return lineStartSmart(cm, range3.head);
-                }
-                return pos;
-              }, sel_move);
-            },
-            goLineUp: function (cm) {
-              return cm.moveV(-1, "line");
-            },
-            goLineDown: function (cm) {
-              return cm.moveV(1, "line");
-            },
-            goPageUp: function (cm) {
-              return cm.moveV(-1, "page");
-            },
-            goPageDown: function (cm) {
-              return cm.moveV(1, "page");
-            },
-            goCharLeft: function (cm) {
-              return cm.moveH(-1, "char");
-            },
-            goCharRight: function (cm) {
-              return cm.moveH(1, "char");
-            },
-            goColumnLeft: function (cm) {
-              return cm.moveH(-1, "column");
-            },
-            goColumnRight: function (cm) {
-              return cm.moveH(1, "column");
-            },
-            goWordLeft: function (cm) {
-              return cm.moveH(-1, "word");
-            },
-            goGroupRight: function (cm) {
-              return cm.moveH(1, "group");
-            },
-            goGroupLeft: function (cm) {
-              return cm.moveH(-1, "group");
-            },
-            goWordRight: function (cm) {
-              return cm.moveH(1, "word");
-            },
-            delCharBefore: function (cm) {
-              return cm.deleteH(-1, "codepoint");
-            },
-            delCharAfter: function (cm) {
-              return cm.deleteH(1, "char");
-            },
-            delWordBefore: function (cm) {
-              return cm.deleteH(-1, "word");
-            },
-            delWordAfter: function (cm) {
-              return cm.deleteH(1, "word");
-            },
-            delGroupBefore: function (cm) {
-              return cm.deleteH(-1, "group");
-            },
-            delGroupAfter: function (cm) {
-              return cm.deleteH(1, "group");
-            },
-            indentAuto: function (cm) {
-              return cm.indentSelection("smart");
-            },
-            indentMore: function (cm) {
-              return cm.indentSelection("add");
-            },
-            indentLess: function (cm) {
-              return cm.indentSelection("subtract");
-            },
-            insertTab: function (cm) {
-              return cm.replaceSelection("	");
-            },
-            insertSoftTab: function (cm) {
-              var spaces = [],
-                ranges = cm.listSelections(),
-                tabSize = cm.options.tabSize;
-              for (var i2 = 0; i2 < ranges.length; i2++) {
-                var pos = ranges[i2].from();
-                var col = countColumn(cm.getLine(pos.line), pos.ch, tabSize);
-                spaces.push(spaceStr(tabSize - (col % tabSize)));
-              }
-              cm.replaceSelections(spaces);
-            },
-            defaultTab: function (cm) {
-              if (cm.somethingSelected()) {
-                cm.indentSelection("add");
-              } else {
-                cm.execCommand("insertTab");
-              }
-            },
-            transposeChars: function (cm) {
-              return runInOp(cm, function () {
-                var ranges = cm.listSelections(),
-                  newSel = [];
-                for (var i2 = 0; i2 < ranges.length; i2++) {
-                  if (!ranges[i2].empty()) {
-                    continue;
-                  }
-                  var cur = ranges[i2].head,
-                    line = getLine2(cm.doc, cur.line).text;
-                  if (line) {
-                    if (cur.ch == line.length) {
-                      cur = new Pos(cur.line, cur.ch - 1);
-                    }
-                    if (cur.ch > 0) {
-                      cur = new Pos(cur.line, cur.ch + 1);
-                      cm.replaceRange(
-                        line.charAt(cur.ch - 1) + line.charAt(cur.ch - 2),
-                        Pos(cur.line, cur.ch - 2),
-                        cur,
-                        "+transpose"
-                      );
-                    } else if (cur.line > cm.doc.first) {
-                      var prev = getLine2(cm.doc, cur.line - 1).text;
-                      if (prev) {
-                        cur = new Pos(cur.line, 1);
-                        cm.replaceRange(
-                          line.charAt(0) +
-                            cm.doc.lineSeparator() +
-                            prev.charAt(prev.length - 1),
-                          Pos(cur.line - 1, prev.length - 1),
-                          cur,
-                          "+transpose"
-                        );
-                      }
-                    }
-                  }
-                  newSel.push(new Range2(cur, cur));
-                }
-                cm.setSelections(newSel);
-              });
-            },
-            newlineAndIndent: function (cm) {
-              return runInOp(cm, function () {
-                var sels = cm.listSelections();
-                for (var i2 = sels.length - 1; i2 >= 0; i2--) {
-                  cm.replaceRange(
-                    cm.doc.lineSeparator(),
-                    sels[i2].anchor,
-                    sels[i2].head,
-                    "+input"
-                  );
-                }
-                sels = cm.listSelections();
-                for (var i$12 = 0; i$12 < sels.length; i$12++) {
-                  cm.indentLine(sels[i$12].from().line, null, true);
-                }
-                ensureCursorVisible(cm);
-              });
-            },
-            openLine: function (cm) {
-              return cm.replaceSelection("\n", "start");
-            },
-            toggleOverwrite: function (cm) {
-              return cm.toggleOverwrite();
-            },
-          };
-          function lineStart(cm, lineN) {
-            var line = getLine2(cm.doc, lineN);
-            var visual = visualLine(line);
-            if (visual != line) {
-              lineN = lineNo(visual);
-            }
-            return endOfLine(true, cm, visual, lineN, 1);
-          }
-          function lineEnd(cm, lineN) {
-            var line = getLine2(cm.doc, lineN);
-            var visual = visualLineEnd(line);
-            if (visual != line) {
-              lineN = lineNo(visual);
-            }
-            return endOfLine(true, cm, line, lineN, -1);
-          }
-          function lineStartSmart(cm, pos) {
-            var start2 = lineStart(cm, pos.line);
-            var line = getLine2(cm.doc, start2.line);
-            var order2 = getOrder(line, cm.doc.direction);
-            if (!order2 || order2[0].level == 0) {
-              var firstNonWS = Math.max(start2.ch, line.text.search(/\S/));
-              var inWS =
-                pos.line == start2.line && pos.ch <= firstNonWS && pos.ch;
-              return Pos(start2.line, inWS ? 0 : firstNonWS, start2.sticky);
-            }
-            return start2;
-          }
-          function doHandleBinding(cm, bound, dropShift) {
-            if (typeof bound == "string") {
-              bound = commands[bound];
-              if (!bound) {
-                return false;
-              }
-            }
-            cm.display.input.ensurePolled();
-            var prevShift = cm.display.shift,
-              done = false;
-            try {
-              if (cm.isReadOnly()) {
-                cm.state.suppressEdits = true;
-              }
-              if (dropShift) {
-                cm.display.shift = false;
-              }
-              done = bound(cm) != Pass;
-            } finally {
-              cm.display.shift = prevShift;
-              cm.state.suppressEdits = false;
-            }
-            return done;
-          }
-          function lookupKeyForEditor(cm, name2, handle) {
-            for (var i2 = 0; i2 < cm.state.keyMaps.length; i2++) {
-              var result2 = lookupKey(name2, cm.state.keyMaps[i2], handle, cm);
-              if (result2) {
-                return result2;
-              }
-            }
-            return (
-              (cm.options.extraKeys &&
-                lookupKey(name2, cm.options.extraKeys, handle, cm)) ||
-              lookupKey(name2, cm.options.keyMap, handle, cm)
-            );
-          }
-          var stopSeq = new Delayed();
-          function dispatchKey(cm, name2, e, handle) {
-            var seq = cm.state.keySeq;
-            if (seq) {
-              if (isModifierKey(name2)) {
-                return "handled";
-              }
-              if (/\'$/.test(name2)) {
-                cm.state.keySeq = null;
-              } else {
-                stopSeq.set(50, function () {
-                  if (cm.state.keySeq == seq) {
-                    cm.state.keySeq = null;
-                    cm.display.input.reset();
-                  }
-                });
-              }
-              if (dispatchKeyInner(cm, seq + " " + name2, e, handle)) {
-                return true;
-              }
-            }
-            return dispatchKeyInner(cm, name2, e, handle);
-          }
-          function dispatchKeyInner(cm, name2, e, handle) {
-            var result2 = lookupKeyForEditor(cm, name2, handle);
-            if (result2 == "multi") {
-              cm.state.keySeq = name2;
-            }
-            if (result2 == "handled") {
-              signalLater(cm, "keyHandled", cm, name2, e);
-            }
-            if (result2 == "handled" || result2 == "multi") {
-              e_preventDefault(e);
-              restartBlink(cm);
-            }
-            return !!result2;
-          }
-          function handleKeyBinding(cm, e) {
-            var name2 = keyName(e, true);
-            if (!name2) {
-              return false;
-            }
-            if (e.shiftKey && !cm.state.keySeq) {
-              return (
-                dispatchKey(cm, "Shift-" + name2, e, function (b) {
-                  return doHandleBinding(cm, b, true);
-                }) ||
-                dispatchKey(cm, name2, e, function (b) {
-                  if (typeof b == "string" ? /^go[A-Z]/.test(b) : b.motion) {
-                    return doHandleBinding(cm, b);
-                  }
-                })
-              );
-            } else {
-              return dispatchKey(cm, name2, e, function (b) {
-                return doHandleBinding(cm, b);
-              });
-            }
-          }
-          function handleCharBinding(cm, e, ch2) {
-            return dispatchKey(cm, "'" + ch2 + "'", e, function (b) {
-              return doHandleBinding(cm, b, true);
-            });
-          }
-          var lastStoppedKey = null;
-          function onKeyDown2(e) {
-            var cm = this;
-            if (e.target && e.target != cm.display.input.getField()) {
-              return;
-            }
-            cm.curOp.focus = activeElt();
-            if (signalDOMEvent(cm, e)) {
-              return;
-            }
-            if (ie2 && ie_version < 11 && e.keyCode == 27) {
-              e.returnValue = false;
-            }
-            var code3 = e.keyCode;
-            cm.display.shift = code3 == 16 || e.shiftKey;
-            var handled = handleKeyBinding(cm, e);
-            if (presto) {
-              lastStoppedKey = handled ? code3 : null;
-              if (
-                !handled &&
-                code3 == 88 &&
-                !hasCopyEvent &&
-                (mac ? e.metaKey : e.ctrlKey)
-              ) {
-                cm.replaceSelection("", null, "cut");
-              }
-            }
-            if (
-              gecko &&
-              !mac &&
-              !handled &&
-              code3 == 46 &&
-              e.shiftKey &&
-              !e.ctrlKey &&
-              document.execCommand
-            ) {
-              document.execCommand("cut");
-            }
-            if (
-              code3 == 18 &&
-              !/\bCodeMirror-crosshair\b/.test(cm.display.lineDiv.className)
-            ) {
-              showCrossHair(cm);
-            }
-          }
-          function showCrossHair(cm) {
-            var lineDiv = cm.display.lineDiv;
-            addClass(lineDiv, "CodeMirror-crosshair");
-            function up(e) {
-              if (e.keyCode == 18 || !e.altKey) {
-                rmClass(lineDiv, "CodeMirror-crosshair");
-                off(document, "keyup", up);
-                off(document, "mouseover", up);
-              }
-            }
-            on(document, "keyup", up);
-            on(document, "mouseover", up);
-          }
-          function onKeyUp(e) {
-            if (e.keyCode == 16) {
-              this.doc.sel.shift = false;
-            }
-            signalDOMEvent(this, e);
-          }
-          function onKeyPress(e) {
-            var cm = this;
-            if (e.target && e.target != cm.display.input.getField()) {
-              return;
-            }
-            if (
-              eventInWidget(cm.display, e) ||
-              signalDOMEvent(cm, e) ||
-              (e.ctrlKey && !e.altKey) ||
-              (mac && e.metaKey)
-            ) {
-              return;
-            }
-            var keyCode = e.keyCode,
-              charCode = e.charCode;
-            if (presto && keyCode == lastStoppedKey) {
-              lastStoppedKey = null;
-              e_preventDefault(e);
-              return;
-            }
-            if (
-              presto &&
-              (!e.which || e.which < 10) &&
-              handleKeyBinding(cm, e)
-            ) {
-              return;
-            }
-            var ch2 = String.fromCharCode(
-              charCode == null ? keyCode : charCode
-            );
-            if (ch2 == "\b") {
-              return;
-            }
-            if (handleCharBinding(cm, e, ch2)) {
-              return;
-            }
-            cm.display.input.onKeyPress(e);
-          }
-          var DOUBLECLICK_DELAY = 400;
-          var PastClick = function (time, pos, button) {
-            this.time = time;
-            this.pos = pos;
-            this.button = button;
-          };
-          PastClick.prototype.compare = function (time, pos, button) {
-            return (
-              this.time + DOUBLECLICK_DELAY > time &&
-              cmp(pos, this.pos) == 0 &&
-              button == this.button
-            );
-          };
-          var lastClick, lastDoubleClick;
-          function clickRepeat(pos, button) {
-            var now = +new Date();
-            if (lastDoubleClick && lastDoubleClick.compare(now, pos, button)) {
-              lastClick = lastDoubleClick = null;
-              return "triple";
-            } else if (lastClick && lastClick.compare(now, pos, button)) {
-              lastDoubleClick = new PastClick(now, pos, button);
-              lastClick = null;
-              return "double";
-            } else {
-              lastClick = new PastClick(now, pos, button);
-              lastDoubleClick = null;
-              return "single";
-            }
-          }
-          function onMouseDown(e) {
-            var cm = this,
-              display = cm.display;
-            if (
-              signalDOMEvent(cm, e) ||
-              (display.activeTouch && display.input.supportsTouch())
-            ) {
-              return;
-            }
-            display.input.ensurePolled();
-            display.shift = e.shiftKey;
-            if (eventInWidget(display, e)) {
-              if (!webkit) {
-                display.scroller.draggable = false;
-                setTimeout(function () {
-                  return (display.scroller.draggable = true);
-                }, 100);
-              }
-              return;
-            }
-            if (clickInGutter(cm, e)) {
-              return;
-            }
-            var pos = posFromMouse(cm, e),
-              button = e_button(e),
-              repeat = pos ? clickRepeat(pos, button) : "single";
-            window.focus();
-            if (button == 1 && cm.state.selectingText) {
-              cm.state.selectingText(e);
-            }
-            if (pos && handleMappedButton(cm, button, pos, repeat, e)) {
-              return;
-            }
-            if (button == 1) {
-              if (pos) {
-                leftButtonDown(cm, pos, repeat, e);
-              } else if (e_target(e) == display.scroller) {
-                e_preventDefault(e);
-              }
-            } else if (button == 2) {
-              if (pos) {
-                extendSelection(cm.doc, pos);
-              }
-              setTimeout(function () {
-                return display.input.focus();
-              }, 20);
-            } else if (button == 3) {
-              if (captureRightClick) {
-                cm.display.input.onContextMenu(e);
-              } else {
-                delayBlurEvent(cm);
-              }
-            }
-          }
-          function handleMappedButton(cm, button, pos, repeat, event) {
-            var name2 = "Click";
-            if (repeat == "double") {
-              name2 = "Double" + name2;
-            } else if (repeat == "triple") {
-              name2 = "Triple" + name2;
-            }
-            name2 =
-              (button == 1 ? "Left" : button == 2 ? "Middle" : "Right") + name2;
-            return dispatchKey(
-              cm,
-              addModifierNames(name2, event),
-              event,
-              function (bound) {
-                if (typeof bound == "string") {
-                  bound = commands[bound];
-                }
-                if (!bound) {
-                  return false;
-                }
-                var done = false;
-                try {
-                  if (cm.isReadOnly()) {
-                    cm.state.suppressEdits = true;
-                  }
-                  done = bound(cm, pos) != Pass;
-                } finally {
-                  cm.state.suppressEdits = false;
-                }
-                return done;
-              }
-            );
-          }
-          function configureMouse(cm, repeat, event) {
-            var option = cm.getOption("configureMouse");
-            var value = option ? option(cm, repeat, event) : {};
-            if (value.unit == null) {
-              var rect2 = chromeOS
-                ? event.shiftKey && event.metaKey
-                : event.altKey;
-              value.unit = rect2
-                ? "rectangle"
-                : repeat == "single"
-                ? "char"
-                : repeat == "double"
-                ? "word"
-                : "line";
-            }
-            if (value.extend == null || cm.doc.extend) {
-              value.extend = cm.doc.extend || event.shiftKey;
-            }
-            if (value.addNew == null) {
-              value.addNew = mac ? event.metaKey : event.ctrlKey;
-            }
-            if (value.moveOnDrag == null) {
-              value.moveOnDrag = !(mac ? event.altKey : event.ctrlKey);
-            }
-            return value;
-          }
-          function leftButtonDown(cm, pos, repeat, event) {
-            if (ie2) {
-              setTimeout(bind(ensureFocus, cm), 0);
-            } else {
-              cm.curOp.focus = activeElt();
-            }
-            var behavior = configureMouse(cm, repeat, event);
-            var sel = cm.doc.sel,
-              contained;
-            if (
-              cm.options.dragDrop &&
-              dragAndDrop &&
-              !cm.isReadOnly() &&
-              repeat == "single" &&
-              (contained = sel.contains(pos)) > -1 &&
-              (cmp((contained = sel.ranges[contained]).from(), pos) < 0 ||
-                pos.xRel > 0) &&
-              (cmp(contained.to(), pos) > 0 || pos.xRel < 0)
-            ) {
-              leftButtonStartDrag(cm, event, pos, behavior);
-            } else {
-              leftButtonSelect(cm, event, pos, behavior);
-            }
-          }
-          function leftButtonStartDrag(cm, event, pos, behavior) {
-            var display = cm.display,
-              moved = false;
-            var dragEnd = operation(cm, function (e) {
-              if (webkit) {
-                display.scroller.draggable = false;
-              }
-              cm.state.draggingText = false;
-              if (cm.state.delayingBlurEvent) {
-                if (cm.hasFocus()) {
-                  cm.state.delayingBlurEvent = false;
-                } else {
-                  delayBlurEvent(cm);
-                }
-              }
-              off(display.wrapper.ownerDocument, "mouseup", dragEnd);
-              off(display.wrapper.ownerDocument, "mousemove", mouseMove);
-              off(display.scroller, "dragstart", dragStart);
-              off(display.scroller, "drop", dragEnd);
-              if (!moved) {
-                e_preventDefault(e);
-                if (!behavior.addNew) {
-                  extendSelection(cm.doc, pos, null, null, behavior.extend);
-                }
-                if ((webkit && !safari) || (ie2 && ie_version == 9)) {
-                  setTimeout(function () {
-                    display.wrapper.ownerDocument.body.focus({
-                      preventScroll: true,
-                    });
-                    display.input.focus();
-                  }, 20);
-                } else {
-                  display.input.focus();
-                }
-              }
-            });
-            var mouseMove = function (e2) {
-              moved =
-                moved ||
-                Math.abs(event.clientX - e2.clientX) +
-                  Math.abs(event.clientY - e2.clientY) >=
-                  10;
-            };
-            var dragStart = function () {
-              return (moved = true);
-            };
-            if (webkit) {
-              display.scroller.draggable = true;
-            }
-            cm.state.draggingText = dragEnd;
-            dragEnd.copy = !behavior.moveOnDrag;
-            on(display.wrapper.ownerDocument, "mouseup", dragEnd);
-            on(display.wrapper.ownerDocument, "mousemove", mouseMove);
-            on(display.scroller, "dragstart", dragStart);
-            on(display.scroller, "drop", dragEnd);
-            cm.state.delayingBlurEvent = true;
-            setTimeout(function () {
-              return display.input.focus();
-            }, 20);
-            if (display.scroller.dragDrop) {
-              display.scroller.dragDrop();
-            }
-          }
-          function rangeForUnit(cm, pos, unit) {
-            if (unit == "char") {
-              return new Range2(pos, pos);
-            }
-            if (unit == "word") {
-              return cm.findWordAt(pos);
-            }
-            if (unit == "line") {
-              return new Range2(
-                Pos(pos.line, 0),
-                clipPos(cm.doc, Pos(pos.line + 1, 0))
-              );
-            }
-            var result2 = unit(cm, pos);
-            return new Range2(result2.from, result2.to);
-          }
-          function leftButtonSelect(cm, event, start2, behavior) {
-            if (ie2) {
-              delayBlurEvent(cm);
-            }
-            var display = cm.display,
-              doc = cm.doc;
-            e_preventDefault(event);
-            var ourRange,
-              ourIndex,
-              startSel = doc.sel,
-              ranges = startSel.ranges;
-            if (behavior.addNew && !behavior.extend) {
-              ourIndex = doc.sel.contains(start2);
-              if (ourIndex > -1) {
-                ourRange = ranges[ourIndex];
-              } else {
-                ourRange = new Range2(start2, start2);
-              }
-            } else {
-              ourRange = doc.sel.primary();
-              ourIndex = doc.sel.primIndex;
-            }
-            if (behavior.unit == "rectangle") {
-              if (!behavior.addNew) {
-                ourRange = new Range2(start2, start2);
-              }
-              start2 = posFromMouse(cm, event, true, true);
-              ourIndex = -1;
-            } else {
-              var range3 = rangeForUnit(cm, start2, behavior.unit);
-              if (behavior.extend) {
-                ourRange = extendRange(
-                  ourRange,
-                  range3.anchor,
-                  range3.head,
-                  behavior.extend
-                );
-              } else {
-                ourRange = range3;
-              }
-            }
-            if (!behavior.addNew) {
-              ourIndex = 0;
-              setSelection(doc, new Selection([ourRange], 0), sel_mouse);
-              startSel = doc.sel;
-            } else if (ourIndex == -1) {
-              ourIndex = ranges.length;
-              setSelection(
-                doc,
-                normalizeSelection(cm, ranges.concat([ourRange]), ourIndex),
-                { scroll: false, origin: "*mouse" }
-              );
-            } else if (
-              ranges.length > 1 &&
-              ranges[ourIndex].empty() &&
-              behavior.unit == "char" &&
-              !behavior.extend
-            ) {
-              setSelection(
-                doc,
-                normalizeSelection(
-                  cm,
-                  ranges.slice(0, ourIndex).concat(ranges.slice(ourIndex + 1)),
-                  0
-                ),
-                { scroll: false, origin: "*mouse" }
-              );
-              startSel = doc.sel;
-            } else {
-              replaceOneSelection(doc, ourIndex, ourRange, sel_mouse);
-            }
-            var lastPos = start2;
-            function extendTo(pos) {
-              if (cmp(lastPos, pos) == 0) {
-                return;
-              }
-              lastPos = pos;
-              if (behavior.unit == "rectangle") {
-                var ranges2 = [],
-                  tabSize = cm.options.tabSize;
-                var startCol = countColumn(
-                  getLine2(doc, start2.line).text,
-                  start2.ch,
-                  tabSize
-                );
-                var posCol = countColumn(
-                  getLine2(doc, pos.line).text,
-                  pos.ch,
-                  tabSize
-                );
-                var left = Math.min(startCol, posCol),
-                  right = Math.max(startCol, posCol);
-                for (
-                  var line = Math.min(start2.line, pos.line),
-                    end2 = Math.min(
-                      cm.lastLine(),
-                      Math.max(start2.line, pos.line)
-                    );
-                  line <= end2;
-                  line++
-                ) {
-                  var text3 = getLine2(doc, line).text,
-                    leftPos = findColumn(text3, left, tabSize);
-                  if (left == right) {
-                    ranges2.push(
-                      new Range2(Pos(line, leftPos), Pos(line, leftPos))
-                    );
-                  } else if (text3.length > leftPos) {
-                    ranges2.push(
-                      new Range2(
-                        Pos(line, leftPos),
-                        Pos(line, findColumn(text3, right, tabSize))
-                      )
-                    );
-                  }
-                }
-                if (!ranges2.length) {
-                  ranges2.push(new Range2(start2, start2));
-                }
-                setSelection(
-                  doc,
-                  normalizeSelection(
-                    cm,
-                    startSel.ranges.slice(0, ourIndex).concat(ranges2),
-                    ourIndex
-                  ),
-                  { origin: "*mouse", scroll: false }
-                );
-                cm.scrollIntoView(pos);
-              } else {
-                var oldRange = ourRange;
-                var range4 = rangeForUnit(cm, pos, behavior.unit);
-                var anchor = oldRange.anchor,
-                  head;
-                if (cmp(range4.anchor, anchor) > 0) {
-                  head = range4.head;
-                  anchor = minPos(oldRange.from(), range4.anchor);
-                } else {
-                  head = range4.anchor;
-                  anchor = maxPos(oldRange.to(), range4.head);
-                }
-                var ranges$1 = startSel.ranges.slice(0);
-                ranges$1[ourIndex] = bidiSimplify(
-                  cm,
-                  new Range2(clipPos(doc, anchor), head)
-                );
-                setSelection(
-                  doc,
-                  normalizeSelection(cm, ranges$1, ourIndex),
-                  sel_mouse
-                );
-              }
-            }
-            var editorSize = display.wrapper.getBoundingClientRect();
-            var counter = 0;
-            function extend(e) {
-              var curCount = ++counter;
-              var cur = posFromMouse(cm, e, true, behavior.unit == "rectangle");
-              if (!cur) {
-                return;
-              }
-              if (cmp(cur, lastPos) != 0) {
-                cm.curOp.focus = activeElt();
-                extendTo(cur);
-                var visible = visibleLines(display, doc);
-                if (cur.line >= visible.to || cur.line < visible.from) {
-                  setTimeout(
-                    operation(cm, function () {
-                      if (counter == curCount) {
-                        extend(e);
-                      }
-                    }),
-                    150
-                  );
-                }
-              } else {
-                var outside =
-                  e.clientY < editorSize.top
-                    ? -20
-                    : e.clientY > editorSize.bottom
-                    ? 20
-                    : 0;
-                if (outside) {
-                  setTimeout(
-                    operation(cm, function () {
-                      if (counter != curCount) {
-                        return;
-                      }
-                      display.scroller.scrollTop += outside;
-                      extend(e);
-                    }),
-                    50
-                  );
-                }
-              }
-            }
-            function done(e) {
-              cm.state.selectingText = false;
-              counter = Infinity;
-              if (e) {
-                e_preventDefault(e);
-                display.input.focus();
-              }
-              off(display.wrapper.ownerDocument, "mousemove", move);
-              off(display.wrapper.ownerDocument, "mouseup", up);
-              doc.history.lastSelOrigin = null;
-            }
-            var move = operation(cm, function (e) {
-              if (e.buttons === 0 || !e_button(e)) {
-                done(e);
-              } else {
-                extend(e);
-              }
-            });
-            var up = operation(cm, done);
-            cm.state.selectingText = up;
-            on(display.wrapper.ownerDocument, "mousemove", move);
-            on(display.wrapper.ownerDocument, "mouseup", up);
-          }
-          function bidiSimplify(cm, range3) {
-            var anchor = range3.anchor;
-            var head = range3.head;
-            var anchorLine = getLine2(cm.doc, anchor.line);
-            if (cmp(anchor, head) == 0 && anchor.sticky == head.sticky) {
-              return range3;
-            }
-            var order2 = getOrder(anchorLine);
-            if (!order2) {
-              return range3;
-            }
-            var index = getBidiPartAt(order2, anchor.ch, anchor.sticky),
-              part2 = order2[index];
-            if (part2.from != anchor.ch && part2.to != anchor.ch) {
-              return range3;
-            }
-            var boundary =
-              index + ((part2.from == anchor.ch) == (part2.level != 1) ? 0 : 1);
-            if (boundary == 0 || boundary == order2.length) {
-              return range3;
-            }
-            var leftSide;
-            if (head.line != anchor.line) {
-              leftSide =
-                (head.line - anchor.line) *
-                  (cm.doc.direction == "ltr" ? 1 : -1) >
-                0;
-            } else {
-              var headIndex = getBidiPartAt(order2, head.ch, head.sticky);
-              var dir =
-                headIndex - index ||
-                (head.ch - anchor.ch) * (part2.level == 1 ? -1 : 1);
-              if (headIndex == boundary - 1 || headIndex == boundary) {
-                leftSide = dir < 0;
-              } else {
-                leftSide = dir > 0;
-              }
-            }
-            var usePart = order2[boundary + (leftSide ? -1 : 0)];
-            var from = leftSide == (usePart.level == 1);
-            var ch2 = from ? usePart.from : usePart.to,
-              sticky = from ? "after" : "before";
-            return anchor.ch == ch2 && anchor.sticky == sticky
-              ? range3
-              : new Range2(new Pos(anchor.line, ch2, sticky), head);
-          }
-          function gutterEvent(cm, e, type2, prevent) {
-            var mX, mY;
-            if (e.touches) {
-              mX = e.touches[0].clientX;
-              mY = e.touches[0].clientY;
-            } else {
-              try {
-                mX = e.clientX;
-                mY = e.clientY;
-              } catch (e$1) {
-                return false;
-              }
-            }
-            if (
-              mX >= Math.floor(cm.display.gutters.getBoundingClientRect().right)
-            ) {
-              return false;
-            }
-            if (prevent) {
-              e_preventDefault(e);
-            }
-            var display = cm.display;
-            var lineBox = display.lineDiv.getBoundingClientRect();
-            if (mY > lineBox.bottom || !hasHandler(cm, type2)) {
-              return e_defaultPrevented(e);
-            }
-            mY -= lineBox.top - display.viewOffset;
-            for (var i2 = 0; i2 < cm.display.gutterSpecs.length; ++i2) {
-              var g = display.gutters.childNodes[i2];
-              if (g && g.getBoundingClientRect().right >= mX) {
-                var line = lineAtHeight(cm.doc, mY);
-                var gutter = cm.display.gutterSpecs[i2];
-                signal(cm, type2, cm, line, gutter.className, e);
-                return e_defaultPrevented(e);
-              }
-            }
-          }
-          function clickInGutter(cm, e) {
-            return gutterEvent(cm, e, "gutterClick", true);
-          }
-          function onContextMenu(cm, e) {
-            if (eventInWidget(cm.display, e) || contextMenuInGutter(cm, e)) {
-              return;
-            }
-            if (signalDOMEvent(cm, e, "contextmenu")) {
-              return;
-            }
-            if (!captureRightClick) {
-              cm.display.input.onContextMenu(e);
-            }
-          }
-          function contextMenuInGutter(cm, e) {
-            if (!hasHandler(cm, "gutterContextMenu")) {
-              return false;
-            }
-            return gutterEvent(cm, e, "gutterContextMenu", false);
-          }
-          function themeChanged(cm) {
-            cm.display.wrapper.className =
-              cm.display.wrapper.className.replace(/\s*cm-s-\S+/g, "") +
-              cm.options.theme.replace(/(^|\s)\s*/g, " cm-s-");
-            clearCaches(cm);
-          }
-          var Init = {
-            toString: function () {
-              return "CodeMirror.Init";
-            },
-          };
-          var defaults2 = {};
-          var optionHandlers = {};
-          function defineOptions(CodeMirror2) {
-            var optionHandlers2 = CodeMirror2.optionHandlers;
-            function option(name2, deflt, handle, notOnInit) {
-              CodeMirror2.defaults[name2] = deflt;
-              if (handle) {
-                optionHandlers2[name2] = notOnInit
-                  ? function (cm, val, old) {
-                      if (old != Init) {
-                        handle(cm, val, old);
-                      }
-                    }
-                  : handle;
-              }
-            }
-            CodeMirror2.defineOption = option;
-            CodeMirror2.Init = Init;
-            option(
-              "value",
-              "",
-              function (cm, val) {
-                return cm.setValue(val);
-              },
-              true
-            );
-            option(
-              "mode",
-              null,
-              function (cm, val) {
-                cm.doc.modeOption = val;
-                loadMode(cm);
-              },
-              true
-            );
-            option("indentUnit", 2, loadMode, true);
-            option("indentWithTabs", false);
-            option("smartIndent", true);
-            option(
-              "tabSize",
-              4,
-              function (cm) {
-                resetModeState(cm);
-                clearCaches(cm);
-                regChange(cm);
-              },
-              true
-            );
-            option("lineSeparator", null, function (cm, val) {
-              cm.doc.lineSep = val;
-              if (!val) {
-                return;
-              }
-              var newBreaks = [],
-                lineNo2 = cm.doc.first;
-              cm.doc.iter(function (line) {
-                for (var pos = 0; ; ) {
-                  var found = line.text.indexOf(val, pos);
-                  if (found == -1) {
-                    break;
-                  }
-                  pos = found + val.length;
-                  newBreaks.push(Pos(lineNo2, found));
-                }
-                lineNo2++;
-              });
-              for (var i2 = newBreaks.length - 1; i2 >= 0; i2--) {
-                replaceRange(
-                  cm.doc,
-                  val,
-                  newBreaks[i2],
-                  Pos(newBreaks[i2].line, newBreaks[i2].ch + val.length)
-                );
-              }
-            });
-            option(
-              "specialChars",
-              /[\u0000-\u001f\u007f-\u009f\u00ad\u061c\u200b\u200e\u200f\u2028\u2029\ufeff\ufff9-\ufffc]/g,
-              function (cm, val, old) {
-                cm.state.specialChars = new RegExp(
-                  val.source + (val.test("	") ? "" : "|	"),
-                  "g"
-                );
-                if (old != Init) {
-                  cm.refresh();
-                }
-              }
-            );
-            option(
-              "specialCharPlaceholder",
-              defaultSpecialCharPlaceholder,
-              function (cm) {
-                return cm.refresh();
-              },
-              true
-            );
-            option("electricChars", true);
-            option(
-              "inputStyle",
-              mobile ? "contenteditable" : "textarea",
-              function () {
-                throw new Error(
-                  "inputStyle can not (yet) be changed in a running editor"
-                );
-              },
-              true
-            );
-            option(
-              "spellcheck",
-              false,
-              function (cm, val) {
-                return (cm.getInputField().spellcheck = val);
-              },
-              true
-            );
-            option(
-              "autocorrect",
-              false,
-              function (cm, val) {
-                return (cm.getInputField().autocorrect = val);
-              },
-              true
-            );
-            option(
-              "autocapitalize",
-              false,
-              function (cm, val) {
-                return (cm.getInputField().autocapitalize = val);
-              },
-              true
-            );
-            option("rtlMoveVisually", !windows);
-            option("wholeLineUpdateBefore", true);
-            option(
-              "theme",
-              "default",
-              function (cm) {
-                themeChanged(cm);
-                updateGutters(cm);
-              },
-              true
-            );
-            option("keyMap", "default", function (cm, val, old) {
-              var next = getKeyMap(val);
-              var prev = old != Init && getKeyMap(old);
-              if (prev && prev.detach) {
-                prev.detach(cm, next);
-              }
-              if (next.attach) {
-                next.attach(cm, prev || null);
-              }
-            });
-            option("extraKeys", null);
-            option("configureMouse", null);
-            option("lineWrapping", false, wrappingChanged, true);
-            option(
-              "gutters",
-              [],
-              function (cm, val) {
-                cm.display.gutterSpecs = getGutters(
-                  val,
-                  cm.options.lineNumbers
-                );
-                updateGutters(cm);
-              },
-              true
-            );
-            option(
-              "fixedGutter",
-              true,
-              function (cm, val) {
-                cm.display.gutters.style.left = val
-                  ? compensateForHScroll(cm.display) + "px"
-                  : "0";
-                cm.refresh();
-              },
-              true
-            );
-            option(
-              "coverGutterNextToScrollbar",
-              false,
-              function (cm) {
-                return updateScrollbars(cm);
-              },
-              true
-            );
-            option(
-              "scrollbarStyle",
-              "native",
-              function (cm) {
-                initScrollbars(cm);
-                updateScrollbars(cm);
-                cm.display.scrollbars.setScrollTop(cm.doc.scrollTop);
-                cm.display.scrollbars.setScrollLeft(cm.doc.scrollLeft);
-              },
-              true
-            );
-            option(
-              "lineNumbers",
-              false,
-              function (cm, val) {
-                cm.display.gutterSpecs = getGutters(cm.options.gutters, val);
-                updateGutters(cm);
-              },
-              true
-            );
-            option("firstLineNumber", 1, updateGutters, true);
-            option(
-              "lineNumberFormatter",
-              function (integer2) {
-                return integer2;
-              },
-              updateGutters,
-              true
-            );
-            option("showCursorWhenSelecting", false, updateSelection, true);
-            option("resetSelectionOnContextMenu", true);
-            option("lineWiseCopyCut", true);
-            option("pasteLinesPerSelection", true);
-            option("selectionsMayTouch", false);
-            option("readOnly", false, function (cm, val) {
-              if (val == "nocursor") {
-                onBlur(cm);
-                cm.display.input.blur();
-              }
-              cm.display.input.readOnlyChanged(val);
-            });
-            option("screenReaderLabel", null, function (cm, val) {
-              val = val === "" ? null : val;
-              cm.display.input.screenReaderLabelChanged(val);
-            });
-            option(
-              "disableInput",
-              false,
-              function (cm, val) {
-                if (!val) {
-                  cm.display.input.reset();
-                }
-              },
-              true
-            );
-            option("dragDrop", true, dragDropChanged);
-            option("allowDropFileTypes", null);
-            option("cursorBlinkRate", 530);
-            option("cursorScrollMargin", 0);
-            option("cursorHeight", 1, updateSelection, true);
-            option("singleCursorHeightPerLine", true, updateSelection, true);
-            option("workTime", 100);
-            option("workDelay", 100);
-            option("flattenSpans", true, resetModeState, true);
-            option("addModeClass", false, resetModeState, true);
-            option("pollInterval", 100);
-            option("undoDepth", 200, function (cm, val) {
-              return (cm.doc.history.undoDepth = val);
-            });
-            option("historyEventDelay", 1250);
-            option(
-              "viewportMargin",
-              10,
-              function (cm) {
-                return cm.refresh();
-              },
-              true
-            );
-            option("maxHighlightLength", 1e4, resetModeState, true);
-            option("moveInputWithCursor", true, function (cm, val) {
-              if (!val) {
-                cm.display.input.resetPosition();
-              }
-            });
-            option("tabindex", null, function (cm, val) {
-              return (cm.display.input.getField().tabIndex = val || "");
-            });
-            option("autofocus", null);
-            option(
-              "direction",
-              "ltr",
-              function (cm, val) {
-                return cm.doc.setDirection(val);
-              },
-              true
-            );
-            option("phrases", null);
-          }
-          function dragDropChanged(cm, value, old) {
-            var wasOn = old && old != Init;
-            if (!value != !wasOn) {
-              var funcs = cm.display.dragFunctions;
-              var toggle = value ? on : off;
-              toggle(cm.display.scroller, "dragstart", funcs.start);
-              toggle(cm.display.scroller, "dragenter", funcs.enter);
-              toggle(cm.display.scroller, "dragover", funcs.over);
-              toggle(cm.display.scroller, "dragleave", funcs.leave);
-              toggle(cm.display.scroller, "drop", funcs.drop);
-            }
-          }
-          function wrappingChanged(cm) {
-            if (cm.options.lineWrapping) {
-              addClass(cm.display.wrapper, "CodeMirror-wrap");
-              cm.display.sizer.style.minWidth = "";
-              cm.display.sizerWidth = null;
-            } else {
-              rmClass(cm.display.wrapper, "CodeMirror-wrap");
-              findMaxLine(cm);
-            }
-            estimateLineHeights(cm);
-            regChange(cm);
-            clearCaches(cm);
-            setTimeout(function () {
-              return updateScrollbars(cm);
-            }, 100);
-          }
-          function CodeMirror(place, options) {
-            var this$1$1 = this;
-            if (!(this instanceof CodeMirror)) {
-              return new CodeMirror(place, options);
-            }
-            this.options = options = options ? copyObj(options) : {};
-            copyObj(defaults2, options, false);
-            var doc = options.value;
-            if (typeof doc == "string") {
-              doc = new Doc(
-                doc,
-                options.mode,
-                null,
-                options.lineSeparator,
-                options.direction
-              );
-            } else if (options.mode) {
-              doc.modeOption = options.mode;
-            }
-            this.doc = doc;
-            var input = new CodeMirror.inputStyles[options.inputStyle](this);
-            var display = (this.display = new Display(
-              place,
-              doc,
-              input,
-              options
-            ));
-            display.wrapper.CodeMirror = this;
-            themeChanged(this);
-            if (options.lineWrapping) {
-              this.display.wrapper.className += " CodeMirror-wrap";
-            }
-            initScrollbars(this);
-            this.state = {
-              keyMaps: [],
-              overlays: [],
-              modeGen: 0,
-              overwrite: false,
-              delayingBlurEvent: false,
-              focused: false,
-              suppressEdits: false,
-              pasteIncoming: -1,
-              cutIncoming: -1,
-              selectingText: false,
-              draggingText: false,
-              highlight: new Delayed(),
-              keySeq: null,
-              specialChars: null,
-            };
-            if (options.autofocus && !mobile) {
-              display.input.focus();
-            }
-            if (ie2 && ie_version < 11) {
-              setTimeout(function () {
-                return this$1$1.display.input.reset(true);
-              }, 20);
-            }
-            registerEventHandlers(this);
-            ensureGlobalHandlers();
-            startOperation(this);
-            this.curOp.forceUpdate = true;
-            attachDoc(this, doc);
-            if ((options.autofocus && !mobile) || this.hasFocus()) {
-              setTimeout(function () {
-                if (this$1$1.hasFocus() && !this$1$1.state.focused) {
-                  onFocus(this$1$1);
-                }
-              }, 20);
-            } else {
-              onBlur(this);
-            }
-            for (var opt2 in optionHandlers) {
-              if (optionHandlers.hasOwnProperty(opt2)) {
-                optionHandlers[opt2](this, options[opt2], Init);
-              }
-            }
-            maybeUpdateLineNumberWidth(this);
-            if (options.finishInit) {
-              options.finishInit(this);
-            }
-            for (var i2 = 0; i2 < initHooks.length; ++i2) {
-              initHooks[i2](this);
-            }
-            endOperation(this);
-            if (
-              webkit &&
-              options.lineWrapping &&
-              getComputedStyle(display.lineDiv).textRendering ==
-                "optimizelegibility"
-            ) {
-              display.lineDiv.style.textRendering = "auto";
-            }
-          }
-          CodeMirror.defaults = defaults2;
-          CodeMirror.optionHandlers = optionHandlers;
-          function registerEventHandlers(cm) {
-            var d = cm.display;
-            on(d.scroller, "mousedown", operation(cm, onMouseDown));
-            if (ie2 && ie_version < 11) {
-              on(
-                d.scroller,
-                "dblclick",
-                operation(cm, function (e) {
-                  if (signalDOMEvent(cm, e)) {
-                    return;
-                  }
-                  var pos = posFromMouse(cm, e);
-                  if (
-                    !pos ||
-                    clickInGutter(cm, e) ||
-                    eventInWidget(cm.display, e)
-                  ) {
-                    return;
-                  }
-                  e_preventDefault(e);
-                  var word2 = cm.findWordAt(pos);
-                  extendSelection(cm.doc, word2.anchor, word2.head);
-                })
-              );
-            } else {
-              on(d.scroller, "dblclick", function (e) {
-                return signalDOMEvent(cm, e) || e_preventDefault(e);
-              });
-            }
-            on(d.scroller, "contextmenu", function (e) {
-              return onContextMenu(cm, e);
-            });
-            on(d.input.getField(), "contextmenu", function (e) {
-              if (!d.scroller.contains(e.target)) {
-                onContextMenu(cm, e);
-              }
-            });
-            var touchFinished,
-              prevTouch = { end: 0 };
-            function finishTouch() {
-              if (d.activeTouch) {
-                touchFinished = setTimeout(function () {
-                  return (d.activeTouch = null);
-                }, 1e3);
-                prevTouch = d.activeTouch;
-                prevTouch.end = +new Date();
-              }
-            }
-            function isMouseLikeTouchEvent(e) {
-              if (e.touches.length != 1) {
-                return false;
-              }
-              var touch = e.touches[0];
-              return touch.radiusX <= 1 && touch.radiusY <= 1;
-            }
-            function farAway(touch, other) {
-              if (other.left == null) {
-                return true;
-              }
-              var dx = other.left - touch.left,
-                dy = other.top - touch.top;
-              return dx * dx + dy * dy > 20 * 20;
-            }
-            on(d.scroller, "touchstart", function (e) {
-              if (
-                !signalDOMEvent(cm, e) &&
-                !isMouseLikeTouchEvent(e) &&
-                !clickInGutter(cm, e)
-              ) {
-                d.input.ensurePolled();
-                clearTimeout(touchFinished);
-                var now = +new Date();
-                d.activeTouch = {
-                  start: now,
-                  moved: false,
-                  prev: now - prevTouch.end <= 300 ? prevTouch : null,
-                };
-                if (e.touches.length == 1) {
-                  d.activeTouch.left = e.touches[0].pageX;
-                  d.activeTouch.top = e.touches[0].pageY;
-                }
-              }
-            });
-            on(d.scroller, "touchmove", function () {
-              if (d.activeTouch) {
-                d.activeTouch.moved = true;
-              }
-            });
-            on(d.scroller, "touchend", function (e) {
-              var touch = d.activeTouch;
-              if (
-                touch &&
-                !eventInWidget(d, e) &&
-                touch.left != null &&
-                !touch.moved &&
-                new Date() - touch.start < 300
-              ) {
-                var pos = cm.coordsChar(d.activeTouch, "page"),
-                  range3;
-                if (!touch.prev || farAway(touch, touch.prev)) {
-                  range3 = new Range2(pos, pos);
-                } else if (
-                  !touch.prev.prev ||
-                  farAway(touch, touch.prev.prev)
-                ) {
-                  range3 = cm.findWordAt(pos);
-                } else {
-                  range3 = new Range2(
-                    Pos(pos.line, 0),
-                    clipPos(cm.doc, Pos(pos.line + 1, 0))
-                  );
-                }
-                cm.setSelection(range3.anchor, range3.head);
-                cm.focus();
-                e_preventDefault(e);
-              }
-              finishTouch();
-            });
-            on(d.scroller, "touchcancel", finishTouch);
-            on(d.scroller, "scroll", function () {
-              if (d.scroller.clientHeight) {
-                updateScrollTop(cm, d.scroller.scrollTop);
-                setScrollLeft(cm, d.scroller.scrollLeft, true);
-                signal(cm, "scroll", cm);
-              }
-            });
-            on(d.scroller, "mousewheel", function (e) {
-              return onScrollWheel(cm, e);
-            });
-            on(d.scroller, "DOMMouseScroll", function (e) {
-              return onScrollWheel(cm, e);
-            });
-            on(d.wrapper, "scroll", function () {
-              return (d.wrapper.scrollTop = d.wrapper.scrollLeft = 0);
-            });
-            d.dragFunctions = {
-              enter: function (e) {
-                if (!signalDOMEvent(cm, e)) {
-                  e_stop(e);
-                }
-              },
-              over: function (e) {
-                if (!signalDOMEvent(cm, e)) {
-                  onDragOver(cm, e);
-                  e_stop(e);
-                }
-              },
-              start: function (e) {
-                return onDragStart(cm, e);
-              },
-              drop: operation(cm, onDrop),
-              leave: function (e) {
-                if (!signalDOMEvent(cm, e)) {
-                  clearDragCursor(cm);
-                }
-              },
-            };
-            var inp = d.input.getField();
-            on(inp, "keyup", function (e) {
-              return onKeyUp.call(cm, e);
-            });
-            on(inp, "keydown", operation(cm, onKeyDown2));
-            on(inp, "keypress", operation(cm, onKeyPress));
-            on(inp, "focus", function (e) {
-              return onFocus(cm, e);
-            });
-            on(inp, "blur", function (e) {
-              return onBlur(cm, e);
-            });
-          }
-          var initHooks = [];
-          CodeMirror.defineInitHook = function (f) {
-            return initHooks.push(f);
-          };
-          function indentLine(cm, n2, how, aggressive) {
-            var doc = cm.doc,
-              state;
-            if (how == null) {
-              how = "add";
-            }
-            if (how == "smart") {
-              if (!doc.mode.indent) {
-                how = "prev";
-              } else {
-                state = getContextBefore(cm, n2).state;
-              }
-            }
-            var tabSize = cm.options.tabSize;
-            var line = getLine2(doc, n2),
-              curSpace = countColumn(line.text, null, tabSize);
-            if (line.stateAfter) {
-              line.stateAfter = null;
-            }
-            var curSpaceString = line.text.match(/^\s*/)[0],
-              indentation;
-            if (!aggressive && !/\S/.test(line.text)) {
-              indentation = 0;
-              how = "not";
-            } else if (how == "smart") {
-              indentation = doc.mode.indent(
-                state,
-                line.text.slice(curSpaceString.length),
-                line.text
-              );
-              if (indentation == Pass || indentation > 150) {
-                if (!aggressive) {
-                  return;
-                }
-                how = "prev";
-              }
-            }
-            if (how == "prev") {
-              if (n2 > doc.first) {
-                indentation = countColumn(
-                  getLine2(doc, n2 - 1).text,
-                  null,
-                  tabSize
-                );
-              } else {
-                indentation = 0;
-              }
-            } else if (how == "add") {
-              indentation = curSpace + cm.options.indentUnit;
-            } else if (how == "subtract") {
-              indentation = curSpace - cm.options.indentUnit;
-            } else if (typeof how == "number") {
-              indentation = curSpace + how;
-            }
-            indentation = Math.max(0, indentation);
-            var indentString = "",
-              pos = 0;
-            if (cm.options.indentWithTabs) {
-              for (var i2 = Math.floor(indentation / tabSize); i2; --i2) {
-                pos += tabSize;
-                indentString += "	";
-              }
-            }
-            if (pos < indentation) {
-              indentString += spaceStr(indentation - pos);
-            }
-            if (indentString != curSpaceString) {
-              replaceRange(
-                doc,
-                indentString,
-                Pos(n2, 0),
-                Pos(n2, curSpaceString.length),
-                "+input"
-              );
-              line.stateAfter = null;
-              return true;
-            } else {
-              for (var i$12 = 0; i$12 < doc.sel.ranges.length; i$12++) {
-                var range3 = doc.sel.ranges[i$12];
-                if (
-                  range3.head.line == n2 &&
-                  range3.head.ch < curSpaceString.length
-                ) {
-                  var pos$1 = Pos(n2, curSpaceString.length);
-                  replaceOneSelection(doc, i$12, new Range2(pos$1, pos$1));
-                  break;
-                }
-              }
-            }
-          }
-          var lastCopied = null;
-          function setLastCopied(newLastCopied) {
-            lastCopied = newLastCopied;
-          }
-          function applyTextInput(cm, inserted, deleted, sel, origin) {
-            var doc = cm.doc;
-            cm.display.shift = false;
-            if (!sel) {
-              sel = doc.sel;
-            }
-            var recent = +new Date() - 200;
-            var paste = origin == "paste" || cm.state.pasteIncoming > recent;
-            var textLines = splitLinesAuto(inserted),
-              multiPaste = null;
-            if (paste && sel.ranges.length > 1) {
-              if (lastCopied && lastCopied.text.join("\n") == inserted) {
-                if (sel.ranges.length % lastCopied.text.length == 0) {
-                  multiPaste = [];
-                  for (var i2 = 0; i2 < lastCopied.text.length; i2++) {
-                    multiPaste.push(doc.splitLines(lastCopied.text[i2]));
-                  }
-                }
-              } else if (
-                textLines.length == sel.ranges.length &&
-                cm.options.pasteLinesPerSelection
-              ) {
-                multiPaste = map2(textLines, function (l2) {
-                  return [l2];
-                });
-              }
-            }
-            var updateInput = cm.curOp.updateInput;
-            for (var i$12 = sel.ranges.length - 1; i$12 >= 0; i$12--) {
-              var range3 = sel.ranges[i$12];
-              var from = range3.from(),
-                to = range3.to();
-              if (range3.empty()) {
-                if (deleted && deleted > 0) {
-                  from = Pos(from.line, from.ch - deleted);
-                } else if (cm.state.overwrite && !paste) {
-                  to = Pos(
-                    to.line,
-                    Math.min(
-                      getLine2(doc, to.line).text.length,
-                      to.ch + lst(textLines).length
-                    )
-                  );
-                } else if (
-                  paste &&
-                  lastCopied &&
-                  lastCopied.lineWise &&
-                  lastCopied.text.join("\n") == textLines.join("\n")
-                ) {
-                  from = to = Pos(from.line, 0);
-                }
-              }
-              var changeEvent = {
-                from,
-                to,
-                text: multiPaste
-                  ? multiPaste[i$12 % multiPaste.length]
-                  : textLines,
-                origin:
-                  origin ||
-                  (paste
-                    ? "paste"
-                    : cm.state.cutIncoming > recent
-                    ? "cut"
-                    : "+input"),
-              };
-              makeChange(cm.doc, changeEvent);
-              signalLater(cm, "inputRead", cm, changeEvent);
-            }
-            if (inserted && !paste) {
-              triggerElectric(cm, inserted);
-            }
-            ensureCursorVisible(cm);
-            if (cm.curOp.updateInput < 2) {
-              cm.curOp.updateInput = updateInput;
-            }
-            cm.curOp.typing = true;
-            cm.state.pasteIncoming = cm.state.cutIncoming = -1;
-          }
-          function handlePaste(e, cm) {
-            var pasted = e.clipboardData && e.clipboardData.getData("Text");
-            if (pasted) {
-              e.preventDefault();
-              if (!cm.isReadOnly() && !cm.options.disableInput) {
-                runInOp(cm, function () {
-                  return applyTextInput(cm, pasted, 0, null, "paste");
-                });
-              }
-              return true;
-            }
-          }
-          function triggerElectric(cm, inserted) {
-            if (!cm.options.electricChars || !cm.options.smartIndent) {
-              return;
-            }
-            var sel = cm.doc.sel;
-            for (var i2 = sel.ranges.length - 1; i2 >= 0; i2--) {
-              var range3 = sel.ranges[i2];
-              if (
-                range3.head.ch > 100 ||
-                (i2 && sel.ranges[i2 - 1].head.line == range3.head.line)
-              ) {
-                continue;
-              }
-              var mode2 = cm.getModeAt(range3.head);
-              var indented = false;
-              if (mode2.electricChars) {
-                for (var j = 0; j < mode2.electricChars.length; j++) {
-                  if (inserted.indexOf(mode2.electricChars.charAt(j)) > -1) {
-                    indented = indentLine(cm, range3.head.line, "smart");
-                    break;
-                  }
-                }
-              } else if (mode2.electricInput) {
-                if (
-                  mode2.electricInput.test(
-                    getLine2(cm.doc, range3.head.line).text.slice(
-                      0,
-                      range3.head.ch
-                    )
-                  )
-                ) {
-                  indented = indentLine(cm, range3.head.line, "smart");
-                }
-              }
-              if (indented) {
-                signalLater(cm, "electricInput", cm, range3.head.line);
-              }
-            }
-          }
-          function copyableRanges(cm) {
-            var text3 = [],
-              ranges = [];
-            for (var i2 = 0; i2 < cm.doc.sel.ranges.length; i2++) {
-              var line = cm.doc.sel.ranges[i2].head.line;
-              var lineRange = { anchor: Pos(line, 0), head: Pos(line + 1, 0) };
-              ranges.push(lineRange);
-              text3.push(cm.getRange(lineRange.anchor, lineRange.head));
-            }
-            return { text: text3, ranges };
-          }
-          function disableBrowserMagic(
-            field,
-            spellcheck,
-            autocorrect,
-            autocapitalize
-          ) {
-            field.setAttribute("autocorrect", autocorrect ? "" : "off");
-            field.setAttribute("autocapitalize", autocapitalize ? "" : "off");
-            field.setAttribute("spellcheck", !!spellcheck);
-          }
-          function hiddenTextarea() {
-            var te = elt(
-              "textarea",
-              null,
-              null,
-              "position: absolute; bottom: -1em; padding: 0; width: 1px; height: 1em; min-height: 1em; outline: none"
-            );
-            var div2 = elt(
-              "div",
-              [te],
-              null,
-              "overflow: hidden; position: relative; width: 3px; height: 0px;"
-            );
-            if (webkit) {
-              te.style.width = "1000px";
-            } else {
-              te.setAttribute("wrap", "off");
-            }
-            if (ios) {
-              te.style.border = "1px solid black";
-            }
-            disableBrowserMagic(te);
-            return div2;
-          }
-          function addEditorMethods(CodeMirror2) {
-            var optionHandlers2 = CodeMirror2.optionHandlers;
-            var helpers2 = (CodeMirror2.helpers = {});
-            CodeMirror2.prototype = {
-              constructor: CodeMirror2,
-              focus: function () {
-                window.focus();
-                this.display.input.focus();
-              },
-              setOption: function (option, value) {
-                var options = this.options,
-                  old = options[option];
-                if (options[option] == value && option != "mode") {
-                  return;
-                }
-                options[option] = value;
-                if (optionHandlers2.hasOwnProperty(option)) {
-                  operation(this, optionHandlers2[option])(this, value, old);
-                }
-                signal(this, "optionChange", this, option);
-              },
-              getOption: function (option) {
-                return this.options[option];
-              },
-              getDoc: function () {
-                return this.doc;
-              },
-              addKeyMap: function (map3, bottom2) {
-                this.state.keyMaps[bottom2 ? "push" : "unshift"](
-                  getKeyMap(map3)
-                );
-              },
-              removeKeyMap: function (map3) {
-                var maps = this.state.keyMaps;
-                for (var i2 = 0; i2 < maps.length; ++i2) {
-                  if (maps[i2] == map3 || maps[i2].name == map3) {
-                    maps.splice(i2, 1);
-                    return true;
-                  }
-                }
-              },
-              addOverlay: methodOp(function (spec, options) {
-                var mode2 = spec.token
-                  ? spec
-                  : CodeMirror2.getMode(this.options, spec);
-                if (mode2.startState) {
-                  throw new Error("Overlays may not be stateful.");
-                }
-                insertSorted(
-                  this.state.overlays,
-                  {
-                    mode: mode2,
-                    modeSpec: spec,
-                    opaque: options && options.opaque,
-                    priority: (options && options.priority) || 0,
-                  },
-                  function (overlay) {
-                    return overlay.priority;
-                  }
-                );
-                this.state.modeGen++;
-                regChange(this);
-              }),
-              removeOverlay: methodOp(function (spec) {
-                var overlays = this.state.overlays;
-                for (var i2 = 0; i2 < overlays.length; ++i2) {
-                  var cur = overlays[i2].modeSpec;
-                  if (
-                    cur == spec ||
-                    (typeof spec == "string" && cur.name == spec)
-                  ) {
-                    overlays.splice(i2, 1);
-                    this.state.modeGen++;
-                    regChange(this);
-                    return;
-                  }
-                }
-              }),
-              indentLine: methodOp(function (n2, dir, aggressive) {
-                if (typeof dir != "string" && typeof dir != "number") {
-                  if (dir == null) {
-                    dir = this.options.smartIndent ? "smart" : "prev";
-                  } else {
-                    dir = dir ? "add" : "subtract";
-                  }
-                }
-                if (isLine(this.doc, n2)) {
-                  indentLine(this, n2, dir, aggressive);
-                }
-              }),
-              indentSelection: methodOp(function (how) {
-                var ranges = this.doc.sel.ranges,
-                  end2 = -1;
-                for (var i2 = 0; i2 < ranges.length; i2++) {
-                  var range3 = ranges[i2];
-                  if (!range3.empty()) {
-                    var from = range3.from(),
-                      to = range3.to();
-                    var start2 = Math.max(end2, from.line);
-                    end2 =
-                      Math.min(this.lastLine(), to.line - (to.ch ? 0 : 1)) + 1;
-                    for (var j = start2; j < end2; ++j) {
-                      indentLine(this, j, how);
-                    }
-                    var newRanges = this.doc.sel.ranges;
-                    if (
-                      from.ch == 0 &&
-                      ranges.length == newRanges.length &&
-                      newRanges[i2].from().ch > 0
-                    ) {
-                      replaceOneSelection(
-                        this.doc,
-                        i2,
-                        new Range2(from, newRanges[i2].to()),
-                        sel_dontScroll
-                      );
-                    }
-                  } else if (range3.head.line > end2) {
-                    indentLine(this, range3.head.line, how, true);
-                    end2 = range3.head.line;
-                    if (i2 == this.doc.sel.primIndex) {
-                      ensureCursorVisible(this);
-                    }
-                  }
-                }
-              }),
-              getTokenAt: function (pos, precise) {
-                return takeToken(this, pos, precise);
-              },
-              getLineTokens: function (line, precise) {
-                return takeToken(this, Pos(line), precise, true);
-              },
-              getTokenTypeAt: function (pos) {
-                pos = clipPos(this.doc, pos);
-                var styles2 = getLineStyles(this, getLine2(this.doc, pos.line));
-                var before = 0,
-                  after = (styles2.length - 1) / 2,
-                  ch2 = pos.ch;
-                var type2;
-                if (ch2 == 0) {
-                  type2 = styles2[2];
-                } else {
-                  for (;;) {
-                    var mid2 = (before + after) >> 1;
-                    if ((mid2 ? styles2[mid2 * 2 - 1] : 0) >= ch2) {
-                      after = mid2;
-                    } else if (styles2[mid2 * 2 + 1] < ch2) {
-                      before = mid2 + 1;
-                    } else {
-                      type2 = styles2[mid2 * 2 + 2];
-                      break;
-                    }
-                  }
-                }
-                var cut = type2 ? type2.indexOf("overlay ") : -1;
-                return cut < 0
-                  ? type2
-                  : cut == 0
-                  ? null
-                  : type2.slice(0, cut - 1);
-              },
-              getModeAt: function (pos) {
-                var mode2 = this.doc.mode;
-                if (!mode2.innerMode) {
-                  return mode2;
-                }
-                return CodeMirror2.innerMode(mode2, this.getTokenAt(pos).state)
-                  .mode;
-              },
-              getHelper: function (pos, type2) {
-                return this.getHelpers(pos, type2)[0];
-              },
-              getHelpers: function (pos, type2) {
-                var found = [];
-                if (!helpers2.hasOwnProperty(type2)) {
-                  return found;
-                }
-                var help = helpers2[type2],
-                  mode2 = this.getModeAt(pos);
-                if (typeof mode2[type2] == "string") {
-                  if (help[mode2[type2]]) {
-                    found.push(help[mode2[type2]]);
-                  }
-                } else if (mode2[type2]) {
-                  for (var i2 = 0; i2 < mode2[type2].length; i2++) {
-                    var val = help[mode2[type2][i2]];
-                    if (val) {
-                      found.push(val);
-                    }
-                  }
-                } else if (mode2.helperType && help[mode2.helperType]) {
-                  found.push(help[mode2.helperType]);
-                } else if (help[mode2.name]) {
-                  found.push(help[mode2.name]);
-                }
-                for (var i$12 = 0; i$12 < help._global.length; i$12++) {
-                  var cur = help._global[i$12];
-                  if (cur.pred(mode2, this) && indexOf(found, cur.val) == -1) {
-                    found.push(cur.val);
-                  }
-                }
-                return found;
-              },
-              getStateAfter: function (line, precise) {
-                var doc = this.doc;
-                line = clipLine(
-                  doc,
-                  line == null ? doc.first + doc.size - 1 : line
-                );
-                return getContextBefore(this, line + 1, precise).state;
-              },
-              cursorCoords: function (start2, mode2) {
-                var pos,
-                  range3 = this.doc.sel.primary();
-                if (start2 == null) {
-                  pos = range3.head;
-                } else if (typeof start2 == "object") {
-                  pos = clipPos(this.doc, start2);
-                } else {
-                  pos = start2 ? range3.from() : range3.to();
-                }
-                return cursorCoords(this, pos, mode2 || "page");
-              },
-              charCoords: function (pos, mode2) {
-                return charCoords(
-                  this,
-                  clipPos(this.doc, pos),
-                  mode2 || "page"
-                );
-              },
-              coordsChar: function (coords, mode2) {
-                coords = fromCoordSystem(this, coords, mode2 || "page");
-                return coordsChar(this, coords.left, coords.top);
-              },
-              lineAtHeight: function (height, mode2) {
-                height = fromCoordSystem(
-                  this,
-                  { top: height, left: 0 },
-                  mode2 || "page"
-                ).top;
-                return lineAtHeight(this.doc, height + this.display.viewOffset);
-              },
-              heightAtLine: function (line, mode2, includeWidgets) {
-                var end2 = false,
-                  lineObj;
-                if (typeof line == "number") {
-                  var last = this.doc.first + this.doc.size - 1;
-                  if (line < this.doc.first) {
-                    line = this.doc.first;
-                  } else if (line > last) {
-                    line = last;
-                    end2 = true;
-                  }
-                  lineObj = getLine2(this.doc, line);
-                } else {
-                  lineObj = line;
-                }
-                return (
-                  intoCoordSystem(
-                    this,
-                    lineObj,
-                    { top: 0, left: 0 },
-                    mode2 || "page",
-                    includeWidgets || end2
-                  ).top + (end2 ? this.doc.height - heightAtLine(lineObj) : 0)
-                );
-              },
-              defaultTextHeight: function () {
-                return textHeight(this.display);
-              },
-              defaultCharWidth: function () {
-                return charWidth(this.display);
-              },
-              getViewport: function () {
-                return { from: this.display.viewFrom, to: this.display.viewTo };
-              },
-              addWidget: function (pos, node, scroll, vert2, horiz) {
-                var display = this.display;
-                pos = cursorCoords(this, clipPos(this.doc, pos));
-                var top2 = pos.bottom,
-                  left = pos.left;
-                node.style.position = "absolute";
-                node.setAttribute("cm-ignore-events", "true");
-                this.display.input.setUneditable(node);
-                display.sizer.appendChild(node);
-                if (vert2 == "over") {
-                  top2 = pos.top;
-                } else if (vert2 == "above" || vert2 == "near") {
-                  var vspace = Math.max(
-                      display.wrapper.clientHeight,
-                      this.doc.height
-                    ),
-                    hspace = Math.max(
-                      display.sizer.clientWidth,
-                      display.lineSpace.clientWidth
-                    );
-                  if (
-                    (vert2 == "above" ||
-                      pos.bottom + node.offsetHeight > vspace) &&
-                    pos.top > node.offsetHeight
-                  ) {
-                    top2 = pos.top - node.offsetHeight;
-                  } else if (pos.bottom + node.offsetHeight <= vspace) {
-                    top2 = pos.bottom;
-                  }
-                  if (left + node.offsetWidth > hspace) {
-                    left = hspace - node.offsetWidth;
-                  }
-                }
-                node.style.top = top2 + "px";
-                node.style.left = node.style.right = "";
-                if (horiz == "right") {
-                  left = display.sizer.clientWidth - node.offsetWidth;
-                  node.style.right = "0px";
-                } else {
-                  if (horiz == "left") {
-                    left = 0;
-                  } else if (horiz == "middle") {
-                    left = (display.sizer.clientWidth - node.offsetWidth) / 2;
-                  }
-                  node.style.left = left + "px";
-                }
-                if (scroll) {
-                  scrollIntoView(this, {
-                    left,
-                    top: top2,
-                    right: left + node.offsetWidth,
-                    bottom: top2 + node.offsetHeight,
-                  });
-                }
-              },
-              triggerOnKeyDown: methodOp(onKeyDown2),
-              triggerOnKeyPress: methodOp(onKeyPress),
-              triggerOnKeyUp: onKeyUp,
-              triggerOnMouseDown: methodOp(onMouseDown),
-              execCommand: function (cmd) {
-                if (commands.hasOwnProperty(cmd)) {
-                  return commands[cmd].call(null, this);
-                }
-              },
-              triggerElectric: methodOp(function (text3) {
-                triggerElectric(this, text3);
-              }),
-              findPosH: function (from, amount, unit, visually) {
-                var dir = 1;
-                if (amount < 0) {
-                  dir = -1;
-                  amount = -amount;
-                }
-                var cur = clipPos(this.doc, from);
-                for (var i2 = 0; i2 < amount; ++i2) {
-                  cur = findPosH(this.doc, cur, dir, unit, visually);
-                  if (cur.hitSide) {
-                    break;
-                  }
-                }
-                return cur;
-              },
-              moveH: methodOp(function (dir, unit) {
-                var this$1$1 = this;
-                this.extendSelectionsBy(function (range3) {
-                  if (
-                    this$1$1.display.shift ||
-                    this$1$1.doc.extend ||
-                    range3.empty()
-                  ) {
-                    return findPosH(
-                      this$1$1.doc,
-                      range3.head,
-                      dir,
-                      unit,
-                      this$1$1.options.rtlMoveVisually
-                    );
-                  } else {
-                    return dir < 0 ? range3.from() : range3.to();
-                  }
-                }, sel_move);
-              }),
-              deleteH: methodOp(function (dir, unit) {
-                var sel = this.doc.sel,
-                  doc = this.doc;
-                if (sel.somethingSelected()) {
-                  doc.replaceSelection("", null, "+delete");
-                } else {
-                  deleteNearSelection(this, function (range3) {
-                    var other = findPosH(doc, range3.head, dir, unit, false);
-                    return dir < 0
-                      ? { from: other, to: range3.head }
-                      : { from: range3.head, to: other };
-                  });
-                }
-              }),
-              findPosV: function (from, amount, unit, goalColumn) {
-                var dir = 1,
-                  x2 = goalColumn;
-                if (amount < 0) {
-                  dir = -1;
-                  amount = -amount;
-                }
-                var cur = clipPos(this.doc, from);
-                for (var i2 = 0; i2 < amount; ++i2) {
-                  var coords = cursorCoords(this, cur, "div");
-                  if (x2 == null) {
-                    x2 = coords.left;
-                  } else {
-                    coords.left = x2;
-                  }
-                  cur = findPosV(this, coords, dir, unit);
-                  if (cur.hitSide) {
-                    break;
-                  }
-                }
-                return cur;
-              },
-              moveV: methodOp(function (dir, unit) {
-                var this$1$1 = this;
-                var doc = this.doc,
-                  goals = [];
-                var collapse =
-                  !this.display.shift &&
-                  !doc.extend &&
-                  doc.sel.somethingSelected();
-                doc.extendSelectionsBy(function (range3) {
-                  if (collapse) {
-                    return dir < 0 ? range3.from() : range3.to();
-                  }
-                  var headPos = cursorCoords(this$1$1, range3.head, "div");
-                  if (range3.goalColumn != null) {
-                    headPos.left = range3.goalColumn;
-                  }
-                  goals.push(headPos.left);
-                  var pos = findPosV(this$1$1, headPos, dir, unit);
-                  if (unit == "page" && range3 == doc.sel.primary()) {
-                    addToScrollTop(
-                      this$1$1,
-                      charCoords(this$1$1, pos, "div").top - headPos.top
-                    );
-                  }
-                  return pos;
-                }, sel_move);
-                if (goals.length) {
-                  for (var i2 = 0; i2 < doc.sel.ranges.length; i2++) {
-                    doc.sel.ranges[i2].goalColumn = goals[i2];
-                  }
-                }
-              }),
-              findWordAt: function (pos) {
-                var doc = this.doc,
-                  line = getLine2(doc, pos.line).text;
-                var start2 = pos.ch,
-                  end2 = pos.ch;
-                if (line) {
-                  var helper = this.getHelper(pos, "wordChars");
-                  if (
-                    (pos.sticky == "before" || end2 == line.length) &&
-                    start2
-                  ) {
-                    --start2;
-                  } else {
-                    ++end2;
-                  }
-                  var startChar = line.charAt(start2);
-                  var check2 = isWordChar(startChar, helper)
-                    ? function (ch2) {
-                        return isWordChar(ch2, helper);
-                      }
-                    : /\s/.test(startChar)
-                    ? function (ch2) {
-                        return /\s/.test(ch2);
-                      }
-                    : function (ch2) {
-                        return !/\s/.test(ch2) && !isWordChar(ch2);
-                      };
-                  while (start2 > 0 && check2(line.charAt(start2 - 1))) {
-                    --start2;
-                  }
-                  while (end2 < line.length && check2(line.charAt(end2))) {
-                    ++end2;
-                  }
-                }
-                return new Range2(Pos(pos.line, start2), Pos(pos.line, end2));
-              },
-              toggleOverwrite: function (value) {
-                if (value != null && value == this.state.overwrite) {
-                  return;
-                }
-                if ((this.state.overwrite = !this.state.overwrite)) {
-                  addClass(this.display.cursorDiv, "CodeMirror-overwrite");
-                } else {
-                  rmClass(this.display.cursorDiv, "CodeMirror-overwrite");
-                }
-                signal(this, "overwriteToggle", this, this.state.overwrite);
-              },
-              hasFocus: function () {
-                return this.display.input.getField() == activeElt();
-              },
-              isReadOnly: function () {
-                return !!(this.options.readOnly || this.doc.cantEdit);
-              },
-              scrollTo: methodOp(function (x2, y2) {
-                scrollToCoords(this, x2, y2);
-              }),
-              getScrollInfo: function () {
-                var scroller = this.display.scroller;
-                return {
-                  left: scroller.scrollLeft,
-                  top: scroller.scrollTop,
-                  height:
-                    scroller.scrollHeight -
-                    scrollGap(this) -
-                    this.display.barHeight,
-                  width:
-                    scroller.scrollWidth -
-                    scrollGap(this) -
-                    this.display.barWidth,
-                  clientHeight: displayHeight(this),
-                  clientWidth: displayWidth(this),
-                };
-              },
-              scrollIntoView: methodOp(function (range3, margin) {
-                if (range3 == null) {
-                  range3 = { from: this.doc.sel.primary().head, to: null };
-                  if (margin == null) {
-                    margin = this.options.cursorScrollMargin;
-                  }
-                } else if (typeof range3 == "number") {
-                  range3 = { from: Pos(range3, 0), to: null };
-                } else if (range3.from == null) {
-                  range3 = { from: range3, to: null };
-                }
-                if (!range3.to) {
-                  range3.to = range3.from;
-                }
-                range3.margin = margin || 0;
-                if (range3.from.line != null) {
-                  scrollToRange(this, range3);
-                } else {
-                  scrollToCoordsRange(
-                    this,
-                    range3.from,
-                    range3.to,
-                    range3.margin
-                  );
-                }
-              }),
-              setSize: methodOp(function (width, height) {
-                var this$1$1 = this;
-                var interpret = function (val) {
-                  return typeof val == "number" || /^\d+$/.test(String(val))
-                    ? val + "px"
-                    : val;
-                };
-                if (width != null) {
-                  this.display.wrapper.style.width = interpret(width);
-                }
-                if (height != null) {
-                  this.display.wrapper.style.height = interpret(height);
-                }
-                if (this.options.lineWrapping) {
-                  clearLineMeasurementCache(this);
-                }
-                var lineNo2 = this.display.viewFrom;
-                this.doc.iter(lineNo2, this.display.viewTo, function (line) {
-                  if (line.widgets) {
-                    for (var i2 = 0; i2 < line.widgets.length; i2++) {
-                      if (line.widgets[i2].noHScroll) {
-                        regLineChange(this$1$1, lineNo2, "widget");
-                        break;
-                      }
-                    }
-                  }
-                  ++lineNo2;
-                });
-                this.curOp.forceUpdate = true;
-                signal(this, "refresh", this);
-              }),
-              operation: function (f) {
-                return runInOp(this, f);
-              },
-              startOperation: function () {
-                return startOperation(this);
-              },
-              endOperation: function () {
-                return endOperation(this);
-              },
-              refresh: methodOp(function () {
-                var oldHeight = this.display.cachedTextHeight;
-                regChange(this);
-                this.curOp.forceUpdate = true;
-                clearCaches(this);
-                scrollToCoords(this, this.doc.scrollLeft, this.doc.scrollTop);
-                updateGutterSpace(this.display);
-                if (
-                  oldHeight == null ||
-                  Math.abs(oldHeight - textHeight(this.display)) > 0.5 ||
-                  this.options.lineWrapping
-                ) {
-                  estimateLineHeights(this);
-                }
-                signal(this, "refresh", this);
-              }),
-              swapDoc: methodOp(function (doc) {
-                var old = this.doc;
-                old.cm = null;
-                if (this.state.selectingText) {
-                  this.state.selectingText();
-                }
-                attachDoc(this, doc);
-                clearCaches(this);
-                this.display.input.reset();
-                scrollToCoords(this, doc.scrollLeft, doc.scrollTop);
-                this.curOp.forceScroll = true;
-                signalLater(this, "swapDoc", this, old);
-                return old;
-              }),
-              phrase: function (phraseText) {
-                var phrases = this.options.phrases;
-                return phrases &&
-                  Object.prototype.hasOwnProperty.call(phrases, phraseText)
-                  ? phrases[phraseText]
-                  : phraseText;
-              },
-              getInputField: function () {
-                return this.display.input.getField();
-              },
-              getWrapperElement: function () {
-                return this.display.wrapper;
-              },
-              getScrollerElement: function () {
-                return this.display.scroller;
-              },
-              getGutterElement: function () {
-                return this.display.gutters;
-              },
-            };
-            eventMixin(CodeMirror2);
-            CodeMirror2.registerHelper = function (type2, name2, value) {
-              if (!helpers2.hasOwnProperty(type2)) {
-                helpers2[type2] = CodeMirror2[type2] = { _global: [] };
-              }
-              helpers2[type2][name2] = value;
-            };
-            CodeMirror2.registerGlobalHelper = function (
-              type2,
-              name2,
-              predicate,
-              value
-            ) {
-              CodeMirror2.registerHelper(type2, name2, value);
-              helpers2[type2]._global.push({ pred: predicate, val: value });
-            };
-          }
-          function findPosH(doc, pos, dir, unit, visually) {
-            var oldPos = pos;
-            var origDir = dir;
-            var lineObj = getLine2(doc, pos.line);
-            var lineDir = visually && doc.direction == "rtl" ? -dir : dir;
-            function findNextLine() {
-              var l2 = pos.line + lineDir;
-              if (l2 < doc.first || l2 >= doc.first + doc.size) {
-                return false;
-              }
-              pos = new Pos(l2, pos.ch, pos.sticky);
-              return (lineObj = getLine2(doc, l2));
-            }
-            function moveOnce(boundToLine) {
-              var next;
-              if (unit == "codepoint") {
-                var ch2 = lineObj.text.charCodeAt(pos.ch + (dir > 0 ? 0 : -1));
-                if (isNaN(ch2)) {
-                  next = null;
-                } else {
-                  var astral =
-                    dir > 0
-                      ? ch2 >= 55296 && ch2 < 56320
-                      : ch2 >= 56320 && ch2 < 57343;
-                  next = new Pos(
-                    pos.line,
-                    Math.max(
-                      0,
-                      Math.min(
-                        lineObj.text.length,
-                        pos.ch + dir * (astral ? 2 : 1)
-                      )
-                    ),
-                    -dir
-                  );
-                }
-              } else if (visually) {
-                next = moveVisually(doc.cm, lineObj, pos, dir);
-              } else {
-                next = moveLogically(lineObj, pos, dir);
-              }
-              if (next == null) {
-                if (!boundToLine && findNextLine()) {
-                  pos = endOfLine(visually, doc.cm, lineObj, pos.line, lineDir);
-                } else {
-                  return false;
-                }
-              } else {
-                pos = next;
-              }
-              return true;
-            }
-            if (unit == "char" || unit == "codepoint") {
-              moveOnce();
-            } else if (unit == "column") {
-              moveOnce(true);
-            } else if (unit == "word" || unit == "group") {
-              var sawType = null,
-                group = unit == "group";
-              var helper = doc.cm && doc.cm.getHelper(pos, "wordChars");
-              for (var first = true; ; first = false) {
-                if (dir < 0 && !moveOnce(!first)) {
-                  break;
-                }
-                var cur = lineObj.text.charAt(pos.ch) || "\n";
-                var type2 = isWordChar(cur, helper)
-                  ? "w"
-                  : group && cur == "\n"
-                  ? "n"
-                  : !group || /\s/.test(cur)
-                  ? null
-                  : "p";
-                if (group && !first && !type2) {
-                  type2 = "s";
-                }
-                if (sawType && sawType != type2) {
-                  if (dir < 0) {
-                    dir = 1;
-                    moveOnce();
-                    pos.sticky = "after";
-                  }
-                  break;
-                }
-                if (type2) {
-                  sawType = type2;
-                }
-                if (dir > 0 && !moveOnce(!first)) {
-                  break;
-                }
-              }
-            }
-            var result2 = skipAtomic(doc, pos, oldPos, origDir, true);
-            if (equalCursorPos(oldPos, result2)) {
-              result2.hitSide = true;
-            }
-            return result2;
-          }
-          function findPosV(cm, pos, dir, unit) {
-            var doc = cm.doc,
-              x2 = pos.left,
-              y2;
-            if (unit == "page") {
-              var pageSize = Math.min(
-                cm.display.wrapper.clientHeight,
-                window.innerHeight || document.documentElement.clientHeight
-              );
-              var moveAmount = Math.max(
-                pageSize - 0.5 * textHeight(cm.display),
-                3
-              );
-              y2 = (dir > 0 ? pos.bottom : pos.top) + dir * moveAmount;
-            } else if (unit == "line") {
-              y2 = dir > 0 ? pos.bottom + 3 : pos.top - 3;
-            }
-            var target2;
-            for (;;) {
-              target2 = coordsChar(cm, x2, y2);
-              if (!target2.outside) {
-                break;
-              }
-              if (dir < 0 ? y2 <= 0 : y2 >= doc.height) {
-                target2.hitSide = true;
-                break;
-              }
-              y2 += dir * 5;
-            }
-            return target2;
-          }
-          var ContentEditableInput = function (cm) {
-            this.cm = cm;
-            this.lastAnchorNode =
-              this.lastAnchorOffset =
-              this.lastFocusNode =
-              this.lastFocusOffset =
-                null;
-            this.polling = new Delayed();
-            this.composing = null;
-            this.gracePeriod = false;
-            this.readDOMTimeout = null;
-          };
-          ContentEditableInput.prototype.init = function (display) {
-            var this$1$1 = this;
-            var input = this,
-              cm = input.cm;
-            var div2 = (input.div = display.lineDiv);
-            div2.contentEditable = true;
-            disableBrowserMagic(
-              div2,
-              cm.options.spellcheck,
-              cm.options.autocorrect,
-              cm.options.autocapitalize
-            );
-            function belongsToInput(e) {
-              for (var t2 = e.target; t2; t2 = t2.parentNode) {
-                if (t2 == div2) {
-                  return true;
-                }
-                if (/\bCodeMirror-(?:line)?widget\b/.test(t2.className)) {
-                  break;
-                }
-              }
-              return false;
-            }
-            on(div2, "paste", function (e) {
-              if (
-                !belongsToInput(e) ||
-                signalDOMEvent(cm, e) ||
-                handlePaste(e, cm)
-              ) {
-                return;
-              }
-              if (ie_version <= 11) {
-                setTimeout(
-                  operation(cm, function () {
-                    return this$1$1.updateFromDOM();
-                  }),
-                  20
-                );
-              }
-            });
-            on(div2, "compositionstart", function (e) {
-              this$1$1.composing = { data: e.data, done: false };
-            });
-            on(div2, "compositionupdate", function (e) {
-              if (!this$1$1.composing) {
-                this$1$1.composing = { data: e.data, done: false };
-              }
-            });
-            on(div2, "compositionend", function (e) {
-              if (this$1$1.composing) {
-                if (e.data != this$1$1.composing.data) {
-                  this$1$1.readFromDOMSoon();
-                }
-                this$1$1.composing.done = true;
-              }
-            });
-            on(div2, "touchstart", function () {
-              return input.forceCompositionEnd();
-            });
-            on(div2, "input", function () {
-              if (!this$1$1.composing) {
-                this$1$1.readFromDOMSoon();
-              }
-            });
-            function onCopyCut(e) {
-              if (!belongsToInput(e) || signalDOMEvent(cm, e)) {
-                return;
-              }
-              if (cm.somethingSelected()) {
-                setLastCopied({ lineWise: false, text: cm.getSelections() });
-                if (e.type == "cut") {
-                  cm.replaceSelection("", null, "cut");
-                }
-              } else if (!cm.options.lineWiseCopyCut) {
-                return;
-              } else {
-                var ranges = copyableRanges(cm);
-                setLastCopied({ lineWise: true, text: ranges.text });
-                if (e.type == "cut") {
-                  cm.operation(function () {
-                    cm.setSelections(ranges.ranges, 0, sel_dontScroll);
-                    cm.replaceSelection("", null, "cut");
-                  });
-                }
-              }
-              if (e.clipboardData) {
-                e.clipboardData.clearData();
-                var content = lastCopied.text.join("\n");
-                e.clipboardData.setData("Text", content);
-                if (e.clipboardData.getData("Text") == content) {
-                  e.preventDefault();
-                  return;
-                }
-              }
-              var kludge = hiddenTextarea(),
-                te = kludge.firstChild;
-              cm.display.lineSpace.insertBefore(
-                kludge,
-                cm.display.lineSpace.firstChild
-              );
-              te.value = lastCopied.text.join("\n");
-              var hadFocus = activeElt();
-              selectInput(te);
-              setTimeout(function () {
-                cm.display.lineSpace.removeChild(kludge);
-                hadFocus.focus();
-                if (hadFocus == div2) {
-                  input.showPrimarySelection();
-                }
-              }, 50);
-            }
-            on(div2, "copy", onCopyCut);
-            on(div2, "cut", onCopyCut);
-          };
-          ContentEditableInput.prototype.screenReaderLabelChanged = function (
-            label
-          ) {
-            if (label) {
-              this.div.setAttribute("aria-label", label);
-            } else {
-              this.div.removeAttribute("aria-label");
-            }
-          };
-          ContentEditableInput.prototype.prepareSelection = function () {
-            var result2 = prepareSelection(this.cm, false);
-            result2.focus = activeElt() == this.div;
-            return result2;
-          };
-          ContentEditableInput.prototype.showSelection = function (
-            info2,
-            takeFocus
-          ) {
-            if (!info2 || !this.cm.display.view.length) {
-              return;
-            }
-            if (info2.focus || takeFocus) {
-              this.showPrimarySelection();
-            }
-            this.showMultipleSelections(info2);
-          };
-          ContentEditableInput.prototype.getSelection = function () {
-            return this.cm.display.wrapper.ownerDocument.getSelection();
-          };
-          ContentEditableInput.prototype.showPrimarySelection = function () {
-            var sel = this.getSelection(),
-              cm = this.cm,
-              prim = cm.doc.sel.primary();
-            var from = prim.from(),
-              to = prim.to();
-            if (
-              cm.display.viewTo == cm.display.viewFrom ||
-              from.line >= cm.display.viewTo ||
-              to.line < cm.display.viewFrom
-            ) {
-              sel.removeAllRanges();
-              return;
-            }
-            var curAnchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);
-            var curFocus = domToPos(cm, sel.focusNode, sel.focusOffset);
-            if (
-              curAnchor &&
-              !curAnchor.bad &&
-              curFocus &&
-              !curFocus.bad &&
-              cmp(minPos(curAnchor, curFocus), from) == 0 &&
-              cmp(maxPos(curAnchor, curFocus), to) == 0
-            ) {
-              return;
-            }
-            var view = cm.display.view;
-            var start2 = (from.line >= cm.display.viewFrom &&
-              posToDOM(cm, from)) || {
-              node: view[0].measure.map[2],
-              offset: 0,
-            };
-            var end2 = to.line < cm.display.viewTo && posToDOM(cm, to);
-            if (!end2) {
-              var measure = view[view.length - 1].measure;
-              var map3 = measure.maps
-                ? measure.maps[measure.maps.length - 1]
-                : measure.map;
-              end2 = {
-                node: map3[map3.length - 1],
-                offset: map3[map3.length - 2] - map3[map3.length - 3],
-              };
-            }
-            if (!start2 || !end2) {
-              sel.removeAllRanges();
-              return;
-            }
-            var old = sel.rangeCount && sel.getRangeAt(0),
-              rng;
-            try {
-              rng = range2(start2.node, start2.offset, end2.offset, end2.node);
-            } catch (e) {}
-            if (rng) {
-              if (!gecko && cm.state.focused) {
-                sel.collapse(start2.node, start2.offset);
-                if (!rng.collapsed) {
-                  sel.removeAllRanges();
-                  sel.addRange(rng);
-                }
-              } else {
-                sel.removeAllRanges();
-                sel.addRange(rng);
-              }
-              if (old && sel.anchorNode == null) {
-                sel.addRange(old);
-              } else if (gecko) {
-                this.startGracePeriod();
-              }
-            }
-            this.rememberSelection();
-          };
-          ContentEditableInput.prototype.startGracePeriod = function () {
-            var this$1$1 = this;
-            clearTimeout(this.gracePeriod);
-            this.gracePeriod = setTimeout(function () {
-              this$1$1.gracePeriod = false;
-              if (this$1$1.selectionChanged()) {
-                this$1$1.cm.operation(function () {
-                  return (this$1$1.cm.curOp.selectionChanged = true);
-                });
-              }
-            }, 20);
-          };
-          ContentEditableInput.prototype.showMultipleSelections = function (
-            info2
-          ) {
-            removeChildrenAndAdd(this.cm.display.cursorDiv, info2.cursors);
-            removeChildrenAndAdd(this.cm.display.selectionDiv, info2.selection);
-          };
-          ContentEditableInput.prototype.rememberSelection = function () {
-            var sel = this.getSelection();
-            this.lastAnchorNode = sel.anchorNode;
-            this.lastAnchorOffset = sel.anchorOffset;
-            this.lastFocusNode = sel.focusNode;
-            this.lastFocusOffset = sel.focusOffset;
-          };
-          ContentEditableInput.prototype.selectionInEditor = function () {
-            var sel = this.getSelection();
-            if (!sel.rangeCount) {
-              return false;
-            }
-            var node = sel.getRangeAt(0).commonAncestorContainer;
-            return contains(this.div, node);
-          };
-          ContentEditableInput.prototype.focus = function () {
-            if (this.cm.options.readOnly != "nocursor") {
-              if (!this.selectionInEditor() || activeElt() != this.div) {
-                this.showSelection(this.prepareSelection(), true);
-              }
-              this.div.focus();
-            }
-          };
-          ContentEditableInput.prototype.blur = function () {
-            this.div.blur();
-          };
-          ContentEditableInput.prototype.getField = function () {
-            return this.div;
-          };
-          ContentEditableInput.prototype.supportsTouch = function () {
-            return true;
-          };
-          ContentEditableInput.prototype.receivedFocus = function () {
-            var this$1$1 = this;
-            var input = this;
-            if (this.selectionInEditor()) {
-              setTimeout(function () {
-                return this$1$1.pollSelection();
-              }, 20);
-            } else {
-              runInOp(this.cm, function () {
-                return (input.cm.curOp.selectionChanged = true);
-              });
-            }
-            function poll() {
-              if (input.cm.state.focused) {
-                input.pollSelection();
-                input.polling.set(input.cm.options.pollInterval, poll);
-              }
-            }
-            this.polling.set(this.cm.options.pollInterval, poll);
-          };
-          ContentEditableInput.prototype.selectionChanged = function () {
-            var sel = this.getSelection();
-            return (
-              sel.anchorNode != this.lastAnchorNode ||
-              sel.anchorOffset != this.lastAnchorOffset ||
-              sel.focusNode != this.lastFocusNode ||
-              sel.focusOffset != this.lastFocusOffset
-            );
-          };
-          ContentEditableInput.prototype.pollSelection = function () {
-            if (
-              this.readDOMTimeout != null ||
-              this.gracePeriod ||
-              !this.selectionChanged()
-            ) {
-              return;
-            }
-            var sel = this.getSelection(),
-              cm = this.cm;
-            if (
-              android &&
-              chrome &&
-              this.cm.display.gutterSpecs.length &&
-              isInGutter(sel.anchorNode)
-            ) {
-              this.cm.triggerOnKeyDown({
-                type: "keydown",
-                keyCode: 8,
-                preventDefault: Math.abs,
-              });
-              this.blur();
-              this.focus();
-              return;
-            }
-            if (this.composing) {
-              return;
-            }
-            this.rememberSelection();
-            var anchor = domToPos(cm, sel.anchorNode, sel.anchorOffset);
-            var head = domToPos(cm, sel.focusNode, sel.focusOffset);
-            if (anchor && head) {
-              runInOp(cm, function () {
-                setSelection(
-                  cm.doc,
-                  simpleSelection(anchor, head),
-                  sel_dontScroll
-                );
-                if (anchor.bad || head.bad) {
-                  cm.curOp.selectionChanged = true;
-                }
-              });
-            }
-          };
-          ContentEditableInput.prototype.pollContent = function () {
-            if (this.readDOMTimeout != null) {
-              clearTimeout(this.readDOMTimeout);
-              this.readDOMTimeout = null;
-            }
-            var cm = this.cm,
-              display = cm.display,
-              sel = cm.doc.sel.primary();
-            var from = sel.from(),
-              to = sel.to();
-            if (from.ch == 0 && from.line > cm.firstLine()) {
-              from = Pos(from.line - 1, getLine2(cm.doc, from.line - 1).length);
-            }
-            if (
-              to.ch == getLine2(cm.doc, to.line).text.length &&
-              to.line < cm.lastLine()
-            ) {
-              to = Pos(to.line + 1, 0);
-            }
-            if (from.line < display.viewFrom || to.line > display.viewTo - 1) {
-              return false;
-            }
-            var fromIndex, fromLine, fromNode;
-            if (
-              from.line == display.viewFrom ||
-              (fromIndex = findViewIndex(cm, from.line)) == 0
-            ) {
-              fromLine = lineNo(display.view[0].line);
-              fromNode = display.view[0].node;
-            } else {
-              fromLine = lineNo(display.view[fromIndex].line);
-              fromNode = display.view[fromIndex - 1].node.nextSibling;
-            }
-            var toIndex = findViewIndex(cm, to.line);
-            var toLine, toNode;
-            if (toIndex == display.view.length - 1) {
-              toLine = display.viewTo - 1;
-              toNode = display.lineDiv.lastChild;
-            } else {
-              toLine = lineNo(display.view[toIndex + 1].line) - 1;
-              toNode = display.view[toIndex + 1].node.previousSibling;
-            }
-            if (!fromNode) {
-              return false;
-            }
-            var newText = cm.doc.splitLines(
-              domTextBetween(cm, fromNode, toNode, fromLine, toLine)
-            );
-            var oldText = getBetween(
-              cm.doc,
-              Pos(fromLine, 0),
-              Pos(toLine, getLine2(cm.doc, toLine).text.length)
-            );
-            while (newText.length > 1 && oldText.length > 1) {
-              if (lst(newText) == lst(oldText)) {
-                newText.pop();
-                oldText.pop();
-                toLine--;
-              } else if (newText[0] == oldText[0]) {
-                newText.shift();
-                oldText.shift();
-                fromLine++;
-              } else {
-                break;
-              }
-            }
-            var cutFront = 0,
-              cutEnd = 0;
-            var newTop = newText[0],
-              oldTop = oldText[0],
-              maxCutFront = Math.min(newTop.length, oldTop.length);
-            while (
-              cutFront < maxCutFront &&
-              newTop.charCodeAt(cutFront) == oldTop.charCodeAt(cutFront)
-            ) {
-              ++cutFront;
-            }
-            var newBot = lst(newText),
-              oldBot = lst(oldText);
-            var maxCutEnd = Math.min(
-              newBot.length - (newText.length == 1 ? cutFront : 0),
-              oldBot.length - (oldText.length == 1 ? cutFront : 0)
-            );
-            while (
-              cutEnd < maxCutEnd &&
-              newBot.charCodeAt(newBot.length - cutEnd - 1) ==
-                oldBot.charCodeAt(oldBot.length - cutEnd - 1)
-            ) {
-              ++cutEnd;
-            }
-            if (
-              newText.length == 1 &&
-              oldText.length == 1 &&
-              fromLine == from.line
-            ) {
-              while (
-                cutFront &&
-                cutFront > from.ch &&
-                newBot.charCodeAt(newBot.length - cutEnd - 1) ==
-                  oldBot.charCodeAt(oldBot.length - cutEnd - 1)
-              ) {
-                cutFront--;
-                cutEnd++;
-              }
-            }
-            newText[newText.length - 1] = newBot
-              .slice(0, newBot.length - cutEnd)
-              .replace(/^\u200b+/, "");
-            newText[0] = newText[0].slice(cutFront).replace(/\u200b+$/, "");
-            var chFrom = Pos(fromLine, cutFront);
-            var chTo = Pos(
-              toLine,
-              oldText.length ? lst(oldText).length - cutEnd : 0
-            );
-            if (newText.length > 1 || newText[0] || cmp(chFrom, chTo)) {
-              replaceRange(cm.doc, newText, chFrom, chTo, "+input");
-              return true;
-            }
-          };
-          ContentEditableInput.prototype.ensurePolled = function () {
-            this.forceCompositionEnd();
-          };
-          ContentEditableInput.prototype.reset = function () {
-            this.forceCompositionEnd();
-          };
-          ContentEditableInput.prototype.forceCompositionEnd = function () {
-            if (!this.composing) {
-              return;
-            }
-            clearTimeout(this.readDOMTimeout);
-            this.composing = null;
-            this.updateFromDOM();
-            this.div.blur();
-            this.div.focus();
-          };
-          ContentEditableInput.prototype.readFromDOMSoon = function () {
-            var this$1$1 = this;
-            if (this.readDOMTimeout != null) {
-              return;
-            }
-            this.readDOMTimeout = setTimeout(function () {
-              this$1$1.readDOMTimeout = null;
-              if (this$1$1.composing) {
-                if (this$1$1.composing.done) {
-                  this$1$1.composing = null;
-                } else {
-                  return;
-                }
-              }
-              this$1$1.updateFromDOM();
-            }, 80);
-          };
-          ContentEditableInput.prototype.updateFromDOM = function () {
-            var this$1$1 = this;
-            if (this.cm.isReadOnly() || !this.pollContent()) {
-              runInOp(this.cm, function () {
-                return regChange(this$1$1.cm);
-              });
-            }
-          };
-          ContentEditableInput.prototype.setUneditable = function (node) {
-            node.contentEditable = "false";
-          };
-          ContentEditableInput.prototype.onKeyPress = function (e) {
-            if (e.charCode == 0 || this.composing) {
-              return;
-            }
-            e.preventDefault();
-            if (!this.cm.isReadOnly()) {
-              operation(this.cm, applyTextInput)(
-                this.cm,
-                String.fromCharCode(
-                  e.charCode == null ? e.keyCode : e.charCode
-                ),
-                0
-              );
-            }
-          };
-          ContentEditableInput.prototype.readOnlyChanged = function (val) {
-            this.div.contentEditable = String(val != "nocursor");
-          };
-          ContentEditableInput.prototype.onContextMenu = function () {};
-          ContentEditableInput.prototype.resetPosition = function () {};
-          ContentEditableInput.prototype.needsContentAttribute = true;
-          function posToDOM(cm, pos) {
-            var view = findViewForLine(cm, pos.line);
-            if (!view || view.hidden) {
-              return null;
-            }
-            var line = getLine2(cm.doc, pos.line);
-            var info2 = mapFromLineView(view, line, pos.line);
-            var order2 = getOrder(line, cm.doc.direction),
-              side = "left";
-            if (order2) {
-              var partPos = getBidiPartAt(order2, pos.ch);
-              side = partPos % 2 ? "right" : "left";
-            }
-            var result2 = nodeAndOffsetInLineMap(info2.map, pos.ch, side);
-            result2.offset =
-              result2.collapse == "right" ? result2.end : result2.start;
-            return result2;
-          }
-          function isInGutter(node) {
-            for (var scan = node; scan; scan = scan.parentNode) {
-              if (/CodeMirror-gutter-wrapper/.test(scan.className)) {
-                return true;
-              }
-            }
-            return false;
-          }
-          function badPos(pos, bad) {
-            if (bad) {
-              pos.bad = true;
-            }
-            return pos;
-          }
-          function domTextBetween(cm, from, to, fromLine, toLine) {
-            var text3 = "",
-              closing = false,
-              lineSep = cm.doc.lineSeparator(),
-              extraLinebreak = false;
-            function recognizeMarker(id2) {
-              return function (marker2) {
-                return marker2.id == id2;
-              };
-            }
-            function close() {
-              if (closing) {
-                text3 += lineSep;
-                if (extraLinebreak) {
-                  text3 += lineSep;
-                }
-                closing = extraLinebreak = false;
-              }
-            }
-            function addText(str) {
-              if (str) {
-                close();
-                text3 += str;
-              }
-            }
-            function walk(node) {
-              if (node.nodeType == 1) {
-                var cmText = node.getAttribute("cm-text");
-                if (cmText) {
-                  addText(cmText);
-                  return;
-                }
-                var markerID = node.getAttribute("cm-marker"),
-                  range3;
-                if (markerID) {
-                  var found = cm.findMarks(
-                    Pos(fromLine, 0),
-                    Pos(toLine + 1, 0),
-                    recognizeMarker(+markerID)
-                  );
-                  if (found.length && (range3 = found[0].find(0))) {
-                    addText(
-                      getBetween(cm.doc, range3.from, range3.to).join(lineSep)
-                    );
-                  }
-                  return;
-                }
-                if (node.getAttribute("contenteditable") == "false") {
-                  return;
-                }
-                var isBlock = /^(pre|div|p|li|table|br)$/i.test(node.nodeName);
-                if (
-                  !/^br$/i.test(node.nodeName) &&
-                  node.textContent.length == 0
-                ) {
-                  return;
-                }
-                if (isBlock) {
-                  close();
-                }
-                for (var i2 = 0; i2 < node.childNodes.length; i2++) {
-                  walk(node.childNodes[i2]);
-                }
-                if (/^(pre|p)$/i.test(node.nodeName)) {
-                  extraLinebreak = true;
-                }
-                if (isBlock) {
-                  closing = true;
-                }
-              } else if (node.nodeType == 3) {
-                addText(
-                  node.nodeValue.replace(/\u200b/g, "").replace(/\u00a0/g, " ")
-                );
-              }
-            }
-            for (;;) {
-              walk(from);
-              if (from == to) {
-                break;
-              }
-              from = from.nextSibling;
-              extraLinebreak = false;
-            }
-            return text3;
-          }
-          function domToPos(cm, node, offset) {
-            var lineNode;
-            if (node == cm.display.lineDiv) {
-              lineNode = cm.display.lineDiv.childNodes[offset];
-              if (!lineNode) {
-                return badPos(cm.clipPos(Pos(cm.display.viewTo - 1)), true);
-              }
-              node = null;
-              offset = 0;
-            } else {
-              for (lineNode = node; ; lineNode = lineNode.parentNode) {
-                if (!lineNode || lineNode == cm.display.lineDiv) {
-                  return null;
-                }
-                if (
-                  lineNode.parentNode &&
-                  lineNode.parentNode == cm.display.lineDiv
-                ) {
-                  break;
-                }
-              }
-            }
-            for (var i2 = 0; i2 < cm.display.view.length; i2++) {
-              var lineView = cm.display.view[i2];
-              if (lineView.node == lineNode) {
-                return locateNodeInLineView(lineView, node, offset);
-              }
-            }
-          }
-          function locateNodeInLineView(lineView, node, offset) {
-            var wrapper = lineView.text.firstChild,
-              bad = false;
-            if (!node || !contains(wrapper, node)) {
-              return badPos(Pos(lineNo(lineView.line), 0), true);
-            }
-            if (node == wrapper) {
-              bad = true;
-              node = wrapper.childNodes[offset];
-              offset = 0;
-              if (!node) {
-                var line = lineView.rest ? lst(lineView.rest) : lineView.line;
-                return badPos(Pos(lineNo(line), line.text.length), bad);
-              }
-            }
-            var textNode = node.nodeType == 3 ? node : null,
-              topNode = node;
-            if (
-              !textNode &&
-              node.childNodes.length == 1 &&
-              node.firstChild.nodeType == 3
-            ) {
-              textNode = node.firstChild;
-              if (offset) {
-                offset = textNode.nodeValue.length;
-              }
-            }
-            while (topNode.parentNode != wrapper) {
-              topNode = topNode.parentNode;
-            }
-            var measure = lineView.measure,
-              maps = measure.maps;
-            function find2(textNode2, topNode2, offset2) {
-              for (var i2 = -1; i2 < (maps ? maps.length : 0); i2++) {
-                var map3 = i2 < 0 ? measure.map : maps[i2];
-                for (var j = 0; j < map3.length; j += 3) {
-                  var curNode = map3[j + 2];
-                  if (curNode == textNode2 || curNode == topNode2) {
-                    var line2 = lineNo(
-                      i2 < 0 ? lineView.line : lineView.rest[i2]
-                    );
-                    var ch2 = map3[j] + offset2;
-                    if (offset2 < 0 || curNode != textNode2) {
-                      ch2 = map3[j + (offset2 ? 1 : 0)];
-                    }
-                    return Pos(line2, ch2);
-                  }
-                }
-              }
-            }
-            var found = find2(textNode, topNode, offset);
-            if (found) {
-              return badPos(found, bad);
-            }
-            for (
-              var after = topNode.nextSibling,
-                dist2 = textNode ? textNode.nodeValue.length - offset : 0;
-              after;
-              after = after.nextSibling
-            ) {
-              found = find2(after, after.firstChild, 0);
-              if (found) {
-                return badPos(Pos(found.line, found.ch - dist2), bad);
-              } else {
-                dist2 += after.textContent.length;
-              }
-            }
-            for (
-              var before = topNode.previousSibling, dist$1 = offset;
-              before;
-              before = before.previousSibling
-            ) {
-              found = find2(before, before.firstChild, -1);
-              if (found) {
-                return badPos(Pos(found.line, found.ch + dist$1), bad);
-              } else {
-                dist$1 += before.textContent.length;
-              }
-            }
-          }
-          var TextareaInput = function (cm) {
-            this.cm = cm;
-            this.prevInput = "";
-            this.pollingFast = false;
-            this.polling = new Delayed();
-            this.hasSelection = false;
-            this.composing = null;
-          };
-          TextareaInput.prototype.init = function (display) {
-            var this$1$1 = this;
-            var input = this,
-              cm = this.cm;
-            this.createField(display);
-            var te = this.textarea;
-            display.wrapper.insertBefore(
-              this.wrapper,
-              display.wrapper.firstChild
-            );
-            if (ios) {
-              te.style.width = "0px";
-            }
-            on(te, "input", function () {
-              if (ie2 && ie_version >= 9 && this$1$1.hasSelection) {
-                this$1$1.hasSelection = null;
-              }
-              input.poll();
-            });
-            on(te, "paste", function (e) {
-              if (signalDOMEvent(cm, e) || handlePaste(e, cm)) {
-                return;
-              }
-              cm.state.pasteIncoming = +new Date();
-              input.fastPoll();
-            });
-            function prepareCopyCut(e) {
-              if (signalDOMEvent(cm, e)) {
-                return;
-              }
-              if (cm.somethingSelected()) {
-                setLastCopied({ lineWise: false, text: cm.getSelections() });
-              } else if (!cm.options.lineWiseCopyCut) {
-                return;
-              } else {
-                var ranges = copyableRanges(cm);
-                setLastCopied({ lineWise: true, text: ranges.text });
-                if (e.type == "cut") {
-                  cm.setSelections(ranges.ranges, null, sel_dontScroll);
-                } else {
-                  input.prevInput = "";
-                  te.value = ranges.text.join("\n");
-                  selectInput(te);
-                }
-              }
-              if (e.type == "cut") {
-                cm.state.cutIncoming = +new Date();
-              }
-            }
-            on(te, "cut", prepareCopyCut);
-            on(te, "copy", prepareCopyCut);
-            on(display.scroller, "paste", function (e) {
-              if (eventInWidget(display, e) || signalDOMEvent(cm, e)) {
-                return;
-              }
-              if (!te.dispatchEvent) {
-                cm.state.pasteIncoming = +new Date();
-                input.focus();
-                return;
-              }
-              var event = new Event("paste");
-              event.clipboardData = e.clipboardData;
-              te.dispatchEvent(event);
-            });
-            on(display.lineSpace, "selectstart", function (e) {
-              if (!eventInWidget(display, e)) {
-                e_preventDefault(e);
-              }
-            });
-            on(te, "compositionstart", function () {
-              var start2 = cm.getCursor("from");
-              if (input.composing) {
-                input.composing.range.clear();
-              }
-              input.composing = {
-                start: start2,
-                range: cm.markText(start2, cm.getCursor("to"), {
-                  className: "CodeMirror-composing",
-                }),
-              };
-            });
-            on(te, "compositionend", function () {
-              if (input.composing) {
-                input.poll();
-                input.composing.range.clear();
-                input.composing = null;
-              }
-            });
-          };
-          TextareaInput.prototype.createField = function (_display) {
-            this.wrapper = hiddenTextarea();
-            this.textarea = this.wrapper.firstChild;
-          };
-          TextareaInput.prototype.screenReaderLabelChanged = function (label) {
-            if (label) {
-              this.textarea.setAttribute("aria-label", label);
-            } else {
-              this.textarea.removeAttribute("aria-label");
-            }
-          };
-          TextareaInput.prototype.prepareSelection = function () {
-            var cm = this.cm,
-              display = cm.display,
-              doc = cm.doc;
-            var result2 = prepareSelection(cm);
-            if (cm.options.moveInputWithCursor) {
-              var headPos = cursorCoords(cm, doc.sel.primary().head, "div");
-              var wrapOff = display.wrapper.getBoundingClientRect(),
-                lineOff = display.lineDiv.getBoundingClientRect();
-              result2.teTop = Math.max(
-                0,
-                Math.min(
-                  display.wrapper.clientHeight - 10,
-                  headPos.top + lineOff.top - wrapOff.top
-                )
-              );
-              result2.teLeft = Math.max(
-                0,
-                Math.min(
-                  display.wrapper.clientWidth - 10,
-                  headPos.left + lineOff.left - wrapOff.left
-                )
-              );
-            }
-            return result2;
-          };
-          TextareaInput.prototype.showSelection = function (drawn) {
-            var cm = this.cm,
-              display = cm.display;
-            removeChildrenAndAdd(display.cursorDiv, drawn.cursors);
-            removeChildrenAndAdd(display.selectionDiv, drawn.selection);
-            if (drawn.teTop != null) {
-              this.wrapper.style.top = drawn.teTop + "px";
-              this.wrapper.style.left = drawn.teLeft + "px";
-            }
-          };
-          TextareaInput.prototype.reset = function (typing) {
-            if (this.contextMenuPending || this.composing) {
-              return;
-            }
-            var cm = this.cm;
-            if (cm.somethingSelected()) {
-              this.prevInput = "";
-              var content = cm.getSelection();
-              this.textarea.value = content;
-              if (cm.state.focused) {
-                selectInput(this.textarea);
-              }
-              if (ie2 && ie_version >= 9) {
-                this.hasSelection = content;
-              }
-            } else if (!typing) {
-              this.prevInput = this.textarea.value = "";
-              if (ie2 && ie_version >= 9) {
-                this.hasSelection = null;
-              }
-            }
-          };
-          TextareaInput.prototype.getField = function () {
-            return this.textarea;
-          };
-          TextareaInput.prototype.supportsTouch = function () {
-            return false;
-          };
-          TextareaInput.prototype.focus = function () {
-            if (
-              this.cm.options.readOnly != "nocursor" &&
-              (!mobile || activeElt() != this.textarea)
-            ) {
-              try {
-                this.textarea.focus();
-              } catch (e) {}
-            }
-          };
-          TextareaInput.prototype.blur = function () {
-            this.textarea.blur();
-          };
-          TextareaInput.prototype.resetPosition = function () {
-            this.wrapper.style.top = this.wrapper.style.left = 0;
-          };
-          TextareaInput.prototype.receivedFocus = function () {
-            this.slowPoll();
-          };
-          TextareaInput.prototype.slowPoll = function () {
-            var this$1$1 = this;
-            if (this.pollingFast) {
-              return;
-            }
-            this.polling.set(this.cm.options.pollInterval, function () {
-              this$1$1.poll();
-              if (this$1$1.cm.state.focused) {
-                this$1$1.slowPoll();
-              }
-            });
-          };
-          TextareaInput.prototype.fastPoll = function () {
-            var missed = false,
-              input = this;
-            input.pollingFast = true;
-            function p2() {
-              var changed = input.poll();
-              if (!changed && !missed) {
-                missed = true;
-                input.polling.set(60, p2);
-              } else {
-                input.pollingFast = false;
-                input.slowPoll();
-              }
-            }
-            input.polling.set(20, p2);
-          };
-          TextareaInput.prototype.poll = function () {
-            var this$1$1 = this;
-            var cm = this.cm,
-              input = this.textarea,
-              prevInput = this.prevInput;
-            if (
-              this.contextMenuPending ||
-              !cm.state.focused ||
-              (hasSelection(input) && !prevInput && !this.composing) ||
-              cm.isReadOnly() ||
-              cm.options.disableInput ||
-              cm.state.keySeq
-            ) {
-              return false;
-            }
-            var text3 = input.value;
-            if (text3 == prevInput && !cm.somethingSelected()) {
-              return false;
-            }
-            if (
-              (ie2 && ie_version >= 9 && this.hasSelection === text3) ||
-              (mac && /[\uf700-\uf7ff]/.test(text3))
-            ) {
-              cm.display.input.reset();
-              return false;
-            }
-            if (cm.doc.sel == cm.display.selForContextMenu) {
-              var first = text3.charCodeAt(0);
-              if (first == 8203 && !prevInput) {
-                prevInput = "\u200B";
-              }
-              if (first == 8666) {
-                this.reset();
-                return this.cm.execCommand("undo");
-              }
-            }
-            var same = 0,
-              l2 = Math.min(prevInput.length, text3.length);
-            while (
-              same < l2 &&
-              prevInput.charCodeAt(same) == text3.charCodeAt(same)
-            ) {
-              ++same;
-            }
-            runInOp(cm, function () {
-              applyTextInput(
-                cm,
-                text3.slice(same),
-                prevInput.length - same,
-                null,
-                this$1$1.composing ? "*compose" : null
-              );
-              if (text3.length > 1e3 || text3.indexOf("\n") > -1) {
-                input.value = this$1$1.prevInput = "";
-              } else {
-                this$1$1.prevInput = text3;
-              }
-              if (this$1$1.composing) {
-                this$1$1.composing.range.clear();
-                this$1$1.composing.range = cm.markText(
-                  this$1$1.composing.start,
-                  cm.getCursor("to"),
-                  { className: "CodeMirror-composing" }
-                );
-              }
-            });
-            return true;
-          };
-          TextareaInput.prototype.ensurePolled = function () {
-            if (this.pollingFast && this.poll()) {
-              this.pollingFast = false;
-            }
-          };
-          TextareaInput.prototype.onKeyPress = function () {
-            if (ie2 && ie_version >= 9) {
-              this.hasSelection = null;
-            }
-            this.fastPoll();
-          };
-          TextareaInput.prototype.onContextMenu = function (e) {
-            var input = this,
-              cm = input.cm,
-              display = cm.display,
-              te = input.textarea;
-            if (input.contextMenuPending) {
-              input.contextMenuPending();
-            }
-            var pos = posFromMouse(cm, e),
-              scrollPos = display.scroller.scrollTop;
-            if (!pos || presto) {
-              return;
-            }
-            var reset = cm.options.resetSelectionOnContextMenu;
-            if (reset && cm.doc.sel.contains(pos) == -1) {
-              operation(cm, setSelection)(
-                cm.doc,
-                simpleSelection(pos),
-                sel_dontScroll
-              );
-            }
-            var oldCSS = te.style.cssText,
-              oldWrapperCSS = input.wrapper.style.cssText;
-            var wrapperBox = input.wrapper.offsetParent.getBoundingClientRect();
-            input.wrapper.style.cssText = "position: static";
-            te.style.cssText =
-              "position: absolute; width: 30px; height: 30px;\n      top: " +
-              (e.clientY - wrapperBox.top - 5) +
-              "px; left: " +
-              (e.clientX - wrapperBox.left - 5) +
-              "px;\n      z-index: 1000; background: " +
-              (ie2 ? "rgba(255, 255, 255, .05)" : "transparent") +
-              ";\n      outline: none; border-width: 0; outline: none; overflow: hidden; opacity: .05; filter: alpha(opacity=5);";
-            var oldScrollY;
-            if (webkit) {
-              oldScrollY = window.scrollY;
-            }
-            display.input.focus();
-            if (webkit) {
-              window.scrollTo(null, oldScrollY);
-            }
-            display.input.reset();
-            if (!cm.somethingSelected()) {
-              te.value = input.prevInput = " ";
-            }
-            input.contextMenuPending = rehide;
-            display.selForContextMenu = cm.doc.sel;
-            clearTimeout(display.detectingSelectAll);
-            function prepareSelectAllHack() {
-              if (te.selectionStart != null) {
-                var selected = cm.somethingSelected();
-                var extval = "\u200B" + (selected ? te.value : "");
-                te.value = "\u21DA";
-                te.value = extval;
-                input.prevInput = selected ? "" : "\u200B";
-                te.selectionStart = 1;
-                te.selectionEnd = extval.length;
-                display.selForContextMenu = cm.doc.sel;
-              }
-            }
-            function rehide() {
-              if (input.contextMenuPending != rehide) {
-                return;
-              }
-              input.contextMenuPending = false;
-              input.wrapper.style.cssText = oldWrapperCSS;
-              te.style.cssText = oldCSS;
-              if (ie2 && ie_version < 9) {
-                display.scrollbars.setScrollTop(
-                  (display.scroller.scrollTop = scrollPos)
-                );
-              }
-              if (te.selectionStart != null) {
-                if (!ie2 || (ie2 && ie_version < 9)) {
-                  prepareSelectAllHack();
-                }
-                var i2 = 0,
-                  poll = function () {
-                    if (
-                      display.selForContextMenu == cm.doc.sel &&
-                      te.selectionStart == 0 &&
-                      te.selectionEnd > 0 &&
-                      input.prevInput == "\u200B"
-                    ) {
-                      operation(cm, selectAll)(cm);
-                    } else if (i2++ < 10) {
-                      display.detectingSelectAll = setTimeout(poll, 500);
-                    } else {
-                      display.selForContextMenu = null;
-                      display.input.reset();
-                    }
-                  };
-                display.detectingSelectAll = setTimeout(poll, 200);
-              }
-            }
-            if (ie2 && ie_version >= 9) {
-              prepareSelectAllHack();
-            }
-            if (captureRightClick) {
-              e_stop(e);
-              var mouseup = function () {
-                off(window, "mouseup", mouseup);
-                setTimeout(rehide, 20);
-              };
-              on(window, "mouseup", mouseup);
-            } else {
-              setTimeout(rehide, 50);
-            }
-          };
-          TextareaInput.prototype.readOnlyChanged = function (val) {
-            if (!val) {
-              this.reset();
-            }
-            this.textarea.disabled = val == "nocursor";
-            this.textarea.readOnly = !!val;
-          };
-          TextareaInput.prototype.setUneditable = function () {};
-          TextareaInput.prototype.needsContentAttribute = false;
-          function fromTextArea(textarea, options) {
-            options = options ? copyObj(options) : {};
-            options.value = textarea.value;
-            if (!options.tabindex && textarea.tabIndex) {
-              options.tabindex = textarea.tabIndex;
-            }
-            if (!options.placeholder && textarea.placeholder) {
-              options.placeholder = textarea.placeholder;
-            }
-            if (options.autofocus == null) {
-              var hasFocus = activeElt();
-              options.autofocus =
-                hasFocus == textarea ||
-                (textarea.getAttribute("autofocus") != null &&
-                  hasFocus == document.body);
-            }
-            function save() {
-              textarea.value = cm.getValue();
-            }
-            var realSubmit;
-            if (textarea.form) {
-              on(textarea.form, "submit", save);
-              if (!options.leaveSubmitMethodAlone) {
-                var form = textarea.form;
-                realSubmit = form.submit;
-                try {
-                  var wrappedSubmit = (form.submit = function () {
-                    save();
-                    form.submit = realSubmit;
-                    form.submit();
-                    form.submit = wrappedSubmit;
-                  });
-                } catch (e) {}
-              }
-            }
-            options.finishInit = function (cm2) {
-              cm2.save = save;
-              cm2.getTextArea = function () {
-                return textarea;
-              };
-              cm2.toTextArea = function () {
-                cm2.toTextArea = isNaN;
-                save();
-                textarea.parentNode.removeChild(cm2.getWrapperElement());
-                textarea.style.display = "";
-                if (textarea.form) {
-                  off(textarea.form, "submit", save);
-                  if (
-                    !options.leaveSubmitMethodAlone &&
-                    typeof textarea.form.submit == "function"
-                  ) {
-                    textarea.form.submit = realSubmit;
-                  }
-                }
-              };
-            };
-            textarea.style.display = "none";
-            var cm = CodeMirror(function (node) {
-              return textarea.parentNode.insertBefore(
-                node,
-                textarea.nextSibling
-              );
-            }, options);
-            return cm;
-          }
-          function addLegacyProps(CodeMirror2) {
-            CodeMirror2.off = off;
-            CodeMirror2.on = on;
-            CodeMirror2.wheelEventPixels = wheelEventPixels;
-            CodeMirror2.Doc = Doc;
-            CodeMirror2.splitLines = splitLinesAuto;
-            CodeMirror2.countColumn = countColumn;
-            CodeMirror2.findColumn = findColumn;
-            CodeMirror2.isWordChar = isWordCharBasic;
-            CodeMirror2.Pass = Pass;
-            CodeMirror2.signal = signal;
-            CodeMirror2.Line = Line;
-            CodeMirror2.changeEnd = changeEnd;
-            CodeMirror2.scrollbarModel = scrollbarModel;
-            CodeMirror2.Pos = Pos;
-            CodeMirror2.cmpPos = cmp;
-            CodeMirror2.modes = modes;
-            CodeMirror2.mimeModes = mimeModes;
-            CodeMirror2.resolveMode = resolveMode;
-            CodeMirror2.getMode = getMode;
-            CodeMirror2.modeExtensions = modeExtensions;
-            CodeMirror2.extendMode = extendMode;
-            CodeMirror2.copyState = copyState;
-            CodeMirror2.startState = startState;
-            CodeMirror2.innerMode = innerMode;
-            CodeMirror2.commands = commands;
-            CodeMirror2.keyMap = keyMap2;
-            CodeMirror2.keyName = keyName;
-            CodeMirror2.isModifierKey = isModifierKey;
-            CodeMirror2.lookupKey = lookupKey;
-            CodeMirror2.normalizeKeyMap = normalizeKeyMap;
-            CodeMirror2.StringStream = StringStream;
-            CodeMirror2.SharedTextMarker = SharedTextMarker;
-            CodeMirror2.TextMarker = TextMarker;
-            CodeMirror2.LineWidget = LineWidget;
-            CodeMirror2.e_preventDefault = e_preventDefault;
-            CodeMirror2.e_stopPropagation = e_stopPropagation;
-            CodeMirror2.e_stop = e_stop;
-            CodeMirror2.addClass = addClass;
-            CodeMirror2.contains = contains;
-            CodeMirror2.rmClass = rmClass;
-            CodeMirror2.keyNames = keyNames;
-          }
-          defineOptions(CodeMirror);
-          addEditorMethods(CodeMirror);
-          var dontDelegate =
-            "iter insert remove copy getEditor constructor".split(" ");
-          for (var prop2 in Doc.prototype) {
-            if (
-              Doc.prototype.hasOwnProperty(prop2) &&
-              indexOf(dontDelegate, prop2) < 0
-            ) {
-              CodeMirror.prototype[prop2] = (function (method) {
-                return function () {
-                  return method.apply(this.doc, arguments);
-                };
-              })(Doc.prototype[prop2]);
-            }
-          }
-          eventMixin(Doc);
-          CodeMirror.inputStyles = {
-            textarea: TextareaInput,
-            contenteditable: ContentEditableInput,
-          };
-          CodeMirror.defineMode = function (name2) {
-            if (!CodeMirror.defaults.mode && name2 != "null") {
-              CodeMirror.defaults.mode = name2;
-            }
-            defineMode.apply(this, arguments);
-          };
-          CodeMirror.defineMIME = defineMIME;
-          CodeMirror.defineMode("null", function () {
-            return {
-              token: function (stream) {
-                return stream.skipToEnd();
-              },
-            };
-          });
-          CodeMirror.defineMIME("text/plain", "null");
-          CodeMirror.defineExtension = function (name2, func) {
-            CodeMirror.prototype[name2] = func;
-          };
-          CodeMirror.defineDocExtension = function (name2, func) {
-            Doc.prototype[name2] = func;
-          };
-          CodeMirror.fromTextArea = fromTextArea;
-          addLegacyProps(CodeMirror);
-          CodeMirror.version = "5.65.1";
-          return CodeMirror;
-        });
-      })(codemirror$2);
-      var codemirror = codemirror$2.exports;
-      var codemirror$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: codemirror,
-          },
-          [codemirror$2.exports]
-        )
-      );
-      var showHint$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports);
-        })(function (CodeMirror) {
-          var HINT_ELEMENT_CLASS = "CodeMirror-hint";
-          var ACTIVE_HINT_ELEMENT_CLASS = "CodeMirror-hint-active";
-          CodeMirror.showHint = function (cm, getHints, options) {
-            if (!getHints) return cm.showHint(options);
-            if (options && options.async) getHints.async = true;
-            var newOpts = { hint: getHints };
-            if (options)
-              for (var prop2 in options) newOpts[prop2] = options[prop2];
-            return cm.showHint(newOpts);
-          };
-          CodeMirror.defineExtension("showHint", function (options) {
-            options = parseOptions(this, this.getCursor("start"), options);
-            var selections = this.listSelections();
-            if (selections.length > 1) return;
-            if (this.somethingSelected()) {
-              if (!options.hint.supportsSelection) return;
-              for (var i = 0; i < selections.length; i++)
-                if (selections[i].head.line != selections[i].anchor.line)
-                  return;
-            }
-            if (this.state.completionActive)
-              this.state.completionActive.close();
-            var completion = (this.state.completionActive = new Completion(
-              this,
-              options
-            ));
-            if (!completion.options.hint) return;
-            CodeMirror.signal(this, "startCompletion", this);
-            completion.update(true);
-          });
-          CodeMirror.defineExtension("closeHint", function () {
-            if (this.state.completionActive)
-              this.state.completionActive.close();
-          });
-          function Completion(cm, options) {
-            this.cm = cm;
-            this.options = options;
-            this.widget = null;
-            this.debounce = 0;
-            this.tick = 0;
-            this.startPos = this.cm.getCursor("start");
-            this.startLen =
-              this.cm.getLine(this.startPos.line).length -
-              this.cm.getSelection().length;
-            if (this.options.updateOnCursorActivity) {
-              var self2 = this;
-              cm.on(
-                "cursorActivity",
-                (this.activityFunc = function () {
-                  self2.cursorActivity();
-                })
-              );
-            }
-          }
-          var requestAnimationFrame =
-            window.requestAnimationFrame ||
-            function (fn) {
-              return setTimeout(fn, 1e3 / 60);
-            };
-          var cancelAnimationFrame =
-            window.cancelAnimationFrame || clearTimeout;
-          Completion.prototype = {
-            close: function () {
-              if (!this.active()) return;
-              this.cm.state.completionActive = null;
-              this.tick = null;
-              if (this.options.updateOnCursorActivity) {
-                this.cm.off("cursorActivity", this.activityFunc);
-              }
-              if (this.widget && this.data)
-                CodeMirror.signal(this.data, "close");
-              if (this.widget) this.widget.close();
-              CodeMirror.signal(this.cm, "endCompletion", this.cm);
-            },
-            active: function () {
-              return this.cm.state.completionActive == this;
-            },
-            pick: function (data, i) {
-              var completion = data.list[i],
-                self2 = this;
-              this.cm.operation(function () {
-                if (completion.hint)
-                  completion.hint(self2.cm, data, completion);
-                else
-                  self2.cm.replaceRange(
-                    getText(completion),
-                    completion.from || data.from,
-                    completion.to || data.to,
-                    "complete"
-                  );
-                CodeMirror.signal(data, "pick", completion);
-                self2.cm.scrollIntoView();
-              });
-              if (this.options.closeOnPick) {
-                this.close();
-              }
-            },
-            cursorActivity: function () {
-              if (this.debounce) {
-                cancelAnimationFrame(this.debounce);
-                this.debounce = 0;
-              }
-              var identStart = this.startPos;
-              if (this.data) {
-                identStart = this.data.from;
-              }
-              var pos = this.cm.getCursor(),
-                line = this.cm.getLine(pos.line);
-              if (
-                pos.line != this.startPos.line ||
-                line.length - pos.ch != this.startLen - this.startPos.ch ||
-                pos.ch < identStart.ch ||
-                this.cm.somethingSelected() ||
-                !pos.ch ||
-                this.options.closeCharacters.test(line.charAt(pos.ch - 1))
-              ) {
-                this.close();
-              } else {
-                var self2 = this;
-                this.debounce = requestAnimationFrame(function () {
-                  self2.update();
-                });
-                if (this.widget) this.widget.disable();
-              }
-            },
-            update: function (first) {
-              if (this.tick == null) return;
-              var self2 = this,
-                myTick = ++this.tick;
-              fetchHints(
-                this.options.hint,
-                this.cm,
-                this.options,
-                function (data) {
-                  if (self2.tick == myTick) self2.finishUpdate(data, first);
-                }
-              );
-            },
-            finishUpdate: function (data, first) {
-              if (this.data) CodeMirror.signal(this.data, "update");
-              var picked =
-                (this.widget && this.widget.picked) ||
-                (first && this.options.completeSingle);
-              if (this.widget) this.widget.close();
-              this.data = data;
-              if (data && data.list.length) {
-                if (picked && data.list.length == 1) {
-                  this.pick(data, 0);
-                } else {
-                  this.widget = new Widget(this, data);
-                  CodeMirror.signal(data, "shown");
-                }
-              }
-            },
-          };
-          function parseOptions(cm, pos, options) {
-            var editor = cm.options.hintOptions;
-            var out = {};
-            for (var prop2 in defaultOptions2)
-              out[prop2] = defaultOptions2[prop2];
-            if (editor) {
-              for (var prop2 in editor)
-                if (editor[prop2] !== void 0) out[prop2] = editor[prop2];
-            }
-            if (options) {
-              for (var prop2 in options)
-                if (options[prop2] !== void 0) out[prop2] = options[prop2];
-            }
-            if (out.hint.resolve) out.hint = out.hint.resolve(cm, pos);
-            return out;
-          }
-          function getText(completion) {
-            if (typeof completion == "string") return completion;
-            else return completion.text;
-          }
-          function buildKeyMap(completion, handle) {
-            var baseMap = {
-              Up: function () {
-                handle.moveFocus(-1);
-              },
-              Down: function () {
-                handle.moveFocus(1);
-              },
-              PageUp: function () {
-                handle.moveFocus(-handle.menuSize() + 1, true);
-              },
-              PageDown: function () {
-                handle.moveFocus(handle.menuSize() - 1, true);
-              },
-              Home: function () {
-                handle.setFocus(0);
-              },
-              End: function () {
-                handle.setFocus(handle.length - 1);
-              },
-              Enter: handle.pick,
-              Tab: handle.pick,
-              Esc: handle.close,
-            };
-            var mac = /Mac/.test(navigator.platform);
-            if (mac) {
-              baseMap["Ctrl-P"] = function () {
-                handle.moveFocus(-1);
-              };
-              baseMap["Ctrl-N"] = function () {
-                handle.moveFocus(1);
-              };
-            }
-            var custom = completion.options.customKeys;
-            var ourMap = custom ? {} : baseMap;
-            function addBinding(key2, val) {
-              var bound;
-              if (typeof val != "string")
-                bound = function (cm) {
-                  return val(cm, handle);
-                };
-              else if (baseMap.hasOwnProperty(val)) bound = baseMap[val];
-              else bound = val;
-              ourMap[key2] = bound;
-            }
-            if (custom) {
-              for (var key in custom)
-                if (custom.hasOwnProperty(key)) addBinding(key, custom[key]);
-            }
-            var extra = completion.options.extraKeys;
-            if (extra) {
-              for (var key in extra)
-                if (extra.hasOwnProperty(key)) addBinding(key, extra[key]);
-            }
-            return ourMap;
-          }
-          function getHintElement(hintsElement, el2) {
-            while (el2 && el2 != hintsElement) {
-              if (
-                el2.nodeName.toUpperCase() === "LI" &&
-                el2.parentNode == hintsElement
-              )
-                return el2;
-              el2 = el2.parentNode;
-            }
-          }
-          function Widget(completion, data) {
-            this.id = "cm-complete-" + Math.floor(Math.random(1e6));
-            this.completion = completion;
-            this.data = data;
-            this.picked = false;
-            var widget = this,
-              cm = completion.cm;
-            var ownerDocument = cm.getInputField().ownerDocument;
-            var parentWindow =
-              ownerDocument.defaultView || ownerDocument.parentWindow;
-            var hints = (this.hints = ownerDocument.createElement("ul"));
-            hints.setAttribute("role", "listbox");
-            hints.setAttribute("aria-expanded", "true");
-            hints.id = this.id;
-            var theme = completion.cm.options.theme;
-            hints.className = "CodeMirror-hints " + theme;
-            this.selectedHint = data.selectedHint || 0;
-            var completions = data.list;
-            for (var i = 0; i < completions.length; ++i) {
-              var elt = hints.appendChild(ownerDocument.createElement("li")),
-                cur = completions[i];
-              var className =
-                HINT_ELEMENT_CLASS +
-                (i != this.selectedHint ? "" : " " + ACTIVE_HINT_ELEMENT_CLASS);
-              if (cur.className != null)
-                className = cur.className + " " + className;
-              elt.className = className;
-              if (i == this.selectedHint)
-                elt.setAttribute("aria-selected", "true");
-              elt.id = this.id + "-" + i;
-              elt.setAttribute("role", "option");
-              if (cur.render) cur.render(elt, data, cur);
-              else
-                elt.appendChild(
-                  ownerDocument.createTextNode(cur.displayText || getText(cur))
-                );
-              elt.hintId = i;
-            }
-            var container = completion.options.container || ownerDocument.body;
-            var pos = cm.cursorCoords(
-              completion.options.alignWithWord ? data.from : null
-            );
-            var left = pos.left,
-              top2 = pos.bottom,
-              below = true;
-            var offsetLeft = 0,
-              offsetTop = 0;
-            if (container !== ownerDocument.body) {
-              var isContainerPositioned =
-                ["absolute", "relative", "fixed"].indexOf(
-                  parentWindow.getComputedStyle(container).position
-                ) !== -1;
-              var offsetParent = isContainerPositioned
-                ? container
-                : container.offsetParent;
-              var offsetParentPosition = offsetParent.getBoundingClientRect();
-              var bodyPosition = ownerDocument.body.getBoundingClientRect();
-              offsetLeft =
-                offsetParentPosition.left -
-                bodyPosition.left -
-                offsetParent.scrollLeft;
-              offsetTop =
-                offsetParentPosition.top -
-                bodyPosition.top -
-                offsetParent.scrollTop;
-            }
-            hints.style.left = left - offsetLeft + "px";
-            hints.style.top = top2 - offsetTop + "px";
-            var winW =
-              parentWindow.innerWidth ||
-              Math.max(
-                ownerDocument.body.offsetWidth,
-                ownerDocument.documentElement.offsetWidth
-              );
-            var winH =
-              parentWindow.innerHeight ||
-              Math.max(
-                ownerDocument.body.offsetHeight,
-                ownerDocument.documentElement.offsetHeight
-              );
-            container.appendChild(hints);
-            cm.getInputField().setAttribute("aria-autocomplete", "list");
-            cm.getInputField().setAttribute("aria-owns", this.id);
-            cm.getInputField().setAttribute(
-              "aria-activedescendant",
-              this.id + "-" + this.selectedHint
-            );
-            var box = completion.options.moveOnOverlap
-              ? hints.getBoundingClientRect()
-              : new DOMRect();
-            var scrolls = completion.options.paddingForScrollbar
-              ? hints.scrollHeight > hints.clientHeight + 1
-              : false;
-            var startScroll;
-            setTimeout(function () {
-              startScroll = cm.getScrollInfo();
-            });
-            var overlapY = box.bottom - winH;
-            if (overlapY > 0) {
-              var height = box.bottom - box.top,
-                curTop = pos.top - (pos.bottom - box.top);
-              if (curTop - height > 0) {
-                hints.style.top = (top2 = pos.top - height - offsetTop) + "px";
-                below = false;
-              } else if (height > winH) {
-                hints.style.height = winH - 5 + "px";
-                hints.style.top =
-                  (top2 = pos.bottom - box.top - offsetTop) + "px";
-                var cursor = cm.getCursor();
-                if (data.from.ch != cursor.ch) {
-                  pos = cm.cursorCoords(cursor);
-                  hints.style.left = (left = pos.left - offsetLeft) + "px";
-                  box = hints.getBoundingClientRect();
-                }
-              }
-            }
-            var overlapX = box.right - winW;
-            if (scrolls) overlapX += cm.display.nativeBarWidth;
-            if (overlapX > 0) {
-              if (box.right - box.left > winW) {
-                hints.style.width = winW - 5 + "px";
-                overlapX -= box.right - box.left - winW;
-              }
-              hints.style.left =
-                (left = pos.left - overlapX - offsetLeft) + "px";
-            }
-            if (scrolls)
-              for (var node = hints.firstChild; node; node = node.nextSibling)
-                node.style.paddingRight = cm.display.nativeBarWidth + "px";
-            cm.addKeyMap(
-              (this.keyMap = buildKeyMap(completion, {
-                moveFocus: function (n2, avoidWrap) {
-                  widget.changeActive(widget.selectedHint + n2, avoidWrap);
-                },
-                setFocus: function (n2) {
-                  widget.changeActive(n2);
-                },
-                menuSize: function () {
-                  return widget.screenAmount();
-                },
-                length: completions.length,
-                close: function () {
-                  completion.close();
-                },
-                pick: function () {
-                  widget.pick();
-                },
-                data,
-              }))
-            );
-            if (completion.options.closeOnUnfocus) {
-              var closingOnBlur;
-              cm.on(
-                "blur",
-                (this.onBlur = function () {
-                  closingOnBlur = setTimeout(function () {
-                    completion.close();
-                  }, 100);
-                })
-              );
-              cm.on(
-                "focus",
-                (this.onFocus = function () {
-                  clearTimeout(closingOnBlur);
-                })
-              );
-            }
-            cm.on(
-              "scroll",
-              (this.onScroll = function () {
-                var curScroll = cm.getScrollInfo(),
-                  editor = cm.getWrapperElement().getBoundingClientRect();
-                if (!startScroll) startScroll = cm.getScrollInfo();
-                var newTop = top2 + startScroll.top - curScroll.top;
-                var point =
-                  newTop -
-                  (parentWindow.pageYOffset ||
-                    (ownerDocument.documentElement || ownerDocument.body)
-                      .scrollTop);
-                if (!below) point += hints.offsetHeight;
-                if (point <= editor.top || point >= editor.bottom)
-                  return completion.close();
-                hints.style.top = newTop + "px";
-                hints.style.left =
-                  left + startScroll.left - curScroll.left + "px";
-              })
-            );
-            CodeMirror.on(hints, "dblclick", function (e) {
-              var t2 = getHintElement(hints, e.target || e.srcElement);
-              if (t2 && t2.hintId != null) {
-                widget.changeActive(t2.hintId);
-                widget.pick();
-              }
-            });
-            CodeMirror.on(hints, "click", function (e) {
-              var t2 = getHintElement(hints, e.target || e.srcElement);
-              if (t2 && t2.hintId != null) {
-                widget.changeActive(t2.hintId);
-                if (completion.options.completeOnSingleClick) widget.pick();
-              }
-            });
-            CodeMirror.on(hints, "mousedown", function () {
-              setTimeout(function () {
-                cm.focus();
-              }, 20);
-            });
-            var selectedHintRange = this.getSelectedHintRange();
-            if (selectedHintRange.from !== 0 || selectedHintRange.to !== 0) {
-              this.scrollToActive();
-            }
-            CodeMirror.signal(
-              data,
-              "select",
-              completions[this.selectedHint],
-              hints.childNodes[this.selectedHint]
-            );
-            return true;
-          }
-          Widget.prototype = {
-            close: function () {
-              if (this.completion.widget != this) return;
-              this.completion.widget = null;
-              if (this.hints.parentNode)
-                this.hints.parentNode.removeChild(this.hints);
-              this.completion.cm.removeKeyMap(this.keyMap);
-              var input = this.completion.cm.getInputField();
-              input.removeAttribute("aria-activedescendant");
-              input.removeAttribute("aria-owns");
-              var cm = this.completion.cm;
-              if (this.completion.options.closeOnUnfocus) {
-                cm.off("blur", this.onBlur);
-                cm.off("focus", this.onFocus);
-              }
-              cm.off("scroll", this.onScroll);
-            },
-            disable: function () {
-              this.completion.cm.removeKeyMap(this.keyMap);
-              var widget = this;
-              this.keyMap = {
-                Enter: function () {
-                  widget.picked = true;
-                },
-              };
-              this.completion.cm.addKeyMap(this.keyMap);
-            },
-            pick: function () {
-              this.completion.pick(this.data, this.selectedHint);
-            },
-            changeActive: function (i, avoidWrap) {
-              if (i >= this.data.list.length)
-                i = avoidWrap ? this.data.list.length - 1 : 0;
-              else if (i < 0) i = avoidWrap ? 0 : this.data.list.length - 1;
-              if (this.selectedHint == i) return;
-              var node = this.hints.childNodes[this.selectedHint];
-              if (node) {
-                node.className = node.className.replace(
-                  " " + ACTIVE_HINT_ELEMENT_CLASS,
-                  ""
-                );
-                node.removeAttribute("aria-selected");
-              }
-              node = this.hints.childNodes[(this.selectedHint = i)];
-              node.className += " " + ACTIVE_HINT_ELEMENT_CLASS;
-              node.setAttribute("aria-selected", "true");
-              this.completion.cm
-                .getInputField()
-                .setAttribute("aria-activedescendant", node.id);
-              this.scrollToActive();
-              CodeMirror.signal(
-                this.data,
-                "select",
-                this.data.list[this.selectedHint],
-                node
-              );
-            },
-            scrollToActive: function () {
-              var selectedHintRange = this.getSelectedHintRange();
-              var node1 = this.hints.childNodes[selectedHintRange.from];
-              var node2 = this.hints.childNodes[selectedHintRange.to];
-              var firstNode = this.hints.firstChild;
-              if (node1.offsetTop < this.hints.scrollTop)
-                this.hints.scrollTop = node1.offsetTop - firstNode.offsetTop;
-              else if (
-                node2.offsetTop + node2.offsetHeight >
-                this.hints.scrollTop + this.hints.clientHeight
-              )
-                this.hints.scrollTop =
-                  node2.offsetTop +
-                  node2.offsetHeight -
-                  this.hints.clientHeight +
-                  firstNode.offsetTop;
-            },
-            screenAmount: function () {
-              return (
-                Math.floor(
-                  this.hints.clientHeight / this.hints.firstChild.offsetHeight
-                ) || 1
-              );
-            },
-            getSelectedHintRange: function () {
-              var margin = this.completion.options.scrollMargin || 0;
-              return {
-                from: Math.max(0, this.selectedHint - margin),
-                to: Math.min(
-                  this.data.list.length - 1,
-                  this.selectedHint + margin
-                ),
-              };
-            },
-          };
-          function applicableHelpers(cm, helpers2) {
-            if (!cm.somethingSelected()) return helpers2;
-            var result2 = [];
-            for (var i = 0; i < helpers2.length; i++)
-              if (helpers2[i].supportsSelection) result2.push(helpers2[i]);
-            return result2;
-          }
-          function fetchHints(hint2, cm, options, callback) {
-            if (hint2.async) {
-              hint2(cm, callback, options);
-            } else {
-              var result2 = hint2(cm, options);
-              if (result2 && result2.then) result2.then(callback);
-              else callback(result2);
-            }
-          }
-          function resolveAutoHints(cm, pos) {
-            var helpers2 = cm.getHelpers(pos, "hint"),
-              words;
-            if (helpers2.length) {
-              var resolved = function (cm2, callback, options) {
-                var app = applicableHelpers(cm2, helpers2);
-                function run(i) {
-                  if (i == app.length) return callback(null);
-                  fetchHints(app[i], cm2, options, function (result2) {
-                    if (result2 && result2.list.length > 0) callback(result2);
-                    else run(i + 1);
-                  });
-                }
-                run(0);
-              };
-              resolved.async = true;
-              resolved.supportsSelection = true;
-              return resolved;
-            } else if ((words = cm.getHelper(cm.getCursor(), "hintWords"))) {
-              return function (cm2) {
-                return CodeMirror.hint.fromList(cm2, { words });
-              };
-            } else if (CodeMirror.hint.anyword) {
-              return function (cm2, options) {
-                return CodeMirror.hint.anyword(cm2, options);
-              };
-            } else {
-              return function () {};
-            }
-          }
-          CodeMirror.registerHelper("hint", "auto", {
-            resolve: resolveAutoHints,
-          });
-          CodeMirror.registerHelper("hint", "fromList", function (cm, options) {
-            var cur = cm.getCursor(),
-              token2 = cm.getTokenAt(cur);
-            var term,
-              from = CodeMirror.Pos(cur.line, token2.start),
-              to = cur;
-            if (
-              token2.start < cur.ch &&
-              /\w/.test(token2.string.charAt(cur.ch - token2.start - 1))
-            ) {
-              term = token2.string.substr(0, cur.ch - token2.start);
-            } else {
-              term = "";
-              from = cur;
-            }
-            var found = [];
-            for (var i = 0; i < options.words.length; i++) {
-              var word2 = options.words[i];
-              if (word2.slice(0, term.length) == term) found.push(word2);
-            }
-            if (found.length) return { list: found, from, to };
-          });
-          CodeMirror.commands.autocomplete = CodeMirror.showHint;
-          var defaultOptions2 = {
-            hint: CodeMirror.hint.auto,
-            completeSingle: true,
-            alignWithWord: true,
-            closeCharacters: /[\s()\[\]{};:>,]/,
-            closeOnPick: true,
-            closeOnUnfocus: true,
-            updateOnCursorActivity: true,
-            completeOnSingleClick: true,
-            container: null,
-            customKeys: null,
-            extraKeys: null,
-            paddingForScrollbar: true,
-            moveOnOverlap: true,
-          };
-          CodeMirror.defineOption("hintOptions", null);
-        });
-      })();
-      var showHint = showHint$2.exports;
-      var showHint$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: showHint,
-          },
-          [showHint$2.exports]
-        )
-      );
-      var matchbrackets$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports);
-        })(function (CodeMirror) {
-          var ie_lt8 =
-            /MSIE \d/.test(navigator.userAgent) &&
-            (document.documentMode == null || document.documentMode < 8);
-          var Pos = CodeMirror.Pos;
-          var matching = {
-            "(": ")>",
-            ")": "(<",
-            "[": "]>",
-            "]": "[<",
-            "{": "}>",
-            "}": "{<",
-            "<": ">>",
-            ">": "<<",
-          };
-          function bracketRegex(config2) {
-            return (config2 && config2.bracketRegex) || /[(){}[\]]/;
-          }
-          function findMatchingBracket(cm, where, config2) {
-            var line = cm.getLineHandle(where.line),
-              pos = where.ch - 1;
-            var afterCursor = config2 && config2.afterCursor;
-            if (afterCursor == null)
-              afterCursor = /(^| )cm-fat-cursor($| )/.test(
-                cm.getWrapperElement().className
-              );
-            var re2 = bracketRegex(config2);
-            var match2 =
-              (!afterCursor &&
-                pos >= 0 &&
-                re2.test(line.text.charAt(pos)) &&
-                matching[line.text.charAt(pos)]) ||
-              (re2.test(line.text.charAt(pos + 1)) &&
-                matching[line.text.charAt(++pos)]);
-            if (!match2) return null;
-            var dir = match2.charAt(1) == ">" ? 1 : -1;
-            if (config2 && config2.strict && dir > 0 != (pos == where.ch))
-              return null;
-            var style = cm.getTokenTypeAt(Pos(where.line, pos + 1));
-            var found = scanForBracket(
-              cm,
-              Pos(where.line, pos + (dir > 0 ? 1 : 0)),
-              dir,
-              style,
-              config2
-            );
-            if (found == null) return null;
-            return {
-              from: Pos(where.line, pos),
-              to: found && found.pos,
-              match: found && found.ch == match2.charAt(0),
-              forward: dir > 0,
-            };
-          }
-          function scanForBracket(cm, where, dir, style, config2) {
-            var maxScanLen = (config2 && config2.maxScanLineLength) || 1e4;
-            var maxScanLines = (config2 && config2.maxScanLines) || 1e3;
-            var stack = [];
-            var re2 = bracketRegex(config2);
-            var lineEnd =
-              dir > 0
-                ? Math.min(where.line + maxScanLines, cm.lastLine() + 1)
-                : Math.max(cm.firstLine() - 1, where.line - maxScanLines);
-            for (var lineNo = where.line; lineNo != lineEnd; lineNo += dir) {
-              var line = cm.getLine(lineNo);
-              if (!line) continue;
-              var pos = dir > 0 ? 0 : line.length - 1,
-                end2 = dir > 0 ? line.length : -1;
-              if (line.length > maxScanLen) continue;
-              if (lineNo == where.line) pos = where.ch - (dir < 0 ? 1 : 0);
-              for (; pos != end2; pos += dir) {
-                var ch2 = line.charAt(pos);
-                if (
-                  re2.test(ch2) &&
-                  (style === void 0 ||
-                    (cm.getTokenTypeAt(Pos(lineNo, pos + 1)) || "") ==
-                      (style || ""))
-                ) {
-                  var match2 = matching[ch2];
-                  if (match2 && (match2.charAt(1) == ">") == dir > 0)
-                    stack.push(ch2);
-                  else if (!stack.length)
-                    return { pos: Pos(lineNo, pos), ch: ch2 };
-                  else stack.pop();
-                }
-              }
-            }
-            return lineNo - dir == (dir > 0 ? cm.lastLine() : cm.firstLine())
-              ? false
-              : null;
-          }
-          function matchBrackets(cm, autoclear, config2) {
-            var maxHighlightLen =
-                cm.state.matchBrackets.maxHighlightLineLength || 1e3,
-              highlightNonMatching = config2 && config2.highlightNonMatching;
-            var marks = [],
-              ranges = cm.listSelections();
-            for (var i = 0; i < ranges.length; i++) {
-              var match2 =
-                ranges[i].empty() &&
-                findMatchingBracket(cm, ranges[i].head, config2);
-              if (
-                match2 &&
-                (match2.match || highlightNonMatching !== false) &&
-                cm.getLine(match2.from.line).length <= maxHighlightLen
-              ) {
-                var style = match2.match
-                  ? "CodeMirror-matchingbracket"
-                  : "CodeMirror-nonmatchingbracket";
-                marks.push(
-                  cm.markText(
-                    match2.from,
-                    Pos(match2.from.line, match2.from.ch + 1),
-                    { className: style }
-                  )
-                );
-                if (
-                  match2.to &&
-                  cm.getLine(match2.to.line).length <= maxHighlightLen
-                )
-                  marks.push(
-                    cm.markText(
-                      match2.to,
-                      Pos(match2.to.line, match2.to.ch + 1),
-                      { className: style }
-                    )
-                  );
-              }
-            }
-            if (marks.length) {
-              if (ie_lt8 && cm.state.focused) cm.focus();
-              var clear = function () {
-                cm.operation(function () {
-                  for (var i2 = 0; i2 < marks.length; i2++) marks[i2].clear();
-                });
-              };
-              if (autoclear) setTimeout(clear, 800);
-              else return clear;
-            }
-          }
-          function doMatchBrackets(cm) {
-            cm.operation(function () {
-              if (cm.state.matchBrackets.currentlyHighlighted) {
-                cm.state.matchBrackets.currentlyHighlighted();
-                cm.state.matchBrackets.currentlyHighlighted = null;
-              }
-              cm.state.matchBrackets.currentlyHighlighted = matchBrackets(
-                cm,
-                false,
-                cm.state.matchBrackets
-              );
-            });
-          }
-          function clearHighlighted(cm) {
-            if (
-              cm.state.matchBrackets &&
-              cm.state.matchBrackets.currentlyHighlighted
-            ) {
-              cm.state.matchBrackets.currentlyHighlighted();
-              cm.state.matchBrackets.currentlyHighlighted = null;
-            }
-          }
-          CodeMirror.defineOption(
-            "matchBrackets",
-            false,
-            function (cm, val, old) {
-              if (old && old != CodeMirror.Init) {
-                cm.off("cursorActivity", doMatchBrackets);
-                cm.off("focus", doMatchBrackets);
-                cm.off("blur", clearHighlighted);
-                clearHighlighted(cm);
-              }
-              if (val) {
-                cm.state.matchBrackets = typeof val == "object" ? val : {};
-                cm.on("cursorActivity", doMatchBrackets);
-                cm.on("focus", doMatchBrackets);
-                cm.on("blur", clearHighlighted);
-              }
-            }
-          );
-          CodeMirror.defineExtension("matchBrackets", function () {
-            matchBrackets(this, true);
-          });
-          CodeMirror.defineExtension(
-            "findMatchingBracket",
-            function (pos, config2, oldConfig) {
-              if (oldConfig || typeof config2 == "boolean") {
-                if (!oldConfig) {
-                  config2 = config2 ? { strict: true } : null;
-                } else {
-                  oldConfig.strict = config2;
-                  config2 = oldConfig;
-                }
-              }
-              return findMatchingBracket(this, pos, config2);
-            }
-          );
-          CodeMirror.defineExtension(
-            "scanForBracket",
-            function (pos, dir, style, config2) {
-              return scanForBracket(this, pos, dir, style, config2);
-            }
-          );
-        });
-      })();
-      var matchbrackets = matchbrackets$2.exports;
-      var matchbrackets$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: matchbrackets,
-          },
-          [matchbrackets$2.exports]
-        )
-      );
-      var closebrackets$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports);
-        })(function (CodeMirror) {
-          var defaults2 = {
-            pairs: `()[]{}''""`,
-            closeBefore: `)]}'":;>`,
-            triples: "",
-            explode: "[]{}",
-          };
-          var Pos = CodeMirror.Pos;
-          CodeMirror.defineOption(
-            "autoCloseBrackets",
-            false,
-            function (cm, val, old) {
-              if (old && old != CodeMirror.Init) {
-                cm.removeKeyMap(keyMap2);
-                cm.state.closeBrackets = null;
-              }
-              if (val) {
-                ensureBound(getOption(val, "pairs"));
-                cm.state.closeBrackets = val;
-                cm.addKeyMap(keyMap2);
-              }
-            }
-          );
-          function getOption(conf, name2) {
-            if (name2 == "pairs" && typeof conf == "string") return conf;
-            if (typeof conf == "object" && conf[name2] != null)
-              return conf[name2];
-            return defaults2[name2];
-          }
-          var keyMap2 = { Backspace: handleBackspace, Enter: handleEnter };
-          function ensureBound(chars) {
-            for (var i = 0; i < chars.length; i++) {
-              var ch2 = chars.charAt(i),
-                key = "'" + ch2 + "'";
-              if (!keyMap2[key]) keyMap2[key] = handler(ch2);
-            }
-          }
-          ensureBound(defaults2.pairs + "`");
-          function handler(ch2) {
-            return function (cm) {
-              return handleChar(cm, ch2);
-            };
-          }
-          function getConfig(cm) {
-            var deflt = cm.state.closeBrackets;
-            if (!deflt || deflt.override) return deflt;
-            var mode2 = cm.getModeAt(cm.getCursor());
-            return mode2.closeBrackets || deflt;
-          }
-          function handleBackspace(cm) {
-            var conf = getConfig(cm);
-            if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass;
-            var pairs = getOption(conf, "pairs");
-            var ranges = cm.listSelections();
-            for (var i = 0; i < ranges.length; i++) {
-              if (!ranges[i].empty()) return CodeMirror.Pass;
-              var around = charsAround(cm, ranges[i].head);
-              if (!around || pairs.indexOf(around) % 2 != 0)
-                return CodeMirror.Pass;
-            }
-            for (var i = ranges.length - 1; i >= 0; i--) {
-              var cur = ranges[i].head;
-              cm.replaceRange(
-                "",
-                Pos(cur.line, cur.ch - 1),
-                Pos(cur.line, cur.ch + 1),
-                "+delete"
-              );
-            }
-          }
-          function handleEnter(cm) {
-            var conf = getConfig(cm);
-            var explode = conf && getOption(conf, "explode");
-            if (!explode || cm.getOption("disableInput"))
-              return CodeMirror.Pass;
-            var ranges = cm.listSelections();
-            for (var i = 0; i < ranges.length; i++) {
-              if (!ranges[i].empty()) return CodeMirror.Pass;
-              var around = charsAround(cm, ranges[i].head);
-              if (!around || explode.indexOf(around) % 2 != 0)
-                return CodeMirror.Pass;
-            }
-            cm.operation(function () {
-              var linesep = cm.lineSeparator() || "\n";
-              cm.replaceSelection(linesep + linesep, null);
-              moveSel(cm, -1);
-              ranges = cm.listSelections();
-              for (var i2 = 0; i2 < ranges.length; i2++) {
-                var line = ranges[i2].head.line;
-                cm.indentLine(line, null, true);
-                cm.indentLine(line + 1, null, true);
-              }
-            });
-          }
-          function moveSel(cm, dir) {
-            var newRanges = [],
-              ranges = cm.listSelections(),
-              primary = 0;
-            for (var i = 0; i < ranges.length; i++) {
-              var range2 = ranges[i];
-              if (range2.head == cm.getCursor()) primary = i;
-              var pos =
-                range2.head.ch || dir > 0
-                  ? { line: range2.head.line, ch: range2.head.ch + dir }
-                  : { line: range2.head.line - 1 };
-              newRanges.push({ anchor: pos, head: pos });
-            }
-            cm.setSelections(newRanges, primary);
-          }
-          function contractSelection(sel) {
-            var inverted = CodeMirror.cmpPos(sel.anchor, sel.head) > 0;
-            return {
-              anchor: new Pos(
-                sel.anchor.line,
-                sel.anchor.ch + (inverted ? -1 : 1)
-              ),
-              head: new Pos(sel.head.line, sel.head.ch + (inverted ? 1 : -1)),
-            };
-          }
-          function handleChar(cm, ch2) {
-            var conf = getConfig(cm);
-            if (!conf || cm.getOption("disableInput")) return CodeMirror.Pass;
-            var pairs = getOption(conf, "pairs");
-            var pos = pairs.indexOf(ch2);
-            if (pos == -1) return CodeMirror.Pass;
-            var closeBefore = getOption(conf, "closeBefore");
-            var triples = getOption(conf, "triples");
-            var identical2 = pairs.charAt(pos + 1) == ch2;
-            var ranges = cm.listSelections();
-            var opening = pos % 2 == 0;
-            var type2;
-            for (var i = 0; i < ranges.length; i++) {
-              var range2 = ranges[i],
-                cur = range2.head,
-                curType;
-              var next = cm.getRange(cur, Pos(cur.line, cur.ch + 1));
-              if (opening && !range2.empty()) {
-                curType = "surround";
-              } else if ((identical2 || !opening) && next == ch2) {
-                if (identical2 && stringStartsAfter(cm, cur)) curType = "both";
-                else if (
-                  triples.indexOf(ch2) >= 0 &&
-                  cm.getRange(cur, Pos(cur.line, cur.ch + 3)) == ch2 + ch2 + ch2
-                )
-                  curType = "skipThree";
-                else curType = "skip";
-              } else if (
-                identical2 &&
-                cur.ch > 1 &&
-                triples.indexOf(ch2) >= 0 &&
-                cm.getRange(Pos(cur.line, cur.ch - 2), cur) == ch2 + ch2
-              ) {
-                if (
-                  cur.ch > 2 &&
-                  /\bstring/.test(cm.getTokenTypeAt(Pos(cur.line, cur.ch - 2)))
-                )
-                  return CodeMirror.Pass;
-                curType = "addFour";
-              } else if (identical2) {
-                var prev =
-                  cur.ch == 0
-                    ? " "
-                    : cm.getRange(Pos(cur.line, cur.ch - 1), cur);
-                if (
-                  !CodeMirror.isWordChar(next) &&
-                  prev != ch2 &&
-                  !CodeMirror.isWordChar(prev)
-                )
-                  curType = "both";
-                else return CodeMirror.Pass;
-              } else if (
-                opening &&
-                (next.length === 0 ||
-                  /\s/.test(next) ||
-                  closeBefore.indexOf(next) > -1)
-              ) {
-                curType = "both";
-              } else {
-                return CodeMirror.Pass;
-              }
-              if (!type2) type2 = curType;
-              else if (type2 != curType) return CodeMirror.Pass;
-            }
-            var left = pos % 2 ? pairs.charAt(pos - 1) : ch2;
-            var right = pos % 2 ? ch2 : pairs.charAt(pos + 1);
-            cm.operation(function () {
-              if (type2 == "skip") {
-                moveSel(cm, 1);
-              } else if (type2 == "skipThree") {
-                moveSel(cm, 3);
-              } else if (type2 == "surround") {
-                var sels = cm.getSelections();
-                for (var i2 = 0; i2 < sels.length; i2++)
-                  sels[i2] = left + sels[i2] + right;
-                cm.replaceSelections(sels, "around");
-                sels = cm.listSelections().slice();
-                for (var i2 = 0; i2 < sels.length; i2++)
-                  sels[i2] = contractSelection(sels[i2]);
-                cm.setSelections(sels);
-              } else if (type2 == "both") {
-                cm.replaceSelection(left + right, null);
-                cm.triggerElectric(left + right);
-                moveSel(cm, -1);
-              } else if (type2 == "addFour") {
-                cm.replaceSelection(left + left + left + left, "before");
-                moveSel(cm, 1);
-              }
-            });
-          }
-          function charsAround(cm, pos) {
-            var str = cm.getRange(
-              Pos(pos.line, pos.ch - 1),
-              Pos(pos.line, pos.ch + 1)
-            );
-            return str.length == 2 ? str : null;
-          }
-          function stringStartsAfter(cm, pos) {
-            var token2 = cm.getTokenAt(Pos(pos.line, pos.ch + 1));
-            return (
-              /\bstring/.test(token2.type) &&
-              token2.start == pos.ch &&
-              (pos.ch == 0 || !/\bstring/.test(cm.getTokenTypeAt(pos)))
-            );
-          }
-        });
-      })();
-      var closebrackets = closebrackets$2.exports;
-      var closebrackets$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: closebrackets,
-          },
-          [closebrackets$2.exports]
-        )
-      );
-      var braceFold$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports);
-        })(function (CodeMirror) {
-          function bracketFolding(pairs) {
-            return function (cm, start2) {
-              var line = start2.line,
-                lineText = cm.getLine(line);
-              function findOpening(pair) {
-                var tokenType;
-                for (var at = start2.ch, pass = 0; ; ) {
-                  var found2 =
-                    at <= 0 ? -1 : lineText.lastIndexOf(pair[0], at - 1);
-                  if (found2 == -1) {
-                    if (pass == 1) break;
-                    pass = 1;
-                    at = lineText.length;
-                    continue;
-                  }
-                  if (pass == 1 && found2 < start2.ch) break;
-                  tokenType = cm.getTokenTypeAt(
-                    CodeMirror.Pos(line, found2 + 1)
-                  );
-                  if (!/^(comment|string)/.test(tokenType))
-                    return { ch: found2 + 1, tokenType, pair };
-                  at = found2 - 1;
-                }
-              }
-              function findRange(found2) {
-                var count = 1,
-                  lastLine = cm.lastLine(),
-                  end2,
-                  startCh = found2.ch,
-                  endCh;
-                outer: for (var i2 = line; i2 <= lastLine; ++i2) {
-                  var text3 = cm.getLine(i2),
-                    pos = i2 == line ? startCh : 0;
-                  for (;;) {
-                    var nextOpen = text3.indexOf(found2.pair[0], pos),
-                      nextClose = text3.indexOf(found2.pair[1], pos);
-                    if (nextOpen < 0) nextOpen = text3.length;
-                    if (nextClose < 0) nextClose = text3.length;
-                    pos = Math.min(nextOpen, nextClose);
-                    if (pos == text3.length) break;
-                    if (
-                      cm.getTokenTypeAt(CodeMirror.Pos(i2, pos + 1)) ==
-                      found2.tokenType
-                    ) {
-                      if (pos == nextOpen) ++count;
-                      else if (!--count) {
-                        end2 = i2;
-                        endCh = pos;
-                        break outer;
-                      }
-                    }
-                    ++pos;
-                  }
-                }
-                if (end2 == null || line == end2) return null;
-                return {
-                  from: CodeMirror.Pos(line, startCh),
-                  to: CodeMirror.Pos(end2, endCh),
-                };
-              }
-              var found = [];
-              for (var i = 0; i < pairs.length; i++) {
-                var open = findOpening(pairs[i]);
-                if (open) found.push(open);
-              }
-              found.sort(function (a, b) {
-                return a.ch - b.ch;
-              });
-              for (var i = 0; i < found.length; i++) {
-                var range2 = findRange(found[i]);
-                if (range2) return range2;
-              }
-              return null;
-            };
-          }
-          CodeMirror.registerHelper(
-            "fold",
-            "brace",
-            bracketFolding([
-              ["{", "}"],
-              ["[", "]"],
-            ])
-          );
-          CodeMirror.registerHelper(
-            "fold",
-            "brace-paren",
-            bracketFolding([
-              ["{", "}"],
-              ["[", "]"],
-              ["(", ")"],
-            ])
-          );
-          CodeMirror.registerHelper("fold", "import", function (cm, start2) {
-            function hasImport(line) {
-              if (line < cm.firstLine() || line > cm.lastLine()) return null;
-              var start3 = cm.getTokenAt(CodeMirror.Pos(line, 1));
-              if (!/\S/.test(start3.string))
-                start3 = cm.getTokenAt(CodeMirror.Pos(line, start3.end + 1));
-              if (start3.type != "keyword" || start3.string != "import")
-                return null;
-              for (
-                var i = line, e = Math.min(cm.lastLine(), line + 10);
-                i <= e;
-                ++i
-              ) {
-                var text3 = cm.getLine(i),
-                  semi2 = text3.indexOf(";");
-                if (semi2 != -1)
-                  return { startCh: start3.end, end: CodeMirror.Pos(i, semi2) };
-              }
-            }
-            var startLine = start2.line,
-              has2 = hasImport(startLine),
-              prev;
-            if (
-              !has2 ||
-              hasImport(startLine - 1) ||
-              ((prev = hasImport(startLine - 2)) &&
-                prev.end.line == startLine - 1)
-            )
-              return null;
-            for (var end2 = has2.end; ; ) {
-              var next = hasImport(end2.line + 1);
-              if (next == null) break;
-              end2 = next.end;
-            }
-            return {
-              from: cm.clipPos(CodeMirror.Pos(startLine, has2.startCh + 1)),
-              to: end2,
-            };
-          });
-          CodeMirror.registerHelper("fold", "include", function (cm, start2) {
-            function hasInclude(line) {
-              if (line < cm.firstLine() || line > cm.lastLine()) return null;
-              var start3 = cm.getTokenAt(CodeMirror.Pos(line, 1));
-              if (!/\S/.test(start3.string))
-                start3 = cm.getTokenAt(CodeMirror.Pos(line, start3.end + 1));
-              if (
-                start3.type == "meta" &&
-                start3.string.slice(0, 8) == "#include"
-              )
-                return start3.start + 8;
-            }
-            var startLine = start2.line,
-              has2 = hasInclude(startLine);
-            if (has2 == null || hasInclude(startLine - 1) != null) return null;
-            for (var end2 = startLine; ; ) {
-              var next = hasInclude(end2 + 1);
-              if (next == null) break;
-              ++end2;
-            }
-            return {
-              from: CodeMirror.Pos(startLine, has2 + 1),
-              to: cm.clipPos(CodeMirror.Pos(end2)),
-            };
-          });
-        });
-      })();
-      var braceFold = braceFold$2.exports;
-      var braceFold$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: braceFold,
-          },
-          [braceFold$2.exports]
-        )
-      );
-      var foldgutter$2 = { exports: {} };
-      var foldcode = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports);
-        })(function (CodeMirror) {
-          function doFold(cm, pos, options, force) {
-            if (options && options.call) {
-              var finder = options;
-              options = null;
-            } else {
-              var finder = getOption(cm, options, "rangeFinder");
-            }
-            if (typeof pos == "number") pos = CodeMirror.Pos(pos, 0);
-            var minSize = getOption(cm, options, "minFoldSize");
-            function getRange2(allowFolded) {
-              var range3 = finder(cm, pos);
-              if (!range3 || range3.to.line - range3.from.line < minSize)
-                return null;
-              if (force === "fold") return range3;
-              var marks = cm.findMarksAt(range3.from);
-              for (var i = 0; i < marks.length; ++i) {
-                if (marks[i].__isFold) {
-                  if (!allowFolded) return null;
-                  range3.cleared = true;
-                  marks[i].clear();
-                }
-              }
-              return range3;
-            }
-            var range2 = getRange2(true);
-            if (getOption(cm, options, "scanUp"))
-              while (!range2 && pos.line > cm.firstLine()) {
-                pos = CodeMirror.Pos(pos.line - 1, 0);
-                range2 = getRange2(false);
-              }
-            if (!range2 || range2.cleared || force === "unfold") return;
-            var myWidget = makeWidget(cm, options, range2);
-            CodeMirror.on(myWidget, "mousedown", function (e) {
-              myRange.clear();
-              CodeMirror.e_preventDefault(e);
-            });
-            var myRange = cm.markText(range2.from, range2.to, {
-              replacedWith: myWidget,
-              clearOnEnter: getOption(cm, options, "clearOnEnter"),
-              __isFold: true,
-            });
-            myRange.on("clear", function (from, to) {
-              CodeMirror.signal(cm, "unfold", cm, from, to);
-            });
-            CodeMirror.signal(cm, "fold", cm, range2.from, range2.to);
-          }
-          function makeWidget(cm, options, range2) {
-            var widget = getOption(cm, options, "widget");
-            if (typeof widget == "function") {
-              widget = widget(range2.from, range2.to);
-            }
-            if (typeof widget == "string") {
-              var text3 = document.createTextNode(widget);
-              widget = document.createElement("span");
-              widget.appendChild(text3);
-              widget.className = "CodeMirror-foldmarker";
-            } else if (widget) {
-              widget = widget.cloneNode(true);
-            }
-            return widget;
-          }
-          CodeMirror.newFoldFunction = function (rangeFinder, widget) {
-            return function (cm, pos) {
-              doFold(cm, pos, { rangeFinder, widget });
-            };
-          };
-          CodeMirror.defineExtension(
-            "foldCode",
-            function (pos, options, force) {
-              doFold(this, pos, options, force);
-            }
-          );
-          CodeMirror.defineExtension("isFolded", function (pos) {
-            var marks = this.findMarksAt(pos);
-            for (var i = 0; i < marks.length; ++i)
-              if (marks[i].__isFold) return true;
-          });
-          CodeMirror.commands.toggleFold = function (cm) {
-            cm.foldCode(cm.getCursor());
-          };
-          CodeMirror.commands.fold = function (cm) {
-            cm.foldCode(cm.getCursor(), null, "fold");
-          };
-          CodeMirror.commands.unfold = function (cm) {
-            cm.foldCode(cm.getCursor(), { scanUp: false }, "unfold");
-          };
-          CodeMirror.commands.foldAll = function (cm) {
-            cm.operation(function () {
-              for (var i = cm.firstLine(), e = cm.lastLine(); i <= e; i++)
-                cm.foldCode(CodeMirror.Pos(i, 0), { scanUp: false }, "fold");
-            });
-          };
-          CodeMirror.commands.unfoldAll = function (cm) {
-            cm.operation(function () {
-              for (var i = cm.firstLine(), e = cm.lastLine(); i <= e; i++)
-                cm.foldCode(CodeMirror.Pos(i, 0), { scanUp: false }, "unfold");
-            });
-          };
-          CodeMirror.registerHelper("fold", "combine", function () {
-            var funcs = Array.prototype.slice.call(arguments, 0);
-            return function (cm, start2) {
-              for (var i = 0; i < funcs.length; ++i) {
-                var found = funcs[i](cm, start2);
-                if (found) return found;
-              }
-            };
-          });
-          CodeMirror.registerHelper("fold", "auto", function (cm, start2) {
-            var helpers2 = cm.getHelpers(start2, "fold");
-            for (var i = 0; i < helpers2.length; i++) {
-              var cur = helpers2[i](cm, start2);
-              if (cur) return cur;
-            }
-          });
-          var defaultOptions2 = {
-            rangeFinder: CodeMirror.fold.auto,
-            widget: "\u2194",
-            minFoldSize: 0,
-            scanUp: false,
-            clearOnEnter: true,
-          };
-          CodeMirror.defineOption("foldOptions", null);
-          function getOption(cm, options, name2) {
-            if (options && options[name2] !== void 0) return options[name2];
-            var editorOptions = cm.options.foldOptions;
-            if (editorOptions && editorOptions[name2] !== void 0)
-              return editorOptions[name2];
-            return defaultOptions2[name2];
-          }
-          CodeMirror.defineExtension("foldOption", function (options, name2) {
-            return getOption(this, options, name2);
-          });
-        });
-      })();
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports, foldcode.exports);
-        })(function (CodeMirror) {
-          CodeMirror.defineOption("foldGutter", false, function (cm, val, old) {
-            if (old && old != CodeMirror.Init) {
-              cm.clearGutter(cm.state.foldGutter.options.gutter);
-              cm.state.foldGutter = null;
-              cm.off("gutterClick", onGutterClick);
-              cm.off("changes", onChange);
-              cm.off("viewportChange", onViewportChange);
-              cm.off("fold", onFold);
-              cm.off("unfold", onFold);
-              cm.off("swapDoc", onChange);
-            }
-            if (val) {
-              cm.state.foldGutter = new State(parseOptions(val));
-              updateInViewport(cm);
-              cm.on("gutterClick", onGutterClick);
-              cm.on("changes", onChange);
-              cm.on("viewportChange", onViewportChange);
-              cm.on("fold", onFold);
-              cm.on("unfold", onFold);
-              cm.on("swapDoc", onChange);
-            }
-          });
-          var Pos = CodeMirror.Pos;
-          function State(options) {
-            this.options = options;
-            this.from = this.to = 0;
-          }
-          function parseOptions(opts) {
-            if (opts === true) opts = {};
-            if (opts.gutter == null) opts.gutter = "CodeMirror-foldgutter";
-            if (opts.indicatorOpen == null)
-              opts.indicatorOpen = "CodeMirror-foldgutter-open";
-            if (opts.indicatorFolded == null)
-              opts.indicatorFolded = "CodeMirror-foldgutter-folded";
-            return opts;
-          }
-          function isFolded(cm, line) {
-            var marks = cm.findMarks(Pos(line, 0), Pos(line + 1, 0));
-            for (var i = 0; i < marks.length; ++i) {
-              if (marks[i].__isFold) {
-                var fromPos = marks[i].find(-1);
-                if (fromPos && fromPos.line === line) return marks[i];
-              }
-            }
-          }
-          function marker2(spec) {
-            if (typeof spec == "string") {
-              var elt = document.createElement("div");
-              elt.className = spec + " CodeMirror-guttermarker-subtle";
-              return elt;
-            } else {
-              return spec.cloneNode(true);
-            }
-          }
-          function updateFoldInfo(cm, from, to) {
-            var opts = cm.state.foldGutter.options,
-              cur = from - 1;
-            var minSize = cm.foldOption(opts, "minFoldSize");
-            var func = cm.foldOption(opts, "rangeFinder");
-            var clsFolded =
-              typeof opts.indicatorFolded == "string" &&
-              classTest(opts.indicatorFolded);
-            var clsOpen =
-              typeof opts.indicatorOpen == "string" &&
-              classTest(opts.indicatorOpen);
-            cm.eachLine(from, to, function (line) {
-              ++cur;
-              var mark = null;
-              var old = line.gutterMarkers;
-              if (old) old = old[opts.gutter];
-              if (isFolded(cm, cur)) {
-                if (clsFolded && old && clsFolded.test(old.className)) return;
-                mark = marker2(opts.indicatorFolded);
-              } else {
-                var pos = Pos(cur, 0);
-                var range2 = func && func(cm, pos);
-                if (range2 && range2.to.line - range2.from.line >= minSize) {
-                  if (clsOpen && old && clsOpen.test(old.className)) return;
-                  mark = marker2(opts.indicatorOpen);
-                }
-              }
-              if (!mark && !old) return;
-              cm.setGutterMarker(line, opts.gutter, mark);
-            });
-          }
-          function classTest(cls) {
-            return new RegExp("(^|\\s)" + cls + "(?:$|\\s)\\s*");
-          }
-          function updateInViewport(cm) {
-            var vp = cm.getViewport(),
-              state = cm.state.foldGutter;
-            if (!state) return;
-            cm.operation(function () {
-              updateFoldInfo(cm, vp.from, vp.to);
-            });
-            state.from = vp.from;
-            state.to = vp.to;
-          }
-          function onGutterClick(cm, line, gutter) {
-            var state = cm.state.foldGutter;
-            if (!state) return;
-            var opts = state.options;
-            if (gutter != opts.gutter) return;
-            var folded = isFolded(cm, line);
-            if (folded) folded.clear();
-            else cm.foldCode(Pos(line, 0), opts);
-          }
-          function onChange(cm) {
-            var state = cm.state.foldGutter;
-            if (!state) return;
-            var opts = state.options;
-            state.from = state.to = 0;
-            clearTimeout(state.changeUpdate);
-            state.changeUpdate = setTimeout(function () {
-              updateInViewport(cm);
-            }, opts.foldOnChangeTimeSpan || 600);
-          }
-          function onViewportChange(cm) {
-            var state = cm.state.foldGutter;
-            if (!state) return;
-            var opts = state.options;
-            clearTimeout(state.changeUpdate);
-            state.changeUpdate = setTimeout(function () {
-              var vp = cm.getViewport();
-              if (
-                state.from == state.to ||
-                vp.from - state.to > 20 ||
-                state.from - vp.to > 20
-              ) {
-                updateInViewport(cm);
-              } else {
-                cm.operation(function () {
-                  if (vp.from < state.from) {
-                    updateFoldInfo(cm, vp.from, state.from);
-                    state.from = vp.from;
-                  }
-                  if (vp.to > state.to) {
-                    updateFoldInfo(cm, state.to, vp.to);
-                    state.to = vp.to;
-                  }
-                });
-              }
-            }, opts.updateViewportTimeSpan || 400);
-          }
-          function onFold(cm, from) {
-            var state = cm.state.foldGutter;
-            if (!state) return;
-            var line = from.line;
-            if (line >= state.from && line < state.to)
-              updateFoldInfo(cm, line, line + 1);
-          }
-        });
-      })();
-      var foldgutter = foldgutter$2.exports;
-      var foldgutter$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: foldgutter,
-          },
-          [foldgutter$2.exports]
-        )
-      );
-      var lint$6 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports);
-        })(function (CodeMirror) {
-          var GUTTER_ID = "CodeMirror-lint-markers";
-          var LINT_LINE_ID = "CodeMirror-lint-line-";
-          function showTooltip(cm, e, content) {
-            var tt = document.createElement("div");
-            tt.className = "CodeMirror-lint-tooltip cm-s-" + cm.options.theme;
-            tt.appendChild(content.cloneNode(true));
-            if (cm.state.lint.options.selfContain)
-              cm.getWrapperElement().appendChild(tt);
-            else document.body.appendChild(tt);
-            function position(e2) {
-              if (!tt.parentNode)
-                return CodeMirror.off(document, "mousemove", position);
-              tt.style.top =
-                Math.max(0, e2.clientY - tt.offsetHeight - 5) + "px";
-              tt.style.left = e2.clientX + 5 + "px";
-            }
-            CodeMirror.on(document, "mousemove", position);
-            position(e);
-            if (tt.style.opacity != null) tt.style.opacity = 1;
-            return tt;
-          }
-          function rm(elt) {
-            if (elt.parentNode) elt.parentNode.removeChild(elt);
-          }
-          function hideTooltip(tt) {
-            if (!tt.parentNode) return;
-            if (tt.style.opacity == null) rm(tt);
-            tt.style.opacity = 0;
-            setTimeout(function () {
-              rm(tt);
-            }, 600);
-          }
-          function showTooltipFor(cm, e, content, node) {
-            var tooltip = showTooltip(cm, e, content);
-            function hide() {
-              CodeMirror.off(node, "mouseout", hide);
-              if (tooltip) {
-                hideTooltip(tooltip);
-                tooltip = null;
-              }
-            }
-            var poll = setInterval(function () {
-              if (tooltip)
-                for (var n2 = node; ; n2 = n2.parentNode) {
-                  if (n2 && n2.nodeType == 11) n2 = n2.host;
-                  if (n2 == document.body) return;
-                  if (!n2) {
-                    hide();
-                    break;
-                  }
-                }
-              if (!tooltip) return clearInterval(poll);
-            }, 400);
-            CodeMirror.on(node, "mouseout", hide);
-          }
-          function LintState(cm, conf, hasGutter) {
-            this.marked = [];
-            if (conf instanceof Function) conf = { getAnnotations: conf };
-            if (!conf || conf === true) conf = {};
-            this.options = {};
-            this.linterOptions = conf.options || {};
-            for (var prop2 in defaults2) this.options[prop2] = defaults2[prop2];
-            for (var prop2 in conf) {
-              if (defaults2.hasOwnProperty(prop2)) {
-                if (conf[prop2] != null) this.options[prop2] = conf[prop2];
-              } else if (!conf.options) {
-                this.linterOptions[prop2] = conf[prop2];
-              }
-            }
-            this.timeout = null;
-            this.hasGutter = hasGutter;
-            this.onMouseOver = function (e) {
-              onMouseOver2(cm, e);
-            };
-            this.waitingFor = 0;
-          }
-          var defaults2 = {
-            highlightLines: false,
-            tooltips: true,
-            delay: 500,
-            lintOnChange: true,
-            getAnnotations: null,
-            async: false,
-            selfContain: null,
-            formatAnnotation: null,
-            onUpdateLinting: null,
-          };
-          function clearMarks(cm) {
-            var state = cm.state.lint;
-            if (state.hasGutter) cm.clearGutter(GUTTER_ID);
-            if (state.options.highlightLines) clearErrorLines(cm);
-            for (var i = 0; i < state.marked.length; ++i)
-              state.marked[i].clear();
-            state.marked.length = 0;
-          }
-          function clearErrorLines(cm) {
-            cm.eachLine(function (line) {
-              var has2 =
-                line.wrapClass &&
-                /\bCodeMirror-lint-line-\w+\b/.exec(line.wrapClass);
-              if (has2) cm.removeLineClass(line, "wrap", has2[0]);
-            });
-          }
-          function makeMarker(cm, labels, severity, multiple, tooltips) {
-            var marker2 = document.createElement("div"),
-              inner = marker2;
-            marker2.className =
-              "CodeMirror-lint-marker CodeMirror-lint-marker-" + severity;
-            if (multiple) {
-              inner = marker2.appendChild(document.createElement("div"));
-              inner.className =
-                "CodeMirror-lint-marker CodeMirror-lint-marker-multiple";
-            }
-            if (tooltips != false)
-              CodeMirror.on(inner, "mouseover", function (e) {
-                showTooltipFor(cm, e, labels, inner);
-              });
-            return marker2;
-          }
-          function getMaxSeverity(a, b) {
-            if (a == "error") return a;
-            else return b;
-          }
-          function groupByLine(annotations2) {
-            var lines = [];
-            for (var i = 0; i < annotations2.length; ++i) {
-              var ann = annotations2[i],
-                line = ann.from.line;
-              (lines[line] || (lines[line] = [])).push(ann);
-            }
-            return lines;
-          }
-          function annotationTooltip(ann) {
-            var severity = ann.severity;
-            if (!severity) severity = "error";
-            var tip = document.createElement("div");
-            tip.className =
-              "CodeMirror-lint-message CodeMirror-lint-message-" + severity;
-            if (typeof ann.messageHTML != "undefined") {
-              tip.innerHTML = ann.messageHTML;
-            } else {
-              tip.appendChild(document.createTextNode(ann.message));
-            }
-            return tip;
-          }
-          function lintAsync(cm, getAnnotations) {
-            var state = cm.state.lint;
-            var id2 = ++state.waitingFor;
-            function abort() {
-              id2 = -1;
-              cm.off("change", abort);
-            }
-            cm.on("change", abort);
-            getAnnotations(
-              cm.getValue(),
-              function (annotations2, arg2) {
-                cm.off("change", abort);
-                if (state.waitingFor != id2) return;
-                if (arg2 && annotations2 instanceof CodeMirror)
-                  annotations2 = arg2;
-                cm.operation(function () {
-                  updateLinting(cm, annotations2);
-                });
-              },
-              state.linterOptions,
-              cm
-            );
-          }
-          function startLinting(cm) {
-            var state = cm.state.lint;
-            if (!state) return;
-            var options = state.options;
-            var getAnnotations =
-              options.getAnnotations ||
-              cm.getHelper(CodeMirror.Pos(0, 0), "lint");
-            if (!getAnnotations) return;
-            if (options.async || getAnnotations.async) {
-              lintAsync(cm, getAnnotations);
-            } else {
-              var annotations2 = getAnnotations(
-                cm.getValue(),
-                state.linterOptions,
-                cm
-              );
-              if (!annotations2) return;
-              if (annotations2.then)
-                annotations2.then(function (issues) {
-                  cm.operation(function () {
-                    updateLinting(cm, issues);
-                  });
-                });
-              else
-                cm.operation(function () {
-                  updateLinting(cm, annotations2);
-                });
-            }
-          }
-          function updateLinting(cm, annotationsNotSorted) {
-            var state = cm.state.lint;
-            if (!state) return;
-            var options = state.options;
-            clearMarks(cm);
-            var annotations2 = groupByLine(annotationsNotSorted);
-            for (var line = 0; line < annotations2.length; ++line) {
-              var anns = annotations2[line];
-              if (!anns) continue;
-              var message = [];
-              anns = anns.filter(function (item) {
-                return message.indexOf(item.message) > -1
-                  ? false
-                  : message.push(item.message);
-              });
-              var maxSeverity = null;
-              var tipLabel =
-                state.hasGutter && document.createDocumentFragment();
-              for (var i = 0; i < anns.length; ++i) {
-                var ann = anns[i];
-                var severity = ann.severity;
-                if (!severity) severity = "error";
-                maxSeverity = getMaxSeverity(maxSeverity, severity);
-                if (options.formatAnnotation)
-                  ann = options.formatAnnotation(ann);
-                if (state.hasGutter)
-                  tipLabel.appendChild(annotationTooltip(ann));
-                if (ann.to)
-                  state.marked.push(
-                    cm.markText(ann.from, ann.to, {
-                      className:
-                        "CodeMirror-lint-mark CodeMirror-lint-mark-" + severity,
-                      __annotation: ann,
-                    })
-                  );
-              }
-              if (state.hasGutter)
-                cm.setGutterMarker(
-                  line,
-                  GUTTER_ID,
-                  makeMarker(
-                    cm,
-                    tipLabel,
-                    maxSeverity,
-                    annotations2[line].length > 1,
-                    options.tooltips
-                  )
-                );
-              if (options.highlightLines)
-                cm.addLineClass(line, "wrap", LINT_LINE_ID + maxSeverity);
-            }
-            if (options.onUpdateLinting)
-              options.onUpdateLinting(annotationsNotSorted, annotations2, cm);
-          }
-          function onChange(cm) {
-            var state = cm.state.lint;
-            if (!state) return;
-            clearTimeout(state.timeout);
-            state.timeout = setTimeout(function () {
-              startLinting(cm);
-            }, state.options.delay);
-          }
-          function popupTooltips(cm, annotations2, e) {
-            var target2 = e.target || e.srcElement;
-            var tooltip = document.createDocumentFragment();
-            for (var i = 0; i < annotations2.length; i++) {
-              var ann = annotations2[i];
-              tooltip.appendChild(annotationTooltip(ann));
-            }
-            showTooltipFor(cm, e, tooltip, target2);
-          }
-          function onMouseOver2(cm, e) {
-            var target2 = e.target || e.srcElement;
-            if (!/\bCodeMirror-lint-mark-/.test(target2.className)) return;
-            var box = target2.getBoundingClientRect(),
-              x2 = (box.left + box.right) / 2,
-              y2 = (box.top + box.bottom) / 2;
-            var spans = cm.findMarksAt(
-              cm.coordsChar({ left: x2, top: y2 }, "client")
-            );
-            var annotations2 = [];
-            for (var i = 0; i < spans.length; ++i) {
-              var ann = spans[i].__annotation;
-              if (ann) annotations2.push(ann);
-            }
-            if (annotations2.length) popupTooltips(cm, annotations2, e);
-          }
-          CodeMirror.defineOption("lint", false, function (cm, val, old) {
-            if (old && old != CodeMirror.Init) {
-              clearMarks(cm);
-              if (cm.state.lint.options.lintOnChange !== false)
-                cm.off("change", onChange);
-              CodeMirror.off(
-                cm.getWrapperElement(),
-                "mouseover",
-                cm.state.lint.onMouseOver
-              );
-              clearTimeout(cm.state.lint.timeout);
-              delete cm.state.lint;
-            }
-            if (val) {
-              var gutters = cm.getOption("gutters"),
-                hasLintGutter = false;
-              for (var i = 0; i < gutters.length; ++i)
-                if (gutters[i] == GUTTER_ID) hasLintGutter = true;
-              var state = (cm.state.lint = new LintState(
-                cm,
-                val,
-                hasLintGutter
-              ));
-              if (state.options.lintOnChange) cm.on("change", onChange);
-              if (
-                state.options.tooltips != false &&
-                state.options.tooltips != "gutter"
-              )
-                CodeMirror.on(
-                  cm.getWrapperElement(),
-                  "mouseover",
-                  state.onMouseOver
-                );
-              startLinting(cm);
-            }
-          });
-          CodeMirror.defineExtension("performLint", function () {
-            startLinting(this);
-          });
-        });
-      })();
-      var lint$4 = lint$6.exports;
-      var lint$5 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: lint$4,
-          },
-          [lint$6.exports]
-        )
-      );
-      var searchcursor$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports);
-        })(function (CodeMirror) {
-          var Pos = CodeMirror.Pos;
-          function regexpFlags(regexp) {
-            var flags = regexp.flags;
-            return flags != null
-              ? flags
-              : (regexp.ignoreCase ? "i" : "") +
-                  (regexp.global ? "g" : "") +
-                  (regexp.multiline ? "m" : "");
-          }
-          function ensureFlags(regexp, flags) {
-            var current = regexpFlags(regexp),
-              target2 = current;
-            for (var i = 0; i < flags.length; i++)
-              if (target2.indexOf(flags.charAt(i)) == -1)
-                target2 += flags.charAt(i);
-            return current == target2
-              ? regexp
-              : new RegExp(regexp.source, target2);
-          }
-          function maybeMultiline(regexp) {
-            return /\\s|\\n|\n|\\W|\\D|\[\^/.test(regexp.source);
-          }
-          function searchRegexpForward(doc, regexp, start2) {
-            regexp = ensureFlags(regexp, "g");
-            for (
-              var line = start2.line, ch2 = start2.ch, last = doc.lastLine();
-              line <= last;
-              line++, ch2 = 0
-            ) {
-              regexp.lastIndex = ch2;
-              var string2 = doc.getLine(line),
-                match2 = regexp.exec(string2);
-              if (match2)
-                return {
-                  from: Pos(line, match2.index),
-                  to: Pos(line, match2.index + match2[0].length),
-                  match: match2,
-                };
-            }
-          }
-          function searchRegexpForwardMultiline(doc, regexp, start2) {
-            if (!maybeMultiline(regexp))
-              return searchRegexpForward(doc, regexp, start2);
-            regexp = ensureFlags(regexp, "gm");
-            var string2,
-              chunk = 1;
-            for (
-              var line = start2.line, last = doc.lastLine();
-              line <= last;
-
-            ) {
-              for (var i = 0; i < chunk; i++) {
-                if (line > last) break;
-                var curLine = doc.getLine(line++);
-                string2 = string2 == null ? curLine : string2 + "\n" + curLine;
-              }
-              chunk = chunk * 2;
-              regexp.lastIndex = start2.ch;
-              var match2 = regexp.exec(string2);
-              if (match2) {
-                var before = string2.slice(0, match2.index).split("\n"),
-                  inside = match2[0].split("\n");
-                var startLine = start2.line + before.length - 1,
-                  startCh = before[before.length - 1].length;
-                return {
-                  from: Pos(startLine, startCh),
-                  to: Pos(
-                    startLine + inside.length - 1,
-                    inside.length == 1
-                      ? startCh + inside[0].length
-                      : inside[inside.length - 1].length
-                  ),
-                  match: match2,
-                };
-              }
-            }
-          }
-          function lastMatchIn(string2, regexp, endMargin) {
-            var match2,
-              from = 0;
-            while (from <= string2.length) {
-              regexp.lastIndex = from;
-              var newMatch = regexp.exec(string2);
-              if (!newMatch) break;
-              var end2 = newMatch.index + newMatch[0].length;
-              if (end2 > string2.length - endMargin) break;
-              if (!match2 || end2 > match2.index + match2[0].length)
-                match2 = newMatch;
-              from = newMatch.index + 1;
-            }
-            return match2;
-          }
-          function searchRegexpBackward(doc, regexp, start2) {
-            regexp = ensureFlags(regexp, "g");
-            for (
-              var line = start2.line, ch2 = start2.ch, first = doc.firstLine();
-              line >= first;
-              line--, ch2 = -1
-            ) {
-              var string2 = doc.getLine(line);
-              var match2 = lastMatchIn(
-                string2,
-                regexp,
-                ch2 < 0 ? 0 : string2.length - ch2
-              );
-              if (match2)
-                return {
-                  from: Pos(line, match2.index),
-                  to: Pos(line, match2.index + match2[0].length),
-                  match: match2,
-                };
-            }
-          }
-          function searchRegexpBackwardMultiline(doc, regexp, start2) {
-            if (!maybeMultiline(regexp))
-              return searchRegexpBackward(doc, regexp, start2);
-            regexp = ensureFlags(regexp, "gm");
-            var string2,
-              chunkSize = 1,
-              endMargin = doc.getLine(start2.line).length - start2.ch;
-            for (
-              var line = start2.line, first = doc.firstLine();
-              line >= first;
-
-            ) {
-              for (var i = 0; i < chunkSize && line >= first; i++) {
-                var curLine = doc.getLine(line--);
-                string2 = string2 == null ? curLine : curLine + "\n" + string2;
-              }
-              chunkSize *= 2;
-              var match2 = lastMatchIn(string2, regexp, endMargin);
-              if (match2) {
-                var before = string2.slice(0, match2.index).split("\n"),
-                  inside = match2[0].split("\n");
-                var startLine = line + before.length,
-                  startCh = before[before.length - 1].length;
-                return {
-                  from: Pos(startLine, startCh),
-                  to: Pos(
-                    startLine + inside.length - 1,
-                    inside.length == 1
-                      ? startCh + inside[0].length
-                      : inside[inside.length - 1].length
-                  ),
-                  match: match2,
-                };
-              }
-            }
-          }
-          var doFold, noFold;
-          if (String.prototype.normalize) {
-            doFold = function (str) {
-              return str.normalize("NFD").toLowerCase();
-            };
-            noFold = function (str) {
-              return str.normalize("NFD");
-            };
-          } else {
-            doFold = function (str) {
-              return str.toLowerCase();
-            };
-            noFold = function (str) {
-              return str;
-            };
-          }
-          function adjustPos(orig, folded, pos, foldFunc) {
-            if (orig.length == folded.length) return pos;
-            for (
-              var min = 0, max = pos + Math.max(0, orig.length - folded.length);
-              ;
-
-            ) {
-              if (min == max) return min;
-              var mid2 = (min + max) >> 1;
-              var len = foldFunc(orig.slice(0, mid2)).length;
-              if (len == pos) return mid2;
-              else if (len > pos) max = mid2;
-              else min = mid2 + 1;
-            }
-          }
-          function searchStringForward(doc, query, start2, caseFold) {
-            if (!query.length) return null;
-            var fold = caseFold ? doFold : noFold;
-            var lines = fold(query).split(/\r|\n\r?/);
-            search: for (
-              var line = start2.line,
-                ch2 = start2.ch,
-                last = doc.lastLine() + 1 - lines.length;
-              line <= last;
-              line++, ch2 = 0
-            ) {
-              var orig = doc.getLine(line).slice(ch2),
-                string2 = fold(orig);
-              if (lines.length == 1) {
-                var found = string2.indexOf(lines[0]);
-                if (found == -1) continue search;
-                var start2 = adjustPos(orig, string2, found, fold) + ch2;
-                return {
-                  from: Pos(line, adjustPos(orig, string2, found, fold) + ch2),
-                  to: Pos(
-                    line,
-                    adjustPos(orig, string2, found + lines[0].length, fold) +
-                      ch2
-                  ),
-                };
-              } else {
-                var cutFrom = string2.length - lines[0].length;
-                if (string2.slice(cutFrom) != lines[0]) continue search;
-                for (var i = 1; i < lines.length - 1; i++)
-                  if (fold(doc.getLine(line + i)) != lines[i]) continue search;
-                var end2 = doc.getLine(line + lines.length - 1),
-                  endString = fold(end2),
-                  lastLine = lines[lines.length - 1];
-                if (endString.slice(0, lastLine.length) != lastLine)
-                  continue search;
-                return {
-                  from: Pos(
-                    line,
-                    adjustPos(orig, string2, cutFrom, fold) + ch2
-                  ),
-                  to: Pos(
-                    line + lines.length - 1,
-                    adjustPos(end2, endString, lastLine.length, fold)
-                  ),
-                };
-              }
-            }
-          }
-          function searchStringBackward(doc, query, start2, caseFold) {
-            if (!query.length) return null;
-            var fold = caseFold ? doFold : noFold;
-            var lines = fold(query).split(/\r|\n\r?/);
-            search: for (
-              var line = start2.line,
-                ch2 = start2.ch,
-                first = doc.firstLine() - 1 + lines.length;
-              line >= first;
-              line--, ch2 = -1
-            ) {
-              var orig = doc.getLine(line);
-              if (ch2 > -1) orig = orig.slice(0, ch2);
-              var string2 = fold(orig);
-              if (lines.length == 1) {
-                var found = string2.lastIndexOf(lines[0]);
-                if (found == -1) continue search;
-                return {
-                  from: Pos(line, adjustPos(orig, string2, found, fold)),
-                  to: Pos(
-                    line,
-                    adjustPos(orig, string2, found + lines[0].length, fold)
-                  ),
-                };
-              } else {
-                var lastLine = lines[lines.length - 1];
-                if (string2.slice(0, lastLine.length) != lastLine)
-                  continue search;
-                for (
-                  var i = 1, start2 = line - lines.length + 1;
-                  i < lines.length - 1;
-                  i++
-                )
-                  if (fold(doc.getLine(start2 + i)) != lines[i])
-                    continue search;
-                var top2 = doc.getLine(line + 1 - lines.length),
-                  topString = fold(top2);
-                if (
-                  topString.slice(topString.length - lines[0].length) !=
-                  lines[0]
-                )
-                  continue search;
-                return {
-                  from: Pos(
-                    line + 1 - lines.length,
-                    adjustPos(
-                      top2,
-                      topString,
-                      top2.length - lines[0].length,
-                      fold
-                    )
-                  ),
-                  to: Pos(
-                    line,
-                    adjustPos(orig, string2, lastLine.length, fold)
-                  ),
-                };
-              }
-            }
-          }
-          function SearchCursor(doc, query, pos, options) {
-            this.atOccurrence = false;
-            this.afterEmptyMatch = false;
-            this.doc = doc;
-            pos = pos ? doc.clipPos(pos) : Pos(0, 0);
-            this.pos = { from: pos, to: pos };
-            var caseFold;
-            if (typeof options == "object") {
-              caseFold = options.caseFold;
-            } else {
-              caseFold = options;
-              options = null;
-            }
-            if (typeof query == "string") {
-              if (caseFold == null) caseFold = false;
-              this.matches = function (reverse, pos2) {
-                return (reverse ? searchStringBackward : searchStringForward)(
-                  doc,
-                  query,
-                  pos2,
-                  caseFold
-                );
-              };
-            } else {
-              query = ensureFlags(query, "gm");
-              if (!options || options.multiline !== false)
-                this.matches = function (reverse, pos2) {
-                  return (
-                    reverse
-                      ? searchRegexpBackwardMultiline
-                      : searchRegexpForwardMultiline
-                  )(doc, query, pos2);
-                };
-              else
-                this.matches = function (reverse, pos2) {
-                  return (reverse ? searchRegexpBackward : searchRegexpForward)(
-                    doc,
-                    query,
-                    pos2
-                  );
-                };
-            }
-          }
-          SearchCursor.prototype = {
-            findNext: function () {
-              return this.find(false);
-            },
-            findPrevious: function () {
-              return this.find(true);
-            },
-            find: function (reverse) {
-              var head = this.doc.clipPos(
-                reverse ? this.pos.from : this.pos.to
-              );
-              if (this.afterEmptyMatch && this.atOccurrence) {
-                head = Pos(head.line, head.ch);
-                if (reverse) {
-                  head.ch--;
-                  if (head.ch < 0) {
-                    head.line--;
-                    head.ch = (this.doc.getLine(head.line) || "").length;
-                  }
-                } else {
-                  head.ch++;
-                  if (head.ch > (this.doc.getLine(head.line) || "").length) {
-                    head.ch = 0;
-                    head.line++;
-                  }
-                }
-                if (CodeMirror.cmpPos(head, this.doc.clipPos(head)) != 0) {
-                  return (this.atOccurrence = false);
-                }
-              }
-              var result2 = this.matches(reverse, head);
-              this.afterEmptyMatch =
-                result2 && CodeMirror.cmpPos(result2.from, result2.to) == 0;
-              if (result2) {
-                this.pos = result2;
-                this.atOccurrence = true;
-                return this.pos.match || true;
-              } else {
-                var end2 = Pos(
-                  reverse ? this.doc.firstLine() : this.doc.lastLine() + 1,
-                  0
-                );
-                this.pos = { from: end2, to: end2 };
-                return (this.atOccurrence = false);
-              }
-            },
-            from: function () {
-              if (this.atOccurrence) return this.pos.from;
-            },
-            to: function () {
-              if (this.atOccurrence) return this.pos.to;
-            },
-            replace: function (newText, origin) {
-              if (!this.atOccurrence) return;
-              var lines = CodeMirror.splitLines(newText);
-              this.doc.replaceRange(lines, this.pos.from, this.pos.to, origin);
-              this.pos.to = Pos(
-                this.pos.from.line + lines.length - 1,
-                lines[lines.length - 1].length +
-                  (lines.length == 1 ? this.pos.from.ch : 0)
-              );
-            },
-          };
-          CodeMirror.defineExtension(
-            "getSearchCursor",
-            function (query, pos, caseFold) {
-              return new SearchCursor(this.doc, query, pos, caseFold);
-            }
-          );
-          CodeMirror.defineDocExtension(
-            "getSearchCursor",
-            function (query, pos, caseFold) {
-              return new SearchCursor(this, query, pos, caseFold);
-            }
-          );
-          CodeMirror.defineExtension(
-            "selectMatches",
-            function (query, caseFold) {
-              var ranges = [];
-              var cur = this.getSearchCursor(
-                query,
-                this.getCursor("from"),
-                caseFold
-              );
-              while (cur.findNext()) {
-                if (CodeMirror.cmpPos(cur.to(), this.getCursor("to")) > 0)
-                  break;
-                ranges.push({ anchor: cur.from(), head: cur.to() });
-              }
-              if (ranges.length) this.setSelections(ranges, 0);
-            }
-          );
-        });
-      })();
-      var searchcursor = searchcursor$2.exports;
-      var searchcursor$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: searchcursor,
-          },
-          [searchcursor$2.exports]
-        )
-      );
-      var jumpToLine$2 = { exports: {} };
-      var dialog$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports);
-        })(function (CodeMirror) {
-          function dialogDiv(cm, template, bottom2) {
-            var wrap2 = cm.getWrapperElement();
-            var dialog2;
-            dialog2 = wrap2.appendChild(document.createElement("div"));
-            if (bottom2)
-              dialog2.className = "CodeMirror-dialog CodeMirror-dialog-bottom";
-            else dialog2.className = "CodeMirror-dialog CodeMirror-dialog-top";
-            if (typeof template == "string") {
-              dialog2.innerHTML = template;
-            } else {
-              dialog2.appendChild(template);
-            }
-            CodeMirror.addClass(wrap2, "dialog-opened");
-            return dialog2;
-          }
-          function closeNotification(cm, newVal) {
-            if (cm.state.currentNotificationClose)
-              cm.state.currentNotificationClose();
-            cm.state.currentNotificationClose = newVal;
-          }
-          CodeMirror.defineExtension(
-            "openDialog",
-            function (template, callback, options) {
-              if (!options) options = {};
-              closeNotification(this, null);
-              var dialog2 = dialogDiv(this, template, options.bottom);
-              var closed = false,
-                me2 = this;
-              function close(newVal) {
-                if (typeof newVal == "string") {
-                  inp.value = newVal;
-                } else {
-                  if (closed) return;
-                  closed = true;
-                  CodeMirror.rmClass(dialog2.parentNode, "dialog-opened");
-                  dialog2.parentNode.removeChild(dialog2);
-                  me2.focus();
-                  if (options.onClose) options.onClose(dialog2);
-                }
-              }
-              var inp = dialog2.getElementsByTagName("input")[0],
-                button;
-              if (inp) {
-                inp.focus();
-                if (options.value) {
-                  inp.value = options.value;
-                  if (options.selectValueOnOpen !== false) {
-                    inp.select();
-                  }
-                }
-                if (options.onInput)
-                  CodeMirror.on(inp, "input", function (e) {
-                    options.onInput(e, inp.value, close);
-                  });
-                if (options.onKeyUp)
-                  CodeMirror.on(inp, "keyup", function (e) {
-                    options.onKeyUp(e, inp.value, close);
-                  });
-                CodeMirror.on(inp, "keydown", function (e) {
-                  if (
-                    options &&
-                    options.onKeyDown &&
-                    options.onKeyDown(e, inp.value, close)
-                  ) {
-                    return;
-                  }
-                  if (
-                    e.keyCode == 27 ||
-                    (options.closeOnEnter !== false && e.keyCode == 13)
-                  ) {
-                    inp.blur();
-                    CodeMirror.e_stop(e);
-                    close();
-                  }
-                  if (e.keyCode == 13) callback(inp.value, e);
-                });
-                if (options.closeOnBlur !== false)
-                  CodeMirror.on(dialog2, "focusout", function (evt) {
-                    if (evt.relatedTarget !== null) close();
-                  });
-              } else if ((button = dialog2.getElementsByTagName("button")[0])) {
-                CodeMirror.on(button, "click", function () {
-                  close();
-                  me2.focus();
-                });
-                if (options.closeOnBlur !== false)
-                  CodeMirror.on(button, "blur", close);
-                button.focus();
-              }
-              return close;
-            }
-          );
-          CodeMirror.defineExtension(
-            "openConfirm",
-            function (template, callbacks, options) {
-              closeNotification(this, null);
-              var dialog2 = dialogDiv(
-                this,
-                template,
-                options && options.bottom
-              );
-              var buttons = dialog2.getElementsByTagName("button");
-              var closed = false,
-                me2 = this,
-                blurring = 1;
-              function close() {
-                if (closed) return;
-                closed = true;
-                CodeMirror.rmClass(dialog2.parentNode, "dialog-opened");
-                dialog2.parentNode.removeChild(dialog2);
-                me2.focus();
-              }
-              buttons[0].focus();
-              for (var i = 0; i < buttons.length; ++i) {
-                var b = buttons[i];
-                (function (callback) {
-                  CodeMirror.on(b, "click", function (e) {
-                    CodeMirror.e_preventDefault(e);
-                    close();
-                    if (callback) callback(me2);
-                  });
-                })(callbacks[i]);
-                CodeMirror.on(b, "blur", function () {
-                  --blurring;
-                  setTimeout(function () {
-                    if (blurring <= 0) close();
-                  }, 200);
-                });
-                CodeMirror.on(b, "focus", function () {
-                  ++blurring;
-                });
-              }
-            }
-          );
-          CodeMirror.defineExtension(
-            "openNotification",
-            function (template, options) {
-              closeNotification(this, close);
-              var dialog2 = dialogDiv(
-                this,
-                template,
-                options && options.bottom
-              );
-              var closed = false,
-                doneTimer;
-              var duration =
-                options && typeof options.duration !== "undefined"
-                  ? options.duration
-                  : 5e3;
-              function close() {
-                if (closed) return;
-                closed = true;
-                clearTimeout(doneTimer);
-                CodeMirror.rmClass(dialog2.parentNode, "dialog-opened");
-                dialog2.parentNode.removeChild(dialog2);
-              }
-              CodeMirror.on(dialog2, "click", function (e) {
-                CodeMirror.e_preventDefault(e);
-                close();
-              });
-              if (duration) doneTimer = setTimeout(close, duration);
-              return close;
-            }
-          );
-        });
-      })();
-      var dialog = dialog$2.exports;
-      var dialog$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: dialog,
-          },
-          [dialog$2.exports]
-        )
-      );
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports, dialog$2.exports);
-        })(function (CodeMirror) {
-          CodeMirror.defineOption("search", { bottom: false });
-          function dialog2(cm, text3, shortText, deflt, f) {
-            if (cm.openDialog)
-              cm.openDialog(text3, f, {
-                value: deflt,
-                selectValueOnOpen: true,
-                bottom: cm.options.search.bottom,
-              });
-            else f(prompt(shortText, deflt));
-          }
-          function getJumpDialog(cm) {
-            return (
-              cm.phrase("Jump to line:") +
-              ' <input type="text" style="width: 10em" class="CodeMirror-search-field"/> <span style="color: #888" class="CodeMirror-search-hint">' +
-              cm.phrase("(Use line:column or scroll% syntax)") +
-              "</span>"
-            );
-          }
-          function interpretLine(cm, string2) {
-            var num2 = Number(string2);
-            if (/^[-+]/.test(string2)) return cm.getCursor().line + num2;
-            else return num2 - 1;
-          }
-          CodeMirror.commands.jumpToLine = function (cm) {
-            var cur = cm.getCursor();
-            dialog2(
-              cm,
-              getJumpDialog(cm),
-              cm.phrase("Jump to line:"),
-              cur.line + 1 + ":" + cur.ch,
-              function (posStr) {
-                if (!posStr) return;
-                var match2;
-                if (
-                  (match2 = /^\s*([\+\-]?\d+)\s*\:\s*(\d+)\s*$/.exec(posStr))
-                ) {
-                  cm.setCursor(interpretLine(cm, match2[1]), Number(match2[2]));
-                } else if (
-                  (match2 = /^\s*([\+\-]?\d+(\.\d+)?)\%\s*/.exec(posStr))
-                ) {
-                  var line = Math.round(
-                    (cm.lineCount() * Number(match2[1])) / 100
-                  );
-                  if (/^[-+]/.test(match2[1])) line = cur.line + line + 1;
-                  cm.setCursor(line - 1, cur.ch);
-                } else if (
-                  (match2 = /^\s*\:?\s*([\+\-]?\d+)\s*/.exec(posStr))
-                ) {
-                  cm.setCursor(interpretLine(cm, match2[1]), cur.ch);
-                }
-              }
-            );
-          };
-          CodeMirror.keyMap["default"]["Alt-G"] = "jumpToLine";
-        });
-      })();
-      var jumpToLine = jumpToLine$2.exports;
-      var jumpToLine$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: jumpToLine,
-          },
-          [jumpToLine$2.exports]
-        )
-      );
-      var sublime$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(
-            codemirror$2.exports,
-            searchcursor$2.exports,
-            matchbrackets$2.exports
-          );
-        })(function (CodeMirror) {
-          var cmds = CodeMirror.commands;
-          var Pos = CodeMirror.Pos;
-          function findPosSubword(doc, start2, dir) {
-            if (dir < 0 && start2.ch == 0)
-              return doc.clipPos(Pos(start2.line - 1));
-            var line = doc.getLine(start2.line);
-            if (dir > 0 && start2.ch >= line.length)
-              return doc.clipPos(Pos(start2.line + 1, 0));
-            var state = "start",
-              type2,
-              startPos = start2.ch;
-            for (
-              var pos = startPos, e = dir < 0 ? 0 : line.length, i = 0;
-              pos != e;
-              pos += dir, i++
-            ) {
-              var next = line.charAt(dir < 0 ? pos - 1 : pos);
-              var cat = next != "_" && CodeMirror.isWordChar(next) ? "w" : "o";
-              if (cat == "w" && next.toUpperCase() == next) cat = "W";
-              if (state == "start") {
-                if (cat != "o") {
-                  state = "in";
-                  type2 = cat;
-                } else startPos = pos + dir;
-              } else if (state == "in") {
-                if (type2 != cat) {
-                  if (type2 == "w" && cat == "W" && dir < 0) pos--;
-                  if (type2 == "W" && cat == "w" && dir > 0) {
-                    if (pos == startPos + 1) {
-                      type2 = "w";
-                      continue;
-                    } else pos--;
-                  }
-                  break;
-                }
-              }
-            }
-            return Pos(start2.line, pos);
-          }
-          function moveSubword(cm, dir) {
-            cm.extendSelectionsBy(function (range2) {
-              if (cm.display.shift || cm.doc.extend || range2.empty())
-                return findPosSubword(cm.doc, range2.head, dir);
-              else return dir < 0 ? range2.from() : range2.to();
-            });
-          }
-          cmds.goSubwordLeft = function (cm) {
-            moveSubword(cm, -1);
-          };
-          cmds.goSubwordRight = function (cm) {
-            moveSubword(cm, 1);
-          };
-          cmds.scrollLineUp = function (cm) {
-            var info2 = cm.getScrollInfo();
-            if (!cm.somethingSelected()) {
-              var visibleBottomLine = cm.lineAtHeight(
-                info2.top + info2.clientHeight,
-                "local"
-              );
-              if (cm.getCursor().line >= visibleBottomLine)
-                cm.execCommand("goLineUp");
-            }
-            cm.scrollTo(null, info2.top - cm.defaultTextHeight());
-          };
-          cmds.scrollLineDown = function (cm) {
-            var info2 = cm.getScrollInfo();
-            if (!cm.somethingSelected()) {
-              var visibleTopLine = cm.lineAtHeight(info2.top, "local") + 1;
-              if (cm.getCursor().line <= visibleTopLine)
-                cm.execCommand("goLineDown");
-            }
-            cm.scrollTo(null, info2.top + cm.defaultTextHeight());
-          };
-          cmds.splitSelectionByLine = function (cm) {
-            var ranges = cm.listSelections(),
-              lineRanges = [];
-            for (var i = 0; i < ranges.length; i++) {
-              var from = ranges[i].from(),
-                to = ranges[i].to();
-              for (var line = from.line; line <= to.line; ++line)
-                if (!(to.line > from.line && line == to.line && to.ch == 0))
-                  lineRanges.push({
-                    anchor: line == from.line ? from : Pos(line, 0),
-                    head: line == to.line ? to : Pos(line),
-                  });
-            }
-            cm.setSelections(lineRanges, 0);
-          };
-          cmds.singleSelectionTop = function (cm) {
-            var range2 = cm.listSelections()[0];
-            cm.setSelection(range2.anchor, range2.head, { scroll: false });
-          };
-          cmds.selectLine = function (cm) {
-            var ranges = cm.listSelections(),
-              extended = [];
-            for (var i = 0; i < ranges.length; i++) {
-              var range2 = ranges[i];
-              extended.push({
-                anchor: Pos(range2.from().line, 0),
-                head: Pos(range2.to().line + 1, 0),
-              });
-            }
-            cm.setSelections(extended);
-          };
-          function insertLine(cm, above) {
-            if (cm.isReadOnly()) return CodeMirror.Pass;
-            cm.operation(function () {
-              var len = cm.listSelections().length,
-                newSelection = [],
-                last = -1;
-              for (var i = 0; i < len; i++) {
-                var head = cm.listSelections()[i].head;
-                if (head.line <= last) continue;
-                var at = Pos(head.line + (above ? 0 : 1), 0);
-                cm.replaceRange("\n", at, null, "+insertLine");
-                cm.indentLine(at.line, null, true);
-                newSelection.push({ head: at, anchor: at });
-                last = head.line + 1;
-              }
-              cm.setSelections(newSelection);
-            });
-            cm.execCommand("indentAuto");
-          }
-          cmds.insertLineAfter = function (cm) {
-            return insertLine(cm, false);
-          };
-          cmds.insertLineBefore = function (cm) {
-            return insertLine(cm, true);
-          };
-          function wordAt(cm, pos) {
-            var start2 = pos.ch,
-              end2 = start2,
-              line = cm.getLine(pos.line);
-            while (start2 && CodeMirror.isWordChar(line.charAt(start2 - 1)))
-              --start2;
-            while (
-              end2 < line.length &&
-              CodeMirror.isWordChar(line.charAt(end2))
-            )
-              ++end2;
-            return {
-              from: Pos(pos.line, start2),
-              to: Pos(pos.line, end2),
-              word: line.slice(start2, end2),
-            };
-          }
-          cmds.selectNextOccurrence = function (cm) {
-            var from = cm.getCursor("from"),
-              to = cm.getCursor("to");
-            var fullWord = cm.state.sublimeFindFullWord == cm.doc.sel;
-            if (CodeMirror.cmpPos(from, to) == 0) {
-              var word2 = wordAt(cm, from);
-              if (!word2.word) return;
-              cm.setSelection(word2.from, word2.to);
-              fullWord = true;
-            } else {
-              var text3 = cm.getRange(from, to);
-              var query = fullWord ? new RegExp("\\b" + text3 + "\\b") : text3;
-              var cur = cm.getSearchCursor(query, to);
-              var found = cur.findNext();
-              if (!found) {
-                cur = cm.getSearchCursor(query, Pos(cm.firstLine(), 0));
-                found = cur.findNext();
-              }
-              if (
-                !found ||
-                isSelectedRange(cm.listSelections(), cur.from(), cur.to())
-              )
-                return;
-              cm.addSelection(cur.from(), cur.to());
-            }
-            if (fullWord) cm.state.sublimeFindFullWord = cm.doc.sel;
-          };
-          cmds.skipAndSelectNextOccurrence = function (cm) {
-            var prevAnchor = cm.getCursor("anchor"),
-              prevHead = cm.getCursor("head");
-            cmds.selectNextOccurrence(cm);
-            if (CodeMirror.cmpPos(prevAnchor, prevHead) != 0) {
-              cm.doc.setSelections(
-                cm.doc.listSelections().filter(function (sel) {
-                  return sel.anchor != prevAnchor || sel.head != prevHead;
-                })
-              );
-            }
-          };
-          function addCursorToSelection(cm, dir) {
-            var ranges = cm.listSelections(),
-              newRanges = [];
-            for (var i = 0; i < ranges.length; i++) {
-              var range2 = ranges[i];
-              var newAnchor = cm.findPosV(
-                range2.anchor,
-                dir,
-                "line",
-                range2.anchor.goalColumn
-              );
-              var newHead = cm.findPosV(
-                range2.head,
-                dir,
-                "line",
-                range2.head.goalColumn
-              );
-              newAnchor.goalColumn =
-                range2.anchor.goalColumn != null
-                  ? range2.anchor.goalColumn
-                  : cm.cursorCoords(range2.anchor, "div").left;
-              newHead.goalColumn =
-                range2.head.goalColumn != null
-                  ? range2.head.goalColumn
-                  : cm.cursorCoords(range2.head, "div").left;
-              var newRange = { anchor: newAnchor, head: newHead };
-              newRanges.push(range2);
-              newRanges.push(newRange);
-            }
-            cm.setSelections(newRanges);
-          }
-          cmds.addCursorToPrevLine = function (cm) {
-            addCursorToSelection(cm, -1);
-          };
-          cmds.addCursorToNextLine = function (cm) {
-            addCursorToSelection(cm, 1);
-          };
-          function isSelectedRange(ranges, from, to) {
-            for (var i = 0; i < ranges.length; i++)
-              if (
-                CodeMirror.cmpPos(ranges[i].from(), from) == 0 &&
-                CodeMirror.cmpPos(ranges[i].to(), to) == 0
-              )
-                return true;
-            return false;
-          }
-          var mirror = "(){}[]";
-          function selectBetweenBrackets(cm) {
-            var ranges = cm.listSelections(),
-              newRanges = [];
-            for (var i = 0; i < ranges.length; i++) {
-              var range2 = ranges[i],
-                pos = range2.head,
-                opening = cm.scanForBracket(pos, -1);
-              if (!opening) return false;
-              for (;;) {
-                var closing = cm.scanForBracket(pos, 1);
-                if (!closing) return false;
-                if (
-                  closing.ch == mirror.charAt(mirror.indexOf(opening.ch) + 1)
-                ) {
-                  var startPos = Pos(opening.pos.line, opening.pos.ch + 1);
-                  if (
-                    CodeMirror.cmpPos(startPos, range2.from()) == 0 &&
-                    CodeMirror.cmpPos(closing.pos, range2.to()) == 0
-                  ) {
-                    opening = cm.scanForBracket(opening.pos, -1);
-                    if (!opening) return false;
-                  } else {
-                    newRanges.push({ anchor: startPos, head: closing.pos });
-                    break;
-                  }
-                }
-                pos = Pos(closing.pos.line, closing.pos.ch + 1);
-              }
-            }
-            cm.setSelections(newRanges);
-            return true;
-          }
-          cmds.selectScope = function (cm) {
-            selectBetweenBrackets(cm) || cm.execCommand("selectAll");
-          };
-          cmds.selectBetweenBrackets = function (cm) {
-            if (!selectBetweenBrackets(cm)) return CodeMirror.Pass;
-          };
-          function puncType(type2) {
-            return !type2
-              ? null
-              : /\bpunctuation\b/.test(type2)
-              ? type2
-              : void 0;
-          }
-          cmds.goToBracket = function (cm) {
-            cm.extendSelectionsBy(function (range2) {
-              var next = cm.scanForBracket(
-                range2.head,
-                1,
-                puncType(cm.getTokenTypeAt(range2.head))
-              );
-              if (next && CodeMirror.cmpPos(next.pos, range2.head) != 0)
-                return next.pos;
-              var prev = cm.scanForBracket(
-                range2.head,
-                -1,
-                puncType(
-                  cm.getTokenTypeAt(Pos(range2.head.line, range2.head.ch + 1))
-                )
-              );
-              return (
-                (prev && Pos(prev.pos.line, prev.pos.ch + 1)) || range2.head
-              );
-            });
-          };
-          cmds.swapLineUp = function (cm) {
-            if (cm.isReadOnly()) return CodeMirror.Pass;
-            var ranges = cm.listSelections(),
-              linesToMove = [],
-              at = cm.firstLine() - 1,
-              newSels = [];
-            for (var i = 0; i < ranges.length; i++) {
-              var range2 = ranges[i],
-                from = range2.from().line - 1,
-                to = range2.to().line;
-              newSels.push({
-                anchor: Pos(range2.anchor.line - 1, range2.anchor.ch),
-                head: Pos(range2.head.line - 1, range2.head.ch),
-              });
-              if (range2.to().ch == 0 && !range2.empty()) --to;
-              if (from > at) linesToMove.push(from, to);
-              else if (linesToMove.length)
-                linesToMove[linesToMove.length - 1] = to;
-              at = to;
-            }
-            cm.operation(function () {
-              for (var i2 = 0; i2 < linesToMove.length; i2 += 2) {
-                var from2 = linesToMove[i2],
-                  to2 = linesToMove[i2 + 1];
-                var line = cm.getLine(from2);
-                cm.replaceRange(
-                  "",
-                  Pos(from2, 0),
-                  Pos(from2 + 1, 0),
-                  "+swapLine"
-                );
-                if (to2 > cm.lastLine())
-                  cm.replaceRange(
-                    "\n" + line,
-                    Pos(cm.lastLine()),
-                    null,
-                    "+swapLine"
-                  );
-                else
-                  cm.replaceRange(line + "\n", Pos(to2, 0), null, "+swapLine");
-              }
-              cm.setSelections(newSels);
-              cm.scrollIntoView();
-            });
-          };
-          cmds.swapLineDown = function (cm) {
-            if (cm.isReadOnly()) return CodeMirror.Pass;
-            var ranges = cm.listSelections(),
-              linesToMove = [],
-              at = cm.lastLine() + 1;
-            for (var i = ranges.length - 1; i >= 0; i--) {
-              var range2 = ranges[i],
-                from = range2.to().line + 1,
-                to = range2.from().line;
-              if (range2.to().ch == 0 && !range2.empty()) from--;
-              if (from < at) linesToMove.push(from, to);
-              else if (linesToMove.length)
-                linesToMove[linesToMove.length - 1] = to;
-              at = to;
-            }
-            cm.operation(function () {
-              for (var i2 = linesToMove.length - 2; i2 >= 0; i2 -= 2) {
-                var from2 = linesToMove[i2],
-                  to2 = linesToMove[i2 + 1];
-                var line = cm.getLine(from2);
-                if (from2 == cm.lastLine())
-                  cm.replaceRange("", Pos(from2 - 1), Pos(from2), "+swapLine");
-                else
-                  cm.replaceRange(
-                    "",
-                    Pos(from2, 0),
-                    Pos(from2 + 1, 0),
-                    "+swapLine"
-                  );
-                cm.replaceRange(line + "\n", Pos(to2, 0), null, "+swapLine");
-              }
-              cm.scrollIntoView();
-            });
-          };
-          cmds.toggleCommentIndented = function (cm) {
-            cm.toggleComment({ indent: true });
-          };
-          cmds.joinLines = function (cm) {
-            var ranges = cm.listSelections(),
-              joined = [];
-            for (var i = 0; i < ranges.length; i++) {
-              var range2 = ranges[i],
-                from = range2.from();
-              var start2 = from.line,
-                end2 = range2.to().line;
-              while (i < ranges.length - 1 && ranges[i + 1].from().line == end2)
-                end2 = ranges[++i].to().line;
-              joined.push({
-                start: start2,
-                end: end2,
-                anchor: !range2.empty() && from,
-              });
-            }
-            cm.operation(function () {
-              var offset = 0,
-                ranges2 = [];
-              for (var i2 = 0; i2 < joined.length; i2++) {
-                var obj = joined[i2];
-                var anchor =
-                    obj.anchor && Pos(obj.anchor.line - offset, obj.anchor.ch),
-                  head;
-                for (var line = obj.start; line <= obj.end; line++) {
-                  var actual = line - offset;
-                  if (line == obj.end)
-                    head = Pos(actual, cm.getLine(actual).length + 1);
-                  if (actual < cm.lastLine()) {
-                    cm.replaceRange(
-                      " ",
-                      Pos(actual),
-                      Pos(
-                        actual + 1,
-                        /^\s*/.exec(cm.getLine(actual + 1))[0].length
-                      )
-                    );
-                    ++offset;
-                  }
-                }
-                ranges2.push({ anchor: anchor || head, head });
-              }
-              cm.setSelections(ranges2, 0);
-            });
-          };
-          cmds.duplicateLine = function (cm) {
-            cm.operation(function () {
-              var rangeCount = cm.listSelections().length;
-              for (var i = 0; i < rangeCount; i++) {
-                var range2 = cm.listSelections()[i];
-                if (range2.empty())
-                  cm.replaceRange(
-                    cm.getLine(range2.head.line) + "\n",
-                    Pos(range2.head.line, 0)
-                  );
-                else
-                  cm.replaceRange(
-                    cm.getRange(range2.from(), range2.to()),
-                    range2.from()
-                  );
-              }
-              cm.scrollIntoView();
-            });
-          };
-          function sortLines(cm, caseSensitive, direction) {
-            if (cm.isReadOnly()) return CodeMirror.Pass;
-            var ranges = cm.listSelections(),
-              toSort = [],
-              selected;
-            for (var i = 0; i < ranges.length; i++) {
-              var range2 = ranges[i];
-              if (range2.empty()) continue;
-              var from = range2.from().line,
-                to = range2.to().line;
-              while (i < ranges.length - 1 && ranges[i + 1].from().line == to)
-                to = ranges[++i].to().line;
-              if (!ranges[i].to().ch) to--;
-              toSort.push(from, to);
-            }
-            if (toSort.length) selected = true;
-            else toSort.push(cm.firstLine(), cm.lastLine());
-            cm.operation(function () {
-              var ranges2 = [];
-              for (var i2 = 0; i2 < toSort.length; i2 += 2) {
-                var from2 = toSort[i2],
-                  to2 = toSort[i2 + 1];
-                var start2 = Pos(from2, 0),
-                  end2 = Pos(to2);
-                var lines = cm.getRange(start2, end2, false);
-                if (caseSensitive)
-                  lines.sort(function (a, b) {
-                    return a < b ? -direction : a == b ? 0 : direction;
-                  });
-                else
-                  lines.sort(function (a, b) {
-                    var au = a.toUpperCase(),
-                      bu = b.toUpperCase();
-                    if (au != bu) {
-                      a = au;
-                      b = bu;
-                    }
-                    return a < b ? -direction : a == b ? 0 : direction;
-                  });
-                cm.replaceRange(lines, start2, end2);
-                if (selected)
-                  ranges2.push({ anchor: start2, head: Pos(to2 + 1, 0) });
-              }
-              if (selected) cm.setSelections(ranges2, 0);
-            });
-          }
-          cmds.sortLines = function (cm) {
-            sortLines(cm, true, 1);
-          };
-          cmds.reverseSortLines = function (cm) {
-            sortLines(cm, true, -1);
-          };
-          cmds.sortLinesInsensitive = function (cm) {
-            sortLines(cm, false, 1);
-          };
-          cmds.reverseSortLinesInsensitive = function (cm) {
-            sortLines(cm, false, -1);
-          };
-          cmds.nextBookmark = function (cm) {
-            var marks = cm.state.sublimeBookmarks;
-            if (marks)
-              while (marks.length) {
-                var current = marks.shift();
-                var found = current.find();
-                if (found) {
-                  marks.push(current);
-                  return cm.setSelection(found.from, found.to);
-                }
-              }
-          };
-          cmds.prevBookmark = function (cm) {
-            var marks = cm.state.sublimeBookmarks;
-            if (marks)
-              while (marks.length) {
-                marks.unshift(marks.pop());
-                var found = marks[marks.length - 1].find();
-                if (!found) marks.pop();
-                else return cm.setSelection(found.from, found.to);
-              }
-          };
-          cmds.toggleBookmark = function (cm) {
-            var ranges = cm.listSelections();
-            var marks =
-              cm.state.sublimeBookmarks || (cm.state.sublimeBookmarks = []);
-            for (var i = 0; i < ranges.length; i++) {
-              var from = ranges[i].from(),
-                to = ranges[i].to();
-              var found = ranges[i].empty()
-                ? cm.findMarksAt(from)
-                : cm.findMarks(from, to);
-              for (var j = 0; j < found.length; j++) {
-                if (found[j].sublimeBookmark) {
-                  found[j].clear();
-                  for (var k = 0; k < marks.length; k++)
-                    if (marks[k] == found[j]) marks.splice(k--, 1);
-                  break;
-                }
-              }
-              if (j == found.length)
-                marks.push(
-                  cm.markText(from, to, {
-                    sublimeBookmark: true,
-                    clearWhenEmpty: false,
-                  })
-                );
-            }
-          };
-          cmds.clearBookmarks = function (cm) {
-            var marks = cm.state.sublimeBookmarks;
-            if (marks) for (var i = 0; i < marks.length; i++) marks[i].clear();
-            marks.length = 0;
-          };
-          cmds.selectBookmarks = function (cm) {
-            var marks = cm.state.sublimeBookmarks,
-              ranges = [];
-            if (marks)
-              for (var i = 0; i < marks.length; i++) {
-                var found = marks[i].find();
-                if (!found) marks.splice(i--, 0);
-                else ranges.push({ anchor: found.from, head: found.to });
-              }
-            if (ranges.length) cm.setSelections(ranges, 0);
-          };
-          function modifyWordOrSelection(cm, mod) {
-            cm.operation(function () {
-              var ranges = cm.listSelections(),
-                indices = [],
-                replacements2 = [];
-              for (var i = 0; i < ranges.length; i++) {
-                var range2 = ranges[i];
-                if (range2.empty()) {
-                  indices.push(i);
-                  replacements2.push("");
-                } else
-                  replacements2.push(
-                    mod(cm.getRange(range2.from(), range2.to()))
-                  );
-              }
-              cm.replaceSelections(replacements2, "around", "case");
-              for (var i = indices.length - 1, at; i >= 0; i--) {
-                var range2 = ranges[indices[i]];
-                if (at && CodeMirror.cmpPos(range2.head, at) > 0) continue;
-                var word2 = wordAt(cm, range2.head);
-                at = word2.from;
-                cm.replaceRange(mod(word2.word), word2.from, word2.to);
-              }
-            });
-          }
-          cmds.smartBackspace = function (cm) {
-            if (cm.somethingSelected()) return CodeMirror.Pass;
-            cm.operation(function () {
-              var cursors = cm.listSelections();
-              var indentUnit = cm.getOption("indentUnit");
-              for (var i = cursors.length - 1; i >= 0; i--) {
-                var cursor = cursors[i].head;
-                var toStartOfLine = cm.getRange(
-                  { line: cursor.line, ch: 0 },
-                  cursor
-                );
-                var column = CodeMirror.countColumn(
-                  toStartOfLine,
-                  null,
-                  cm.getOption("tabSize")
-                );
-                var deletePos = cm.findPosH(cursor, -1, "char", false);
-                if (
-                  toStartOfLine &&
-                  !/\S/.test(toStartOfLine) &&
-                  column % indentUnit == 0
-                ) {
-                  var prevIndent = new Pos(
-                    cursor.line,
-                    CodeMirror.findColumn(
-                      toStartOfLine,
-                      column - indentUnit,
-                      indentUnit
-                    )
-                  );
-                  if (prevIndent.ch != cursor.ch) deletePos = prevIndent;
-                }
-                cm.replaceRange("", deletePos, cursor, "+delete");
-              }
-            });
-          };
-          cmds.delLineRight = function (cm) {
-            cm.operation(function () {
-              var ranges = cm.listSelections();
-              for (var i = ranges.length - 1; i >= 0; i--)
-                cm.replaceRange(
-                  "",
-                  ranges[i].anchor,
-                  Pos(ranges[i].to().line),
-                  "+delete"
-                );
-              cm.scrollIntoView();
-            });
-          };
-          cmds.upcaseAtCursor = function (cm) {
-            modifyWordOrSelection(cm, function (str) {
-              return str.toUpperCase();
-            });
-          };
-          cmds.downcaseAtCursor = function (cm) {
-            modifyWordOrSelection(cm, function (str) {
-              return str.toLowerCase();
-            });
-          };
-          cmds.setSublimeMark = function (cm) {
-            if (cm.state.sublimeMark) cm.state.sublimeMark.clear();
-            cm.state.sublimeMark = cm.setBookmark(cm.getCursor());
-          };
-          cmds.selectToSublimeMark = function (cm) {
-            var found = cm.state.sublimeMark && cm.state.sublimeMark.find();
-            if (found) cm.setSelection(cm.getCursor(), found);
-          };
-          cmds.deleteToSublimeMark = function (cm) {
-            var found = cm.state.sublimeMark && cm.state.sublimeMark.find();
-            if (found) {
-              var from = cm.getCursor(),
-                to = found;
-              if (CodeMirror.cmpPos(from, to) > 0) {
-                var tmp = to;
-                to = from;
-                from = tmp;
-              }
-              cm.state.sublimeKilled = cm.getRange(from, to);
-              cm.replaceRange("", from, to);
-            }
-          };
-          cmds.swapWithSublimeMark = function (cm) {
-            var found = cm.state.sublimeMark && cm.state.sublimeMark.find();
-            if (found) {
-              cm.state.sublimeMark.clear();
-              cm.state.sublimeMark = cm.setBookmark(cm.getCursor());
-              cm.setCursor(found);
-            }
-          };
-          cmds.sublimeYank = function (cm) {
-            if (cm.state.sublimeKilled != null)
-              cm.replaceSelection(cm.state.sublimeKilled, null, "paste");
-          };
-          cmds.showInCenter = function (cm) {
-            var pos = cm.cursorCoords(null, "local");
-            cm.scrollTo(
-              null,
-              (pos.top + pos.bottom) / 2 - cm.getScrollInfo().clientHeight / 2
-            );
-          };
-          function getTarget(cm) {
-            var from = cm.getCursor("from"),
-              to = cm.getCursor("to");
-            if (CodeMirror.cmpPos(from, to) == 0) {
-              var word2 = wordAt(cm, from);
-              if (!word2.word) return;
-              from = word2.from;
-              to = word2.to;
-            }
-            return { from, to, query: cm.getRange(from, to), word: word2 };
-          }
-          function findAndGoTo(cm, forward) {
-            var target2 = getTarget(cm);
-            if (!target2) return;
-            var query = target2.query;
-            var cur = cm.getSearchCursor(
-              query,
-              forward ? target2.to : target2.from
-            );
-            if (forward ? cur.findNext() : cur.findPrevious()) {
-              cm.setSelection(cur.from(), cur.to());
-            } else {
-              cur = cm.getSearchCursor(
-                query,
-                forward
-                  ? Pos(cm.firstLine(), 0)
-                  : cm.clipPos(Pos(cm.lastLine()))
-              );
-              if (forward ? cur.findNext() : cur.findPrevious())
-                cm.setSelection(cur.from(), cur.to());
-              else if (target2.word) cm.setSelection(target2.from, target2.to);
-            }
-          }
-          cmds.findUnder = function (cm) {
-            findAndGoTo(cm, true);
-          };
-          cmds.findUnderPrevious = function (cm) {
-            findAndGoTo(cm, false);
-          };
-          cmds.findAllUnder = function (cm) {
-            var target2 = getTarget(cm);
-            if (!target2) return;
-            var cur = cm.getSearchCursor(target2.query);
-            var matches = [];
-            var primaryIndex = -1;
-            while (cur.findNext()) {
-              matches.push({ anchor: cur.from(), head: cur.to() });
-              if (
-                cur.from().line <= target2.from.line &&
-                cur.from().ch <= target2.from.ch
-              )
-                primaryIndex++;
-            }
-            cm.setSelections(matches, primaryIndex);
-          };
-          var keyMap2 = CodeMirror.keyMap;
-          keyMap2.macSublime = {
-            "Cmd-Left": "goLineStartSmart",
-            "Shift-Tab": "indentLess",
-            "Shift-Ctrl-K": "deleteLine",
-            "Alt-Q": "wrapLines",
-            "Ctrl-Left": "goSubwordLeft",
-            "Ctrl-Right": "goSubwordRight",
-            "Ctrl-Alt-Up": "scrollLineUp",
-            "Ctrl-Alt-Down": "scrollLineDown",
-            "Cmd-L": "selectLine",
-            "Shift-Cmd-L": "splitSelectionByLine",
-            Esc: "singleSelectionTop",
-            "Cmd-Enter": "insertLineAfter",
-            "Shift-Cmd-Enter": "insertLineBefore",
-            "Cmd-D": "selectNextOccurrence",
-            "Shift-Cmd-Space": "selectScope",
-            "Shift-Cmd-M": "selectBetweenBrackets",
-            "Cmd-M": "goToBracket",
-            "Cmd-Ctrl-Up": "swapLineUp",
-            "Cmd-Ctrl-Down": "swapLineDown",
-            "Cmd-/": "toggleCommentIndented",
-            "Cmd-J": "joinLines",
-            "Shift-Cmd-D": "duplicateLine",
-            F5: "sortLines",
-            "Shift-F5": "reverseSortLines",
-            "Cmd-F5": "sortLinesInsensitive",
-            "Shift-Cmd-F5": "reverseSortLinesInsensitive",
-            F2: "nextBookmark",
-            "Shift-F2": "prevBookmark",
-            "Cmd-F2": "toggleBookmark",
-            "Shift-Cmd-F2": "clearBookmarks",
-            "Alt-F2": "selectBookmarks",
-            Backspace: "smartBackspace",
-            "Cmd-K Cmd-D": "skipAndSelectNextOccurrence",
-            "Cmd-K Cmd-K": "delLineRight",
-            "Cmd-K Cmd-U": "upcaseAtCursor",
-            "Cmd-K Cmd-L": "downcaseAtCursor",
-            "Cmd-K Cmd-Space": "setSublimeMark",
-            "Cmd-K Cmd-A": "selectToSublimeMark",
-            "Cmd-K Cmd-W": "deleteToSublimeMark",
-            "Cmd-K Cmd-X": "swapWithSublimeMark",
-            "Cmd-K Cmd-Y": "sublimeYank",
-            "Cmd-K Cmd-C": "showInCenter",
-            "Cmd-K Cmd-G": "clearBookmarks",
-            "Cmd-K Cmd-Backspace": "delLineLeft",
-            "Cmd-K Cmd-1": "foldAll",
-            "Cmd-K Cmd-0": "unfoldAll",
-            "Cmd-K Cmd-J": "unfoldAll",
-            "Ctrl-Shift-Up": "addCursorToPrevLine",
-            "Ctrl-Shift-Down": "addCursorToNextLine",
-            "Cmd-F3": "findUnder",
-            "Shift-Cmd-F3": "findUnderPrevious",
-            "Alt-F3": "findAllUnder",
-            "Shift-Cmd-[": "fold",
-            "Shift-Cmd-]": "unfold",
-            "Cmd-I": "findIncremental",
-            "Shift-Cmd-I": "findIncrementalReverse",
-            "Cmd-H": "replace",
-            F3: "findNext",
-            "Shift-F3": "findPrev",
-            fallthrough: "macDefault",
-          };
-          CodeMirror.normalizeKeyMap(keyMap2.macSublime);
-          keyMap2.pcSublime = {
-            "Shift-Tab": "indentLess",
-            "Shift-Ctrl-K": "deleteLine",
-            "Alt-Q": "wrapLines",
-            "Ctrl-T": "transposeChars",
-            "Alt-Left": "goSubwordLeft",
-            "Alt-Right": "goSubwordRight",
-            "Ctrl-Up": "scrollLineUp",
-            "Ctrl-Down": "scrollLineDown",
-            "Ctrl-L": "selectLine",
-            "Shift-Ctrl-L": "splitSelectionByLine",
-            Esc: "singleSelectionTop",
-            "Ctrl-Enter": "insertLineAfter",
-            "Shift-Ctrl-Enter": "insertLineBefore",
-            "Ctrl-D": "selectNextOccurrence",
-            "Shift-Ctrl-Space": "selectScope",
-            "Shift-Ctrl-M": "selectBetweenBrackets",
-            "Ctrl-M": "goToBracket",
-            "Shift-Ctrl-Up": "swapLineUp",
-            "Shift-Ctrl-Down": "swapLineDown",
-            "Ctrl-/": "toggleCommentIndented",
-            "Ctrl-J": "joinLines",
-            "Shift-Ctrl-D": "duplicateLine",
-            F9: "sortLines",
-            "Shift-F9": "reverseSortLines",
-            "Ctrl-F9": "sortLinesInsensitive",
-            "Shift-Ctrl-F9": "reverseSortLinesInsensitive",
-            F2: "nextBookmark",
-            "Shift-F2": "prevBookmark",
-            "Ctrl-F2": "toggleBookmark",
-            "Shift-Ctrl-F2": "clearBookmarks",
-            "Alt-F2": "selectBookmarks",
-            Backspace: "smartBackspace",
-            "Ctrl-K Ctrl-D": "skipAndSelectNextOccurrence",
-            "Ctrl-K Ctrl-K": "delLineRight",
-            "Ctrl-K Ctrl-U": "upcaseAtCursor",
-            "Ctrl-K Ctrl-L": "downcaseAtCursor",
-            "Ctrl-K Ctrl-Space": "setSublimeMark",
-            "Ctrl-K Ctrl-A": "selectToSublimeMark",
-            "Ctrl-K Ctrl-W": "deleteToSublimeMark",
-            "Ctrl-K Ctrl-X": "swapWithSublimeMark",
-            "Ctrl-K Ctrl-Y": "sublimeYank",
-            "Ctrl-K Ctrl-C": "showInCenter",
-            "Ctrl-K Ctrl-G": "clearBookmarks",
-            "Ctrl-K Ctrl-Backspace": "delLineLeft",
-            "Ctrl-K Ctrl-1": "foldAll",
-            "Ctrl-K Ctrl-0": "unfoldAll",
-            "Ctrl-K Ctrl-J": "unfoldAll",
-            "Ctrl-Alt-Up": "addCursorToPrevLine",
-            "Ctrl-Alt-Down": "addCursorToNextLine",
-            "Ctrl-F3": "findUnder",
-            "Shift-Ctrl-F3": "findUnderPrevious",
-            "Alt-F3": "findAllUnder",
-            "Shift-Ctrl-[": "fold",
-            "Shift-Ctrl-]": "unfold",
-            "Ctrl-I": "findIncremental",
-            "Shift-Ctrl-I": "findIncrementalReverse",
-            "Ctrl-H": "replace",
-            F3: "findNext",
-            "Shift-F3": "findPrev",
-            fallthrough: "pcDefault",
-          };
-          CodeMirror.normalizeKeyMap(keyMap2.pcSublime);
-          var mac = keyMap2.default == keyMap2.macDefault;
-          keyMap2.sublime = mac ? keyMap2.macSublime : keyMap2.pcSublime;
-        });
-      })();
-      var sublime = sublime$2.exports;
-      var sublime$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: sublime,
-          },
-          [sublime$2.exports]
-        )
-      );
-      var comment$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports);
-        })(function (CodeMirror) {
-          var noOptions = {};
-          var nonWS = /[^\s\u00a0]/;
-          var Pos = CodeMirror.Pos,
-            cmp = CodeMirror.cmpPos;
-          function firstNonWS(str) {
-            var found = str.search(nonWS);
-            return found == -1 ? 0 : found;
-          }
-          CodeMirror.commands.toggleComment = function (cm) {
-            cm.toggleComment();
-          };
-          CodeMirror.defineExtension("toggleComment", function (options) {
-            if (!options) options = noOptions;
-            var cm = this;
-            var minLine = Infinity,
-              ranges = this.listSelections(),
-              mode2 = null;
-            for (var i = ranges.length - 1; i >= 0; i--) {
-              var from = ranges[i].from(),
-                to = ranges[i].to();
-              if (from.line >= minLine) continue;
-              if (to.line >= minLine) to = Pos(minLine, 0);
-              minLine = from.line;
-              if (mode2 == null) {
-                if (cm.uncomment(from, to, options)) mode2 = "un";
-                else {
-                  cm.lineComment(from, to, options);
-                  mode2 = "line";
-                }
-              } else if (mode2 == "un") {
-                cm.uncomment(from, to, options);
-              } else {
-                cm.lineComment(from, to, options);
-              }
-            }
-          });
-          function probablyInsideString(cm, pos, line) {
-            return (
-              /\bstring\b/.test(cm.getTokenTypeAt(Pos(pos.line, 0))) &&
-              !/^[\'\"\`]/.test(line)
-            );
-          }
-          function getMode(cm, pos) {
-            var mode2 = cm.getMode();
-            return mode2.useInnerComments === false || !mode2.innerMode
-              ? mode2
-              : cm.getModeAt(pos);
-          }
-          CodeMirror.defineExtension(
-            "lineComment",
-            function (from, to, options) {
-              if (!options) options = noOptions;
-              var self2 = this,
-                mode2 = getMode(self2, from);
-              var firstLine = self2.getLine(from.line);
-              if (
-                firstLine == null ||
-                probablyInsideString(self2, from, firstLine)
-              )
-                return;
-              var commentString = options.lineComment || mode2.lineComment;
-              if (!commentString) {
-                if (options.blockCommentStart || mode2.blockCommentStart) {
-                  options.fullLines = true;
-                  self2.blockComment(from, to, options);
-                }
-                return;
-              }
-              var end2 = Math.min(
-                to.ch != 0 || to.line == from.line ? to.line + 1 : to.line,
-                self2.lastLine() + 1
-              );
-              var pad = options.padding == null ? " " : options.padding;
-              var blankLines =
-                options.commentBlankLines || from.line == to.line;
-              self2.operation(function () {
-                if (options.indent) {
-                  var baseString = null;
-                  for (var i = from.line; i < end2; ++i) {
-                    var line = self2.getLine(i);
-                    var whitespace = line.slice(0, firstNonWS(line));
-                    if (
-                      baseString == null ||
-                      baseString.length > whitespace.length
-                    ) {
-                      baseString = whitespace;
-                    }
-                  }
-                  for (var i = from.line; i < end2; ++i) {
-                    var line = self2.getLine(i),
-                      cut = baseString.length;
-                    if (!blankLines && !nonWS.test(line)) continue;
-                    if (line.slice(0, cut) != baseString)
-                      cut = firstNonWS(line);
-                    self2.replaceRange(
-                      baseString + commentString + pad,
-                      Pos(i, 0),
-                      Pos(i, cut)
-                    );
-                  }
-                } else {
-                  for (var i = from.line; i < end2; ++i) {
-                    if (blankLines || nonWS.test(self2.getLine(i)))
-                      self2.replaceRange(commentString + pad, Pos(i, 0));
-                  }
-                }
-              });
-            }
-          );
-          CodeMirror.defineExtension(
-            "blockComment",
-            function (from, to, options) {
-              if (!options) options = noOptions;
-              var self2 = this,
-                mode2 = getMode(self2, from);
-              var startString =
-                options.blockCommentStart || mode2.blockCommentStart;
-              var endString = options.blockCommentEnd || mode2.blockCommentEnd;
-              if (!startString || !endString) {
-                if (
-                  (options.lineComment || mode2.lineComment) &&
-                  options.fullLines != false
-                )
-                  self2.lineComment(from, to, options);
-                return;
-              }
-              if (/\bcomment\b/.test(self2.getTokenTypeAt(Pos(from.line, 0))))
-                return;
-              var end2 = Math.min(to.line, self2.lastLine());
-              if (
-                end2 != from.line &&
-                to.ch == 0 &&
-                nonWS.test(self2.getLine(end2))
-              )
-                --end2;
-              var pad = options.padding == null ? " " : options.padding;
-              if (from.line > end2) return;
-              self2.operation(function () {
-                if (options.fullLines != false) {
-                  var lastLineHasText = nonWS.test(self2.getLine(end2));
-                  self2.replaceRange(pad + endString, Pos(end2));
-                  self2.replaceRange(startString + pad, Pos(from.line, 0));
-                  var lead = options.blockCommentLead || mode2.blockCommentLead;
-                  if (lead != null) {
-                    for (var i = from.line + 1; i <= end2; ++i)
-                      if (i != end2 || lastLineHasText)
-                        self2.replaceRange(lead + pad, Pos(i, 0));
-                  }
-                } else {
-                  var atCursor = cmp(self2.getCursor("to"), to) == 0,
-                    empty2 = !self2.somethingSelected();
-                  self2.replaceRange(endString, to);
-                  if (atCursor)
-                    self2.setSelection(
-                      empty2 ? to : self2.getCursor("from"),
-                      to
-                    );
-                  self2.replaceRange(startString, from);
-                }
-              });
-            }
-          );
-          CodeMirror.defineExtension("uncomment", function (from, to, options) {
-            if (!options) options = noOptions;
-            var self2 = this,
-              mode2 = getMode(self2, from);
-            var end2 = Math.min(
-                to.ch != 0 || to.line == from.line ? to.line : to.line - 1,
-                self2.lastLine()
-              ),
-              start2 = Math.min(from.line, end2);
-            var lineString = options.lineComment || mode2.lineComment,
-              lines = [];
-            var pad = options.padding == null ? " " : options.padding,
-              didSomething;
-            lineComment: {
-              if (!lineString) break lineComment;
-              for (var i = start2; i <= end2; ++i) {
-                var line = self2.getLine(i);
-                var found = line.indexOf(lineString);
-                if (
-                  found > -1 &&
-                  !/comment/.test(self2.getTokenTypeAt(Pos(i, found + 1)))
-                )
-                  found = -1;
-                if (found == -1 && nonWS.test(line)) break lineComment;
-                if (found > -1 && nonWS.test(line.slice(0, found)))
-                  break lineComment;
-                lines.push(line);
-              }
-              self2.operation(function () {
-                for (var i2 = start2; i2 <= end2; ++i2) {
-                  var line2 = lines[i2 - start2];
-                  var pos = line2.indexOf(lineString),
-                    endPos = pos + lineString.length;
-                  if (pos < 0) continue;
-                  if (line2.slice(endPos, endPos + pad.length) == pad)
-                    endPos += pad.length;
-                  didSomething = true;
-                  self2.replaceRange("", Pos(i2, pos), Pos(i2, endPos));
-                }
-              });
-              if (didSomething) return true;
-            }
-            var startString =
-              options.blockCommentStart || mode2.blockCommentStart;
-            var endString = options.blockCommentEnd || mode2.blockCommentEnd;
-            if (!startString || !endString) return false;
-            var lead = options.blockCommentLead || mode2.blockCommentLead;
-            var startLine = self2.getLine(start2),
-              open = startLine.indexOf(startString);
-            if (open == -1) return false;
-            var endLine = end2 == start2 ? startLine : self2.getLine(end2);
-            var close = endLine.indexOf(
-              endString,
-              end2 == start2 ? open + startString.length : 0
-            );
-            var insideStart = Pos(start2, open + 1),
-              insideEnd = Pos(end2, close + 1);
-            if (
-              close == -1 ||
-              !/comment/.test(self2.getTokenTypeAt(insideStart)) ||
-              !/comment/.test(self2.getTokenTypeAt(insideEnd)) ||
-              self2.getRange(insideStart, insideEnd, "\n").indexOf(endString) >
-                -1
-            )
-              return false;
-            var lastStart = startLine.lastIndexOf(startString, from.ch);
-            var firstEnd =
-              lastStart == -1
-                ? -1
-                : startLine
-                    .slice(0, from.ch)
-                    .indexOf(endString, lastStart + startString.length);
-            if (
-              lastStart != -1 &&
-              firstEnd != -1 &&
-              firstEnd + endString.length != from.ch
-            )
-              return false;
-            firstEnd = endLine.indexOf(endString, to.ch);
-            var almostLastStart = endLine
-              .slice(to.ch)
-              .lastIndexOf(startString, firstEnd - to.ch);
-            lastStart =
-              firstEnd == -1 || almostLastStart == -1
-                ? -1
-                : to.ch + almostLastStart;
-            if (firstEnd != -1 && lastStart != -1 && lastStart != to.ch)
-              return false;
-            self2.operation(function () {
-              self2.replaceRange(
-                "",
-                Pos(
-                  end2,
-                  close -
-                    (pad && endLine.slice(close - pad.length, close) == pad
-                      ? pad.length
-                      : 0)
-                ),
-                Pos(end2, close + endString.length)
-              );
-              var openEnd = open + startString.length;
-              if (pad && startLine.slice(openEnd, openEnd + pad.length) == pad)
-                openEnd += pad.length;
-              self2.replaceRange("", Pos(start2, open), Pos(start2, openEnd));
-              if (lead)
-                for (var i2 = start2 + 1; i2 <= end2; ++i2) {
-                  var line2 = self2.getLine(i2),
-                    found2 = line2.indexOf(lead);
-                  if (found2 == -1 || nonWS.test(line2.slice(0, found2)))
-                    continue;
-                  var foundEnd = found2 + lead.length;
-                  if (
-                    pad &&
-                    line2.slice(foundEnd, foundEnd + pad.length) == pad
-                  )
-                    foundEnd += pad.length;
-                  self2.replaceRange("", Pos(i2, found2), Pos(i2, foundEnd));
-                }
-            });
-            return true;
-          });
-        });
-      })();
-      var comment = comment$2.exports;
-      var comment$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: comment,
-          },
-          [comment$2.exports]
-        )
-      );
-      var search$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports, searchcursor$2.exports, dialog$2.exports);
-        })(function (CodeMirror) {
-          CodeMirror.defineOption("search", { bottom: false });
-          function searchOverlay(query, caseInsensitive) {
-            if (typeof query == "string")
-              query = new RegExp(
-                query.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"),
-                caseInsensitive ? "gi" : "g"
-              );
-            else if (!query.global)
-              query = new RegExp(query.source, query.ignoreCase ? "gi" : "g");
-            return {
-              token: function (stream) {
-                query.lastIndex = stream.pos;
-                var match2 = query.exec(stream.string);
-                if (match2 && match2.index == stream.pos) {
-                  stream.pos += match2[0].length || 1;
-                  return "searching";
-                } else if (match2) {
-                  stream.pos = match2.index;
-                } else {
-                  stream.skipToEnd();
-                }
-              },
-            };
-          }
-          function SearchState() {
-            this.posFrom = this.posTo = this.lastQuery = this.query = null;
-            this.overlay = null;
-          }
-          function getSearchState(cm) {
-            return cm.state.search || (cm.state.search = new SearchState());
-          }
-          function queryCaseInsensitive(query) {
-            return typeof query == "string" && query == query.toLowerCase();
-          }
-          function getSearchCursor(cm, query, pos) {
-            return cm.getSearchCursor(query, pos, {
-              caseFold: queryCaseInsensitive(query),
-              multiline: true,
-            });
-          }
-          function persistentDialog(cm, text3, deflt, onEnter, onKeyDown2) {
-            cm.openDialog(text3, onEnter, {
-              value: deflt,
-              selectValueOnOpen: true,
-              closeOnEnter: false,
-              onClose: function () {
-                clearSearch(cm);
-              },
-              onKeyDown: onKeyDown2,
-              bottom: cm.options.search.bottom,
-            });
-          }
-          function dialog2(cm, text3, shortText, deflt, f) {
-            if (cm.openDialog)
-              cm.openDialog(text3, f, {
-                value: deflt,
-                selectValueOnOpen: true,
-                bottom: cm.options.search.bottom,
-              });
-            else f(prompt(shortText, deflt));
-          }
-          function confirmDialog(cm, text3, shortText, fs) {
-            if (cm.openConfirm) cm.openConfirm(text3, fs);
-            else if (confirm(shortText)) fs[0]();
-          }
-          function parseString(string2) {
-            return string2.replace(/\\([nrt\\])/g, function (match2, ch2) {
-              if (ch2 == "n") return "\n";
-              if (ch2 == "r") return "\r";
-              if (ch2 == "t") return "	";
-              if (ch2 == "\\") return "\\";
-              return match2;
-            });
-          }
-          function parseQuery2(query) {
-            var isRE = query.match(/^\/(.*)\/([a-z]*)$/);
-            if (isRE) {
-              try {
-                query = new RegExp(
-                  isRE[1],
-                  isRE[2].indexOf("i") == -1 ? "" : "i"
-                );
-              } catch (e) {}
-            } else {
-              query = parseString(query);
-            }
-            if (typeof query == "string" ? query == "" : query.test(""))
-              query = /x^/;
-            return query;
-          }
-          function startSearch(cm, state, query) {
-            state.queryText = query;
-            state.query = parseQuery2(query);
-            cm.removeOverlay(state.overlay, queryCaseInsensitive(state.query));
-            state.overlay = searchOverlay(
-              state.query,
-              queryCaseInsensitive(state.query)
-            );
-            cm.addOverlay(state.overlay);
-            if (cm.showMatchesOnScrollbar) {
-              if (state.annotate) {
-                state.annotate.clear();
-                state.annotate = null;
-              }
-              state.annotate = cm.showMatchesOnScrollbar(
-                state.query,
-                queryCaseInsensitive(state.query)
-              );
-            }
-          }
-          function doSearch(cm, rev, persistent, immediate) {
-            var state = getSearchState(cm);
-            if (state.query) return findNext(cm, rev);
-            var q2 = cm.getSelection() || state.lastQuery;
-            if (q2 instanceof RegExp && q2.source == "x^") q2 = null;
-            if (persistent && cm.openDialog) {
-              var hiding = null;
-              var searchNext = function (query, event) {
-                CodeMirror.e_stop(event);
-                if (!query) return;
-                if (query != state.queryText) {
-                  startSearch(cm, state, query);
-                  state.posFrom = state.posTo = cm.getCursor();
-                }
-                if (hiding) hiding.style.opacity = 1;
-                findNext(cm, event.shiftKey, function (_, to) {
-                  var dialog3;
-                  if (
-                    to.line < 3 &&
-                    document.querySelector &&
-                    (dialog3 =
-                      cm.display.wrapper.querySelector(".CodeMirror-dialog")) &&
-                    dialog3.getBoundingClientRect().bottom - 4 >
-                      cm.cursorCoords(to, "window").top
-                  )
-                    (hiding = dialog3).style.opacity = 0.4;
-                });
-              };
-              persistentDialog(
-                cm,
-                getQueryDialog(cm),
-                q2,
-                searchNext,
-                function (event, query) {
-                  var keyName = CodeMirror.keyName(event);
-                  var extra = cm.getOption("extraKeys"),
-                    cmd =
-                      (extra && extra[keyName]) ||
-                      CodeMirror.keyMap[cm.getOption("keyMap")][keyName];
-                  if (
-                    cmd == "findNext" ||
-                    cmd == "findPrev" ||
-                    cmd == "findPersistentNext" ||
-                    cmd == "findPersistentPrev"
-                  ) {
-                    CodeMirror.e_stop(event);
-                    startSearch(cm, getSearchState(cm), query);
-                    cm.execCommand(cmd);
-                  } else if (cmd == "find" || cmd == "findPersistent") {
-                    CodeMirror.e_stop(event);
-                    searchNext(query, event);
-                  }
-                }
-              );
-              if (immediate && q2) {
-                startSearch(cm, state, q2);
-                findNext(cm, rev);
-              }
-            } else {
-              dialog2(
-                cm,
-                getQueryDialog(cm),
-                "Search for:",
-                q2,
-                function (query) {
-                  if (query && !state.query)
-                    cm.operation(function () {
-                      startSearch(cm, state, query);
-                      state.posFrom = state.posTo = cm.getCursor();
-                      findNext(cm, rev);
-                    });
-                }
-              );
-            }
-          }
-          function findNext(cm, rev, callback) {
-            cm.operation(function () {
-              var state = getSearchState(cm);
-              var cursor = getSearchCursor(
-                cm,
-                state.query,
-                rev ? state.posFrom : state.posTo
-              );
-              if (!cursor.find(rev)) {
-                cursor = getSearchCursor(
-                  cm,
-                  state.query,
-                  rev
-                    ? CodeMirror.Pos(cm.lastLine())
-                    : CodeMirror.Pos(cm.firstLine(), 0)
-                );
-                if (!cursor.find(rev)) return;
-              }
-              cm.setSelection(cursor.from(), cursor.to());
-              cm.scrollIntoView({ from: cursor.from(), to: cursor.to() }, 20);
-              state.posFrom = cursor.from();
-              state.posTo = cursor.to();
-              if (callback) callback(cursor.from(), cursor.to());
-            });
-          }
-          function clearSearch(cm) {
-            cm.operation(function () {
-              var state = getSearchState(cm);
-              state.lastQuery = state.query;
-              if (!state.query) return;
-              state.query = state.queryText = null;
-              cm.removeOverlay(state.overlay);
-              if (state.annotate) {
-                state.annotate.clear();
-                state.annotate = null;
-              }
-            });
-          }
-          function el2(tag, attrs) {
-            var element = tag
-              ? document.createElement(tag)
-              : document.createDocumentFragment();
-            for (var key in attrs) {
-              element[key] = attrs[key];
-            }
-            for (var i = 2; i < arguments.length; i++) {
-              var child = arguments[i];
-              element.appendChild(
-                typeof child == "string"
-                  ? document.createTextNode(child)
-                  : child
-              );
-            }
-            return element;
-          }
-          function getQueryDialog(cm) {
-            return el2(
-              "",
-              null,
-              el2(
-                "span",
-                { className: "CodeMirror-search-label" },
-                cm.phrase("Search:")
-              ),
-              " ",
-              el2("input", {
-                type: "text",
-                style: "width: 10em",
-                className: "CodeMirror-search-field",
-              }),
-              " ",
-              el2(
-                "span",
-                { style: "color: #888", className: "CodeMirror-search-hint" },
-                cm.phrase("(Use /re/ syntax for regexp search)")
-              )
-            );
-          }
-          function getReplaceQueryDialog(cm) {
-            return el2(
-              "",
-              null,
-              " ",
-              el2("input", {
-                type: "text",
-                style: "width: 10em",
-                className: "CodeMirror-search-field",
-              }),
-              " ",
-              el2(
-                "span",
-                { style: "color: #888", className: "CodeMirror-search-hint" },
-                cm.phrase("(Use /re/ syntax for regexp search)")
-              )
-            );
-          }
-          function getReplacementQueryDialog(cm) {
-            return el2(
-              "",
-              null,
-              el2(
-                "span",
-                { className: "CodeMirror-search-label" },
-                cm.phrase("With:")
-              ),
-              " ",
-              el2("input", {
-                type: "text",
-                style: "width: 10em",
-                className: "CodeMirror-search-field",
-              })
-            );
-          }
-          function getDoReplaceConfirm(cm) {
-            return el2(
-              "",
-              null,
-              el2(
-                "span",
-                { className: "CodeMirror-search-label" },
-                cm.phrase("Replace?")
-              ),
-              " ",
-              el2("button", {}, cm.phrase("Yes")),
-              " ",
-              el2("button", {}, cm.phrase("No")),
-              " ",
-              el2("button", {}, cm.phrase("All")),
-              " ",
-              el2("button", {}, cm.phrase("Stop"))
-            );
-          }
-          function replaceAll(cm, query, text3) {
-            cm.operation(function () {
-              for (
-                var cursor = getSearchCursor(cm, query);
-                cursor.findNext();
-
-              ) {
-                if (typeof query != "string") {
-                  var match2 = cm
-                    .getRange(cursor.from(), cursor.to())
-                    .match(query);
-                  cursor.replace(
-                    text3.replace(/\$(\d)/g, function (_, i) {
-                      return match2[i];
-                    })
-                  );
-                } else cursor.replace(text3);
-              }
-            });
-          }
-          function replace2(cm, all) {
-            if (cm.getOption("readOnly")) return;
-            var query = cm.getSelection() || getSearchState(cm).lastQuery;
-            var dialogText = all
-              ? cm.phrase("Replace all:")
-              : cm.phrase("Replace:");
-            var fragment = el2(
-              "",
-              null,
-              el2("span", { className: "CodeMirror-search-label" }, dialogText),
-              getReplaceQueryDialog(cm)
-            );
-            dialog2(cm, fragment, dialogText, query, function (query2) {
-              if (!query2) return;
-              query2 = parseQuery2(query2);
-              dialog2(
-                cm,
-                getReplacementQueryDialog(cm),
-                cm.phrase("Replace with:"),
-                "",
-                function (text3) {
-                  text3 = parseString(text3);
-                  if (all) {
-                    replaceAll(cm, query2, text3);
-                  } else {
-                    clearSearch(cm);
-                    var cursor = getSearchCursor(
-                      cm,
-                      query2,
-                      cm.getCursor("from")
-                    );
-                    var advance = function () {
-                      var start2 = cursor.from(),
-                        match2;
-                      if (!(match2 = cursor.findNext())) {
-                        cursor = getSearchCursor(cm, query2);
-                        if (
-                          !(match2 = cursor.findNext()) ||
-                          (start2 &&
-                            cursor.from().line == start2.line &&
-                            cursor.from().ch == start2.ch)
-                        )
-                          return;
-                      }
-                      cm.setSelection(cursor.from(), cursor.to());
-                      cm.scrollIntoView({
-                        from: cursor.from(),
-                        to: cursor.to(),
-                      });
-                      confirmDialog(
-                        cm,
-                        getDoReplaceConfirm(cm),
-                        cm.phrase("Replace?"),
-                        [
-                          function () {
-                            doReplace(match2);
-                          },
-                          advance,
-                          function () {
-                            replaceAll(cm, query2, text3);
-                          },
-                        ]
-                      );
-                    };
-                    var doReplace = function (match2) {
-                      cursor.replace(
-                        typeof query2 == "string"
-                          ? text3
-                          : text3.replace(/\$(\d)/g, function (_, i) {
-                              return match2[i];
-                            })
-                      );
-                      advance();
-                    };
-                    advance();
-                  }
-                }
-              );
-            });
-          }
-          CodeMirror.commands.find = function (cm) {
-            clearSearch(cm);
-            doSearch(cm);
-          };
-          CodeMirror.commands.findPersistent = function (cm) {
-            clearSearch(cm);
-            doSearch(cm, false, true);
-          };
-          CodeMirror.commands.findPersistentNext = function (cm) {
-            doSearch(cm, false, true, true);
-          };
-          CodeMirror.commands.findPersistentPrev = function (cm) {
-            doSearch(cm, true, true, true);
-          };
-          CodeMirror.commands.findNext = doSearch;
-          CodeMirror.commands.findPrev = function (cm) {
-            doSearch(cm, true);
-          };
-          CodeMirror.commands.clearSearch = clearSearch;
-          CodeMirror.commands.replace = replace2;
-          CodeMirror.commands.replaceAll = function (cm) {
-            replace2(cm, true);
-          };
-        });
-      })();
-      var search = search$2.exports;
-      var search$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: search,
-          },
-          [search$2.exports]
-        )
-      );
-      var hint$3 = {};
-      var require$$1$1 = /* @__PURE__ */ getAugmentedNamespace(esm);
-      var __importDefault$c =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(hint$3, "__esModule", { value: true });
-      var codemirror_1$a = __importDefault$c(codemirror$2.exports);
-      var graphql_language_service_1$4 = require$$1$1;
-      codemirror_1$a.default.registerHelper(
-        "hint",
-        "graphql",
-        function (editor, options) {
-          var schema = options.schema;
-          if (!schema) {
-            return;
-          }
-          var cur = editor.getCursor();
-          var token2 = editor.getTokenAt(cur);
-          var tokenStart =
-            token2.type !== null && /"|\w/.test(token2.string[0])
-              ? token2.start
-              : token2.end;
-          var position = new graphql_language_service_1$4.Position(
-            cur.line,
-            tokenStart
-          );
-          var rawResults =
-            graphql_language_service_1$4.getAutocompleteSuggestions(
-              schema,
-              editor.getValue(),
-              position,
-              token2,
-              options.externalFragments
-            );
-          var results = {
-            list: rawResults.map(function (item) {
-              return {
-                text: item.label,
-                type: item.type,
-                description: item.documentation,
-                isDeprecated: item.isDeprecated,
-                deprecationReason: item.deprecationReason,
-              };
-            }),
-            from: { line: cur.line, ch: tokenStart },
-            to: { line: cur.line, ch: token2.end },
-          };
-          if (results && results.list && results.list.length > 0) {
-            results.from = codemirror_1$a.default.Pos(
-              results.from.line,
-              results.from.ch
-            );
-            results.to = codemirror_1$a.default.Pos(
-              results.to.line,
-              results.to.ch
-            );
-            codemirror_1$a.default.signal(
-              editor,
-              "hasCompletion",
-              editor,
-              results,
-              token2
-            );
-          }
-          return results;
-        }
-      );
-      var hint$2 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: hint$3,
-          },
-          [hint$3]
-        )
-      );
-      var lint$3 = {};
-      var __importDefault$b =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(lint$3, "__esModule", { value: true });
-      var codemirror_1$9 = __importDefault$b(codemirror$2.exports);
-      var graphql_language_service_1$3 = require$$1$1;
-      var SEVERITY = ["error", "warning", "information", "hint"];
-      var TYPE = {
-        "GraphQL: Validation": "validation",
-        "GraphQL: Deprecation": "deprecation",
-        "GraphQL: Syntax": "syntax",
-      };
-      codemirror_1$9.default.registerHelper(
-        "lint",
-        "graphql",
-        function (text3, options) {
-          var schema = options.schema;
-          var rawResults = graphql_language_service_1$3.getDiagnostics(
-            text3,
-            schema,
-            options.validationRules,
-            void 0,
-            options.externalFragments
-          );
-          var results = rawResults.map(function (error2) {
-            return {
-              message: error2.message,
-              severity: error2.severity
-                ? SEVERITY[error2.severity - 1]
-                : SEVERITY[0],
-              type: error2.source ? TYPE[error2.source] : void 0,
-              from: codemirror_1$9.default.Pos(
-                error2.range.start.line,
-                error2.range.start.character
-              ),
-              to: codemirror_1$9.default.Pos(
-                error2.range.end.line,
-                error2.range.end.character
-              ),
-            };
-          });
-          return results;
-        }
-      );
-      var lint$2 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: lint$3,
-          },
-          [lint$3]
-        )
-      );
-      var info$1 = {};
-      var getTypeInfo$2 = {};
-      var require$$1 = /* @__PURE__ */ getAugmentedNamespace(introspection);
-      var forEachState$1 = {};
-      Object.defineProperty(forEachState$1, "__esModule", { value: true });
-      function forEachState(stack, fn) {
-        var reverseStateStack = [];
-        var state = stack;
-        while (state && state.kind) {
-          reverseStateStack.push(state);
-          state = state.prevState;
-        }
-        for (var i = reverseStateStack.length - 1; i >= 0; i--) {
-          fn(reverseStateStack[i]);
-        }
-      }
-      forEachState$1.default = forEachState;
-      var __importDefault$a =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(getTypeInfo$2, "__esModule", { value: true });
-      var graphql_1$4 = require$$1$2;
-      var introspection_1 = require$$1;
-      var forEachState_1$1 = __importDefault$a(forEachState$1);
-      function getTypeInfo$1(schema, tokenState) {
-        var info2 = {
-          schema,
-          type: null,
-          parentType: null,
-          inputType: null,
-          directiveDef: null,
-          fieldDef: null,
-          argDef: null,
-          argDefs: null,
-          objectFieldDefs: null,
-        };
-        forEachState_1$1.default(tokenState, function (state) {
-          switch (state.kind) {
-            case "Query":
-            case "ShortQuery":
-              info2.type = schema.getQueryType();
-              break;
-            case "Mutation":
-              info2.type = schema.getMutationType();
-              break;
-            case "Subscription":
-              info2.type = schema.getSubscriptionType();
-              break;
-            case "InlineFragment":
-            case "FragmentDefinition":
-              if (state.type) {
-                info2.type = schema.getType(state.type);
-              }
-              break;
-            case "Field":
-            case "AliasedField":
-              info2.fieldDef =
-                info2.type && state.name
-                  ? getFieldDef(schema, info2.parentType, state.name)
-                  : null;
-              info2.type = info2.fieldDef && info2.fieldDef.type;
-              break;
-            case "SelectionSet":
-              info2.parentType = info2.type
-                ? graphql_1$4.getNamedType(info2.type)
-                : null;
-              break;
-            case "Directive":
-              info2.directiveDef = state.name
-                ? schema.getDirective(state.name)
-                : null;
-              break;
-            case "Arguments":
-              var parentDef = state.prevState
-                ? state.prevState.kind === "Field"
-                  ? info2.fieldDef
-                  : state.prevState.kind === "Directive"
-                  ? info2.directiveDef
-                  : state.prevState.kind === "AliasedField"
-                  ? state.prevState.name &&
-                    getFieldDef(schema, info2.parentType, state.prevState.name)
-                  : null
-                : null;
-              info2.argDefs = parentDef ? parentDef.args : null;
-              break;
-            case "Argument":
-              info2.argDef = null;
-              if (info2.argDefs) {
-                for (var i = 0; i < info2.argDefs.length; i++) {
-                  if (info2.argDefs[i].name === state.name) {
-                    info2.argDef = info2.argDefs[i];
-                    break;
-                  }
-                }
-              }
-              info2.inputType = info2.argDef && info2.argDef.type;
-              break;
-            case "EnumValue":
-              var enumType = info2.inputType
-                ? graphql_1$4.getNamedType(info2.inputType)
-                : null;
-              info2.enumValue =
-                enumType instanceof graphql_1$4.GraphQLEnumType
-                  ? find(enumType.getValues(), function (val) {
-                      return val.value === state.name;
-                    })
-                  : null;
-              break;
-            case "ListValue":
-              var nullableType = info2.inputType
-                ? graphql_1$4.getNullableType(info2.inputType)
-                : null;
-              info2.inputType =
-                nullableType instanceof graphql_1$4.GraphQLList
-                  ? nullableType.ofType
-                  : null;
-              break;
-            case "ObjectValue":
-              var objectType = info2.inputType
-                ? graphql_1$4.getNamedType(info2.inputType)
-                : null;
-              info2.objectFieldDefs =
-                objectType instanceof graphql_1$4.GraphQLInputObjectType
-                  ? objectType.getFields()
-                  : null;
-              break;
-            case "ObjectField":
-              var objectField =
-                state.name && info2.objectFieldDefs
-                  ? info2.objectFieldDefs[state.name]
-                  : null;
-              info2.inputType = objectField && objectField.type;
-              break;
-            case "NamedType":
-              info2.type = state.name ? schema.getType(state.name) : null;
-              break;
-          }
-        });
-        return info2;
-      }
-      getTypeInfo$2.default = getTypeInfo$1;
-      function getFieldDef(schema, type2, fieldName) {
-        if (
-          fieldName === introspection_1.SchemaMetaFieldDef.name &&
-          schema.getQueryType() === type2
-        ) {
-          return introspection_1.SchemaMetaFieldDef;
-        }
-        if (
-          fieldName === introspection_1.TypeMetaFieldDef.name &&
-          schema.getQueryType() === type2
-        ) {
-          return introspection_1.TypeMetaFieldDef;
-        }
-        if (
-          fieldName === introspection_1.TypeNameMetaFieldDef.name &&
-          graphql_1$4.isCompositeType(type2)
-        ) {
-          return introspection_1.TypeNameMetaFieldDef;
-        }
-        if (type2 && type2.getFields) {
-          return type2.getFields()[fieldName];
-        }
-      }
-      function find(array, predicate) {
-        for (var i = 0; i < array.length; i++) {
-          if (predicate(array[i])) {
-            return array[i];
-          }
-        }
-      }
-      var SchemaReference = {};
-      Object.defineProperty(SchemaReference, "__esModule", { value: true });
-      SchemaReference.getTypeReference =
-        SchemaReference.getEnumValueReference =
-        SchemaReference.getArgumentReference =
-        SchemaReference.getDirectiveReference =
-        SchemaReference.getFieldReference =
-          void 0;
-      var graphql_1$3 = require$$1$2;
-      function getFieldReference(typeInfo) {
-        return {
-          kind: "Field",
-          schema: typeInfo.schema,
-          field: typeInfo.fieldDef,
-          type: isMetaField(typeInfo.fieldDef) ? null : typeInfo.parentType,
-        };
-      }
-      SchemaReference.getFieldReference = getFieldReference;
-      function getDirectiveReference(typeInfo) {
-        return {
-          kind: "Directive",
-          schema: typeInfo.schema,
-          directive: typeInfo.directiveDef,
-        };
-      }
-      SchemaReference.getDirectiveReference = getDirectiveReference;
-      function getArgumentReference(typeInfo) {
-        return typeInfo.directiveDef
-          ? {
-              kind: "Argument",
-              schema: typeInfo.schema,
-              argument: typeInfo.argDef,
-              directive: typeInfo.directiveDef,
-            }
-          : {
-              kind: "Argument",
-              schema: typeInfo.schema,
-              argument: typeInfo.argDef,
-              field: typeInfo.fieldDef,
-              type: isMetaField(typeInfo.fieldDef) ? null : typeInfo.parentType,
-            };
-      }
-      SchemaReference.getArgumentReference = getArgumentReference;
-      function getEnumValueReference(typeInfo) {
-        return {
-          kind: "EnumValue",
-          value: typeInfo.enumValue || void 0,
-          type: typeInfo.inputType
-            ? graphql_1$3.getNamedType(typeInfo.inputType)
-            : void 0,
-        };
-      }
-      SchemaReference.getEnumValueReference = getEnumValueReference;
-      function getTypeReference(typeInfo, type2) {
-        return {
-          kind: "Type",
-          schema: typeInfo.schema,
-          type: type2 || typeInfo.type,
-        };
-      }
-      SchemaReference.getTypeReference = getTypeReference;
-      function isMetaField(fieldDef) {
-        return fieldDef.name.slice(0, 2) === "__";
-      }
-      var infoAddon$1 = {};
-      var __importDefault$9 =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(infoAddon$1, "__esModule", { value: true });
-      var codemirror_1$8 = __importDefault$9(codemirror$2.exports);
-      codemirror_1$8.default.defineOption(
-        "info",
-        false,
-        function (cm, options, old) {
-          if (old && old !== codemirror_1$8.default.Init) {
-            var oldOnMouseOver = cm.state.info.onMouseOver;
-            codemirror_1$8.default.off(
-              cm.getWrapperElement(),
-              "mouseover",
-              oldOnMouseOver
-            );
-            clearTimeout(cm.state.info.hoverTimeout);
-            delete cm.state.info;
-          }
-          if (options) {
-            var state = (cm.state.info = createState(options));
-            state.onMouseOver = onMouseOver$1.bind(null, cm);
-            codemirror_1$8.default.on(
-              cm.getWrapperElement(),
-              "mouseover",
-              state.onMouseOver
-            );
-          }
-        }
-      );
-      function createState(options) {
-        return {
-          options:
-            options instanceof Function
-              ? { render: options }
-              : options === true
-              ? {}
-              : options,
-        };
-      }
-      function getHoverTime(cm) {
-        var options = cm.state.info.options;
-        return (options && options.hoverTime) || 500;
-      }
-      function onMouseOver$1(cm, e) {
-        var state = cm.state.info;
-        var target2 = e.target || e.srcElement;
-        if (!(target2 instanceof HTMLElement)) {
-          return;
-        }
-        if (target2.nodeName !== "SPAN" || state.hoverTimeout !== void 0) {
-          return;
-        }
-        var box = target2.getBoundingClientRect();
-        var onMouseMove = function () {
-          clearTimeout(state.hoverTimeout);
-          state.hoverTimeout = setTimeout(onHover, hoverTime);
-        };
-        var onMouseOut2 = function () {
-          codemirror_1$8.default.off(document, "mousemove", onMouseMove);
-          codemirror_1$8.default.off(
-            cm.getWrapperElement(),
-            "mouseout",
-            onMouseOut2
-          );
-          clearTimeout(state.hoverTimeout);
-          state.hoverTimeout = void 0;
-        };
-        var onHover = function () {
-          codemirror_1$8.default.off(document, "mousemove", onMouseMove);
-          codemirror_1$8.default.off(
-            cm.getWrapperElement(),
-            "mouseout",
-            onMouseOut2
-          );
-          state.hoverTimeout = void 0;
-          onMouseHover(cm, box);
-        };
-        var hoverTime = getHoverTime(cm);
-        state.hoverTimeout = setTimeout(onHover, hoverTime);
-        codemirror_1$8.default.on(document, "mousemove", onMouseMove);
-        codemirror_1$8.default.on(
-          cm.getWrapperElement(),
-          "mouseout",
-          onMouseOut2
-        );
-      }
-      function onMouseHover(cm, box) {
-        var pos = cm.coordsChar({
-          left: (box.left + box.right) / 2,
-          top: (box.top + box.bottom) / 2,
-        });
-        var state = cm.state.info;
-        var options = state.options;
-        var render = options.render || cm.getHelper(pos, "info");
-        if (render) {
-          var token2 = cm.getTokenAt(pos, true);
-          if (token2) {
-            var info2 = render(token2, options, cm, pos);
-            if (info2) {
-              showPopup(cm, box, info2);
-            }
-          }
-        }
-      }
-      function showPopup(cm, box, info2) {
-        var popup = document.createElement("div");
-        popup.className = "CodeMirror-info";
-        popup.appendChild(info2);
-        document.body.appendChild(popup);
-        var popupBox = popup.getBoundingClientRect();
-        var popupStyle = window.getComputedStyle(popup);
-        var popupWidth =
-          popupBox.right -
-          popupBox.left +
-          parseFloat(popupStyle.marginLeft) +
-          parseFloat(popupStyle.marginRight);
-        var popupHeight =
-          popupBox.bottom -
-          popupBox.top +
-          parseFloat(popupStyle.marginTop) +
-          parseFloat(popupStyle.marginBottom);
-        var topPos = box.bottom;
-        if (
-          popupHeight > window.innerHeight - box.bottom - 15 &&
-          box.top > window.innerHeight - box.bottom
-        ) {
-          topPos = box.top - popupHeight;
-        }
-        if (topPos < 0) {
-          topPos = box.bottom;
-        }
-        var leftPos = Math.max(0, window.innerWidth - popupWidth - 15);
-        if (leftPos > box.left) {
-          leftPos = box.left;
-        }
-        popup.style.opacity = "1";
-        popup.style.top = topPos + "px";
-        popup.style.left = leftPos + "px";
-        var popupTimeout;
-        var onMouseOverPopup = function () {
-          clearTimeout(popupTimeout);
-        };
-        var onMouseOut2 = function () {
-          clearTimeout(popupTimeout);
-          popupTimeout = setTimeout(hidePopup, 200);
-        };
-        var hidePopup = function () {
-          codemirror_1$8.default.off(popup, "mouseover", onMouseOverPopup);
-          codemirror_1$8.default.off(popup, "mouseout", onMouseOut2);
-          codemirror_1$8.default.off(
-            cm.getWrapperElement(),
-            "mouseout",
-            onMouseOut2
-          );
-          if (popup.style.opacity) {
-            popup.style.opacity = "0";
-            setTimeout(function () {
-              if (popup.parentNode) {
-                popup.parentNode.removeChild(popup);
-              }
-            }, 600);
-          } else if (popup.parentNode) {
-            popup.parentNode.removeChild(popup);
-          }
-        };
-        codemirror_1$8.default.on(popup, "mouseover", onMouseOverPopup);
-        codemirror_1$8.default.on(popup, "mouseout", onMouseOut2);
-        codemirror_1$8.default.on(
-          cm.getWrapperElement(),
-          "mouseout",
-          onMouseOut2
-        );
-      }
-      var infoAddon = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: infoAddon$1,
-          },
-          [infoAddon$1]
-        )
-      );
-      var __importDefault$8 =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(info$1, "__esModule", { value: true });
-      var graphql_1$2 = require$$1$2;
-      var codemirror_1$7 = __importDefault$8(codemirror$2.exports);
-      var getTypeInfo_1$1 = __importDefault$8(getTypeInfo$2);
-      var SchemaReference_1$1 = SchemaReference;
-      codemirror_1$7.default.registerHelper(
-        "info",
-        "graphql",
-        function (token2, options) {
-          if (!options.schema || !token2.state) {
-            return;
-          }
-          var state = token2.state;
-          var kind2 = state.kind;
-          var step = state.step;
-          var typeInfo = getTypeInfo_1$1.default(options.schema, token2.state);
-          if (
-            (kind2 === "Field" && step === 0 && typeInfo.fieldDef) ||
-            (kind2 === "AliasedField" && step === 2 && typeInfo.fieldDef)
-          ) {
-            var into = document.createElement("div");
-            renderField(into, typeInfo, options);
-            renderDescription(into, options, typeInfo.fieldDef);
-            return into;
-          } else if (
-            kind2 === "Directive" &&
-            step === 1 &&
-            typeInfo.directiveDef
-          ) {
-            var into = document.createElement("div");
-            renderDirective(into, typeInfo, options);
-            renderDescription(into, options, typeInfo.directiveDef);
-            return into;
-          } else if (kind2 === "Argument" && step === 0 && typeInfo.argDef) {
-            var into = document.createElement("div");
-            renderArg(into, typeInfo, options);
-            renderDescription(into, options, typeInfo.argDef);
-            return into;
-          } else if (
-            kind2 === "EnumValue" &&
-            typeInfo.enumValue &&
-            typeInfo.enumValue.description
-          ) {
-            var into = document.createElement("div");
-            renderEnumValue(into, typeInfo, options);
-            renderDescription(into, options, typeInfo.enumValue);
-            return into;
-          } else if (
-            kind2 === "NamedType" &&
-            typeInfo.type &&
-            typeInfo.type.description
-          ) {
-            var into = document.createElement("div");
-            renderType(into, typeInfo, options, typeInfo.type);
-            renderDescription(into, options, typeInfo.type);
-            return into;
-          }
-        }
-      );
-      function renderField(into, typeInfo, options) {
-        renderQualifiedField(into, typeInfo, options);
-        renderTypeAnnotation(into, typeInfo, options, typeInfo.type);
-      }
-      function renderQualifiedField(into, typeInfo, options) {
-        var _a2;
-        var fieldName =
-          ((_a2 = typeInfo.fieldDef) === null || _a2 === void 0
-            ? void 0
-            : _a2.name) || "";
-        if (fieldName.slice(0, 2) !== "__") {
-          renderType(into, typeInfo, options, typeInfo.parentType);
-          text2(into, ".");
-        }
-        text2(
-          into,
-          fieldName,
-          "field-name",
-          options,
-          SchemaReference_1$1.getFieldReference(typeInfo)
-        );
-      }
-      function renderDirective(into, typeInfo, options) {
-        var _a2;
-        var name2 =
-          "@" +
-          (((_a2 = typeInfo.directiveDef) === null || _a2 === void 0
-            ? void 0
-            : _a2.name) || "");
-        text2(
-          into,
-          name2,
-          "directive-name",
-          options,
-          SchemaReference_1$1.getDirectiveReference(typeInfo)
-        );
-      }
-      function renderArg(into, typeInfo, options) {
-        var _a2;
-        if (typeInfo.directiveDef) {
-          renderDirective(into, typeInfo, options);
-        } else if (typeInfo.fieldDef) {
-          renderQualifiedField(into, typeInfo, options);
-        }
-        var name2 =
-          ((_a2 = typeInfo.argDef) === null || _a2 === void 0
-            ? void 0
-            : _a2.name) || "";
-        text2(into, "(");
-        text2(
-          into,
-          name2,
-          "arg-name",
-          options,
-          SchemaReference_1$1.getArgumentReference(typeInfo)
-        );
-        renderTypeAnnotation(into, typeInfo, options, typeInfo.inputType);
-        text2(into, ")");
-      }
-      function renderTypeAnnotation(into, typeInfo, options, t2) {
-        text2(into, ": ");
-        renderType(into, typeInfo, options, t2);
-      }
-      function renderEnumValue(into, typeInfo, options) {
-        var _a2;
-        var name2 =
-          ((_a2 = typeInfo.enumValue) === null || _a2 === void 0
-            ? void 0
-            : _a2.name) || "";
-        renderType(into, typeInfo, options, typeInfo.inputType);
-        text2(into, ".");
-        text2(
-          into,
-          name2,
-          "enum-value",
-          options,
-          SchemaReference_1$1.getEnumValueReference(typeInfo)
-        );
-      }
-      function renderType(into, typeInfo, options, t2) {
-        if (t2 instanceof graphql_1$2.GraphQLNonNull) {
-          renderType(into, typeInfo, options, t2.ofType);
-          text2(into, "!");
-        } else if (t2 instanceof graphql_1$2.GraphQLList) {
-          text2(into, "[");
-          renderType(into, typeInfo, options, t2.ofType);
-          text2(into, "]");
-        } else {
-          text2(
-            into,
-            (t2 === null || t2 === void 0 ? void 0 : t2.name) || "",
-            "type-name",
-            options,
-            SchemaReference_1$1.getTypeReference(typeInfo, t2)
-          );
-        }
-      }
-      function renderDescription(into, options, def) {
-        var description = def.description;
-        if (description) {
-          var descriptionDiv = document.createElement("div");
-          descriptionDiv.className = "info-description";
-          if (options.renderDescription) {
-            descriptionDiv.innerHTML = options.renderDescription(description);
-          } else {
-            descriptionDiv.appendChild(document.createTextNode(description));
-          }
-          into.appendChild(descriptionDiv);
-        }
-        renderDeprecation(into, options, def);
-      }
-      function renderDeprecation(into, options, def) {
-        var reason = def.deprecationReason;
-        if (reason) {
-          var deprecationDiv = document.createElement("div");
-          deprecationDiv.className = "info-deprecation";
-          if (options.renderDescription) {
-            deprecationDiv.innerHTML = options.renderDescription(reason);
-          } else {
-            deprecationDiv.appendChild(document.createTextNode(reason));
-          }
-          var label = document.createElement("span");
-          label.className = "info-deprecation-label";
-          label.appendChild(document.createTextNode("Deprecated: "));
-          deprecationDiv.insertBefore(label, deprecationDiv.firstChild);
-          into.appendChild(deprecationDiv);
-        }
-      }
-      function text2(into, content, className, options, ref) {
-        if (className === void 0) {
-          className = "";
-        }
-        if (options === void 0) {
-          options = { onClick: null };
-        }
-        if (ref === void 0) {
-          ref = null;
-        }
-        if (className) {
-          var onClick_1 = options.onClick;
-          var node = void 0;
-          if (onClick_1) {
-            node = document.createElement("a");
-            node.href = "javascript:void 0";
-            node.addEventListener("click", function (e) {
-              onClick_1(ref, e);
-            });
-          } else {
-            node = document.createElement("span");
-          }
-          node.className = className;
-          node.appendChild(document.createTextNode(content));
-          into.appendChild(node);
-        } else {
-          into.appendChild(document.createTextNode(content));
-        }
-      }
-      var info = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: info$1,
-          },
-          [info$1]
-        )
-      );
-      var jump$1 = {};
-      var jumpAddon = {};
-      var __importDefault$7 =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(jumpAddon, "__esModule", { value: true });
-      var codemirror_1$6 = __importDefault$7(codemirror$2.exports);
-      codemirror_1$6.default.defineOption(
-        "jump",
-        false,
-        function (cm, options, old) {
-          if (old && old !== codemirror_1$6.default.Init) {
-            var oldOnMouseOver = cm.state.jump.onMouseOver;
-            codemirror_1$6.default.off(
-              cm.getWrapperElement(),
-              "mouseover",
-              oldOnMouseOver
-            );
-            var oldOnMouseOut = cm.state.jump.onMouseOut;
-            codemirror_1$6.default.off(
-              cm.getWrapperElement(),
-              "mouseout",
-              oldOnMouseOut
-            );
-            codemirror_1$6.default.off(
-              document,
-              "keydown",
-              cm.state.jump.onKeyDown
-            );
-            delete cm.state.jump;
-          }
-          if (options) {
-            var state = (cm.state.jump = {
-              options,
-              onMouseOver: onMouseOver.bind(null, cm),
-              onMouseOut: onMouseOut.bind(null, cm),
-              onKeyDown: onKeyDown.bind(null, cm),
-            });
-            codemirror_1$6.default.on(
-              cm.getWrapperElement(),
-              "mouseover",
-              state.onMouseOver
-            );
-            codemirror_1$6.default.on(
-              cm.getWrapperElement(),
-              "mouseout",
-              state.onMouseOut
-            );
-            codemirror_1$6.default.on(document, "keydown", state.onKeyDown);
-          }
-        }
-      );
-      function onMouseOver(cm, event) {
-        var target2 = event.target || event.srcElement;
-        if (!(target2 instanceof HTMLElement)) {
-          return;
-        }
-        if (
-          (target2 === null || target2 === void 0
-            ? void 0
-            : target2.nodeName) !== "SPAN"
-        ) {
-          return;
-        }
-        var box = target2.getBoundingClientRect();
-        var cursor = {
-          left: (box.left + box.right) / 2,
-          top: (box.top + box.bottom) / 2,
-        };
-        cm.state.jump.cursor = cursor;
-        if (cm.state.jump.isHoldingModifier) {
-          enableJumpMode(cm);
-        }
-      }
-      function onMouseOut(cm) {
-        if (!cm.state.jump.isHoldingModifier && cm.state.jump.cursor) {
-          cm.state.jump.cursor = null;
-          return;
-        }
-        if (cm.state.jump.isHoldingModifier && cm.state.jump.marker) {
-          disableJumpMode(cm);
-        }
-      }
-      function onKeyDown(cm, event) {
-        if (cm.state.jump.isHoldingModifier || !isJumpModifier(event.key)) {
-          return;
-        }
-        cm.state.jump.isHoldingModifier = true;
-        if (cm.state.jump.cursor) {
-          enableJumpMode(cm);
-        }
-        var onKeyUp = function (upEvent) {
-          if (upEvent.code !== event.code) {
-            return;
-          }
-          cm.state.jump.isHoldingModifier = false;
-          if (cm.state.jump.marker) {
-            disableJumpMode(cm);
-          }
-          codemirror_1$6.default.off(document, "keyup", onKeyUp);
-          codemirror_1$6.default.off(document, "click", onClick);
-          cm.off("mousedown", onMouseDown);
-        };
-        var onClick = function (clickEvent) {
-          var destination = cm.state.jump.destination;
-          if (destination) {
-            cm.state.jump.options.onClick(destination, clickEvent);
-          }
-        };
-        var onMouseDown = function (_, downEvent) {
-          if (cm.state.jump.destination) {
-            downEvent.codemirrorIgnore = true;
-          }
-        };
-        codemirror_1$6.default.on(document, "keyup", onKeyUp);
-        codemirror_1$6.default.on(document, "click", onClick);
-        cm.on("mousedown", onMouseDown);
-      }
-      var isMac =
-        typeof navigator !== "undefined" &&
-        navigator &&
-        navigator.appVersion.indexOf("Mac") !== -1;
-      function isJumpModifier(key) {
-        return key === (isMac ? "Meta" : "Control");
-      }
-      function enableJumpMode(cm) {
-        if (cm.state.jump.marker) {
-          return;
-        }
-        var cursor = cm.state.jump.cursor;
-        var pos = cm.coordsChar(cursor);
-        var token2 = cm.getTokenAt(pos, true);
-        var options = cm.state.jump.options;
-        var getDestination =
-          options.getDestination || cm.getHelper(pos, "jump");
-        if (getDestination) {
-          var destination = getDestination(token2, options, cm);
-          if (destination) {
-            var marker2 = cm.markText(
-              { line: pos.line, ch: token2.start },
-              { line: pos.line, ch: token2.end },
-              { className: "CodeMirror-jump-token" }
-            );
-            cm.state.jump.marker = marker2;
-            cm.state.jump.destination = destination;
-          }
-        }
-      }
-      function disableJumpMode(cm) {
-        var marker2 = cm.state.jump.marker;
-        cm.state.jump.marker = null;
-        cm.state.jump.destination = null;
-        marker2.clear();
-      }
-      var __importDefault$6 =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(jump$1, "__esModule", { value: true });
-      var codemirror_1$5 = __importDefault$6(codemirror$2.exports);
-      var getTypeInfo_1 = __importDefault$6(getTypeInfo$2);
-      var SchemaReference_1 = SchemaReference;
-      codemirror_1$5.default.registerHelper(
-        "jump",
-        "graphql",
-        function (token2, options) {
-          if (!options.schema || !options.onClick || !token2.state) {
-            return;
-          }
-          var state = token2.state;
-          var kind2 = state.kind;
-          var step = state.step;
-          var typeInfo = getTypeInfo_1.default(options.schema, state);
-          if (
-            (kind2 === "Field" && step === 0 && typeInfo.fieldDef) ||
-            (kind2 === "AliasedField" && step === 2 && typeInfo.fieldDef)
-          ) {
-            return SchemaReference_1.getFieldReference(typeInfo);
-          } else if (
-            kind2 === "Directive" &&
-            step === 1 &&
-            typeInfo.directiveDef
-          ) {
-            return SchemaReference_1.getDirectiveReference(typeInfo);
-          } else if (kind2 === "Argument" && step === 0 && typeInfo.argDef) {
-            return SchemaReference_1.getArgumentReference(typeInfo);
-          } else if (kind2 === "EnumValue" && typeInfo.enumValue) {
-            return SchemaReference_1.getEnumValueReference(typeInfo);
-          } else if (kind2 === "NamedType" && typeInfo.type) {
-            return SchemaReference_1.getTypeReference(typeInfo);
-          }
-        }
-      );
-      var jump = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: jump$1,
-          },
-          [jump$1]
-        )
-      );
-      var mode$5 = {};
-      var modeFactory = {};
-      var modeIndent = {};
-      Object.defineProperty(modeIndent, "__esModule", { value: true });
-      function indent$2(state, textAfter) {
-        var _a2, _b;
-        var levels = state.levels;
-        var level =
-          !levels || levels.length === 0
-            ? state.indentLevel
-            : levels[levels.length - 1] -
-              ((
-                (_a2 = this.electricInput) === null || _a2 === void 0
-                  ? void 0
-                  : _a2.test(textAfter)
-              )
-                ? 1
-                : 0);
-        return (
-          (level || 0) *
-          (((_b = this.config) === null || _b === void 0
-            ? void 0
-            : _b.indentUnit) || 0)
-        );
-      }
-      modeIndent.default = indent$2;
-      var __importDefault$5 =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(modeFactory, "__esModule", { value: true });
-      var graphql_language_service_1$2 = require$$1$1;
-      var mode_indent_1 = __importDefault$5(modeIndent);
-      var graphqlModeFactory = function (config2) {
-        var parser = graphql_language_service_1$2.onlineParser({
-          eatWhitespace: function (stream) {
-            return stream.eatWhile(graphql_language_service_1$2.isIgnored);
-          },
-          lexRules: graphql_language_service_1$2.LexRules,
-          parseRules: graphql_language_service_1$2.ParseRules,
-          editorConfig: { tabSize: config2.tabSize },
-        });
-        return {
-          config: config2,
-          startState: parser.startState,
-          token: parser.token,
-          indent: mode_indent_1.default,
-          electricInput: /^\s*[})\]]/,
-          fold: "brace",
-          lineComment: "#",
-          closeBrackets: {
-            pairs: '()[]{}""',
-            explode: "()[]{}",
-          },
-        };
-      };
-      modeFactory.default = graphqlModeFactory;
-      var __importDefault$4 =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(mode$5, "__esModule", { value: true });
-      var codemirror_1$4 = __importDefault$4(codemirror$2.exports);
-      var mode_factory_1 = __importDefault$4(modeFactory);
-      codemirror_1$4.default.defineMode("graphql", mode_factory_1.default);
-      var mode$4 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: mode$5,
-          },
-          [mode$5]
-        )
-      );
-      var hint$1 = {};
-      var hintList$1 = {};
-      Object.defineProperty(hintList$1, "__esModule", { value: true });
-      function hintList(cursor, token2, list3) {
-        var hints = filterAndSortList(list3, normalizeText(token2.string));
-        if (!hints) {
-          return;
-        }
-        var tokenStart =
-          token2.type !== null && /"|\w/.test(token2.string[0])
-            ? token2.start
-            : token2.end;
-        return {
-          list: hints,
-          from: { line: cursor.line, ch: tokenStart },
-          to: { line: cursor.line, ch: token2.end },
-        };
-      }
-      hintList$1.default = hintList;
-      function filterAndSortList(list3, text3) {
-        if (!text3) {
-          return filterNonEmpty(list3, function (entry) {
-            return !entry.isDeprecated;
-          });
-        }
-        var byProximity = list3.map(function (entry) {
-          return {
-            proximity: getProximity(normalizeText(entry.text), text3),
-            entry,
-          };
-        });
-        var conciseMatches = filterNonEmpty(
-          filterNonEmpty(byProximity, function (pair) {
-            return pair.proximity <= 2;
-          }),
-          function (pair) {
-            return !pair.entry.isDeprecated;
-          }
-        );
-        var sortedMatches = conciseMatches.sort(function (a, b) {
-          return (
-            (a.entry.isDeprecated ? 1 : 0) - (b.entry.isDeprecated ? 1 : 0) ||
-            a.proximity - b.proximity ||
-            a.entry.text.length - b.entry.text.length
-          );
-        });
-        return sortedMatches.map(function (pair) {
-          return pair.entry;
-        });
-      }
-      function filterNonEmpty(array, predicate) {
-        var filtered = array.filter(predicate);
-        return filtered.length === 0 ? array : filtered;
-      }
-      function normalizeText(text3) {
-        return text3.toLowerCase().replace(/\W/g, "");
-      }
-      function getProximity(suggestion, text3) {
-        var proximity = lexicalDistance(text3, suggestion);
-        if (suggestion.length > text3.length) {
-          proximity -= suggestion.length - text3.length - 1;
-          proximity += suggestion.indexOf(text3) === 0 ? 0 : 0.5;
-        }
-        return proximity;
-      }
-      function lexicalDistance(a, b) {
-        var i;
-        var j;
-        var d = [];
-        var aLength = a.length;
-        var bLength = b.length;
-        for (i = 0; i <= aLength; i++) {
-          d[i] = [i];
-        }
-        for (j = 1; j <= bLength; j++) {
-          d[0][j] = j;
-        }
-        for (i = 1; i <= aLength; i++) {
-          for (j = 1; j <= bLength; j++) {
-            var cost = a[i - 1] === b[j - 1] ? 0 : 1;
-            d[i][j] = Math.min(
-              d[i - 1][j] + 1,
-              d[i][j - 1] + 1,
-              d[i - 1][j - 1] + cost
-            );
-            if (
-              i > 1 &&
-              j > 1 &&
-              a[i - 1] === b[j - 2] &&
-              a[i - 2] === b[j - 1]
-            ) {
-              d[i][j] = Math.min(d[i][j], d[i - 2][j - 2] + cost);
-            }
-          }
-        }
-        return d[aLength][bLength];
-      }
-      var __importDefault$3 =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(hint$1, "__esModule", { value: true });
-      var codemirror_1$3 = __importDefault$3(codemirror$2.exports);
-      var graphql_1$1 = require$$1$2;
-      var forEachState_1 = __importDefault$3(forEachState$1);
-      var hintList_1 = __importDefault$3(hintList$1);
-      codemirror_1$3.default.registerHelper(
-        "hint",
-        "graphql-variables",
-        function (editor, options) {
-          var cur = editor.getCursor();
-          var token2 = editor.getTokenAt(cur);
-          var results = getVariablesHint(cur, token2, options);
-          if (results && results.list && results.list.length > 0) {
-            results.from = codemirror_1$3.default.Pos(
-              results.from.line,
-              results.from.ch
-            );
-            results.to = codemirror_1$3.default.Pos(
-              results.to.line,
-              results.to.ch
-            );
-            codemirror_1$3.default.signal(
-              editor,
-              "hasCompletion",
-              editor,
-              results,
-              token2
-            );
-          }
-          return results;
-        }
-      );
-      function getVariablesHint(cur, token2, options) {
-        var state =
-          token2.state.kind === "Invalid"
-            ? token2.state.prevState
-            : token2.state;
-        var kind2 = state.kind;
-        var step = state.step;
-        if (kind2 === "Document" && step === 0) {
-          return hintList_1.default(cur, token2, [{ text: "{" }]);
-        }
-        var variableToType = options.variableToType;
-        if (!variableToType) {
-          return;
-        }
-        var typeInfo = getTypeInfo(variableToType, token2.state);
-        if (kind2 === "Document" || (kind2 === "Variable" && step === 0)) {
-          var variableNames = Object.keys(variableToType);
-          return hintList_1.default(
-            cur,
-            token2,
-            variableNames.map(function (name2) {
-              return {
-                text: '"' + name2 + '": ',
-                type: variableToType[name2],
-              };
-            })
-          );
-        }
-        if (
-          kind2 === "ObjectValue" ||
-          (kind2 === "ObjectField" && step === 0)
-        ) {
-          if (typeInfo.fields) {
-            var inputFields = Object.keys(typeInfo.fields).map(function (
-              fieldName
-            ) {
-              return typeInfo.fields[fieldName];
-            });
-            return hintList_1.default(
-              cur,
-              token2,
-              inputFields.map(function (field) {
-                return {
-                  text: '"' + field.name + '": ',
-                  type: field.type,
-                  description: field.description,
-                };
-              })
-            );
-          }
-        }
-        if (
-          kind2 === "StringValue" ||
-          kind2 === "NumberValue" ||
-          kind2 === "BooleanValue" ||
-          kind2 === "NullValue" ||
-          (kind2 === "ListValue" && step === 1) ||
-          (kind2 === "ObjectField" && step === 2) ||
-          (kind2 === "Variable" && step === 2)
-        ) {
-          var namedInputType_1 = typeInfo.type
-            ? graphql_1$1.getNamedType(typeInfo.type)
-            : void 0;
-          if (namedInputType_1 instanceof graphql_1$1.GraphQLInputObjectType) {
-            return hintList_1.default(cur, token2, [{ text: "{" }]);
-          } else if (namedInputType_1 instanceof graphql_1$1.GraphQLEnumType) {
-            var values = namedInputType_1.getValues();
-            return hintList_1.default(
-              cur,
-              token2,
-              values.map(function (value) {
-                return {
-                  text: '"' + value.name + '"',
-                  type: namedInputType_1,
-                  description: value.description,
-                };
-              })
-            );
-          } else if (namedInputType_1 === graphql_1$1.GraphQLBoolean) {
-            return hintList_1.default(cur, token2, [
-              {
-                text: "true",
-                type: graphql_1$1.GraphQLBoolean,
-                description: "Not false.",
-              },
-              {
-                text: "false",
-                type: graphql_1$1.GraphQLBoolean,
-                description: "Not true.",
-              },
-            ]);
-          }
-        }
-      }
-      function getTypeInfo(variableToType, tokenState) {
-        var info2 = {
-          type: null,
-          fields: null,
-        };
-        forEachState_1.default(tokenState, function (state) {
-          if (state.kind === "Variable") {
-            info2.type = variableToType[state.name];
-          } else if (state.kind === "ListValue") {
-            var nullableType = info2.type
-              ? graphql_1$1.getNullableType(info2.type)
-              : void 0;
-            info2.type =
-              nullableType instanceof graphql_1$1.GraphQLList
-                ? nullableType.ofType
-                : null;
-          } else if (state.kind === "ObjectValue") {
-            var objectType = info2.type
-              ? graphql_1$1.getNamedType(info2.type)
-              : void 0;
-            info2.fields =
-              objectType instanceof graphql_1$1.GraphQLInputObjectType
-                ? objectType.getFields()
-                : null;
-          } else if (state.kind === "ObjectField") {
-            var objectField =
-              state.name && info2.fields ? info2.fields[state.name] : null;
-            info2.type = objectField && objectField.type;
-          }
-        });
-        return info2;
-      }
-      var hint = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: hint$1,
-          },
-          [hint$1]
-        )
-      );
-      var lint$1 = {};
-      var jsonParse$1 = {};
-      Object.defineProperty(jsonParse$1, "__esModule", { value: true });
-      function jsonParse(str) {
-        string = str;
-        strLen = str.length;
-        start = end = lastEnd = -1;
-        ch();
-        lex();
-        var ast2 = parseObj();
-        expect("EOF");
-        return ast2;
-      }
-      jsonParse$1.default = jsonParse;
-      var string;
-      var strLen;
-      var start;
-      var end;
-      var lastEnd;
-      var code2;
-      var kind;
-      function parseObj() {
-        var nodeStart = start;
-        var members = [];
-        expect("{");
-        if (!skip("}")) {
-          do {
-            members.push(parseMember());
-          } while (skip(","));
-          expect("}");
-        }
-        return {
-          kind: "Object",
-          start: nodeStart,
-          end: lastEnd,
-          members,
-        };
-      }
-      function parseMember() {
-        var nodeStart = start;
-        var key = kind === "String" ? curToken() : null;
-        expect("String");
-        expect(":");
-        var value = parseVal();
-        return {
-          kind: "Member",
-          start: nodeStart,
-          end: lastEnd,
-          key,
-          value,
-        };
-      }
-      function parseArr() {
-        var nodeStart = start;
-        var values = [];
-        expect("[");
-        if (!skip("]")) {
-          do {
-            values.push(parseVal());
-          } while (skip(","));
-          expect("]");
-        }
-        return {
-          kind: "Array",
-          start: nodeStart,
-          end: lastEnd,
-          values,
-        };
-      }
-      function parseVal() {
-        switch (kind) {
-          case "[":
-            return parseArr();
-          case "{":
-            return parseObj();
-          case "String":
-          case "Number":
-          case "Boolean":
-          case "Null":
-            var token2 = curToken();
-            lex();
-            return token2;
-        }
-        expect("Value");
-      }
-      function curToken() {
-        return {
-          kind,
-          start,
-          end,
-          value: JSON.parse(string.slice(start, end)),
-        };
-      }
-      function expect(str) {
-        if (kind === str) {
-          lex();
-          return;
-        }
-        var found;
-        if (kind === "EOF") {
-          found = "[end of file]";
-        } else if (end - start > 1) {
-          found = "`" + string.slice(start, end) + "`";
-        } else {
-          var match2 = string.slice(start).match(/^.+?\b/);
-          found = "`" + (match2 ? match2[0] : string[start]) + "`";
-        }
-        throw syntaxError("Expected " + str + " but found " + found + ".");
-      }
-      function syntaxError(message) {
-        return { message, start, end };
-      }
-      function skip(k) {
-        if (kind === k) {
-          lex();
-          return true;
-        }
-      }
-      function ch() {
-        if (end < strLen) {
-          end++;
-          code2 = end === strLen ? 0 : string.charCodeAt(end);
-        }
-        return code2;
-      }
-      function lex() {
-        lastEnd = end;
-        while (code2 === 9 || code2 === 10 || code2 === 13 || code2 === 32) {
-          ch();
-        }
-        if (code2 === 0) {
-          kind = "EOF";
-          return;
-        }
-        start = end;
-        switch (code2) {
-          case 34:
-            kind = "String";
-            return readString();
-          case 45:
-          case 48:
-          case 49:
-          case 50:
-          case 51:
-          case 52:
-          case 53:
-          case 54:
-          case 55:
-          case 56:
-          case 57:
-            kind = "Number";
-            return readNumber();
-          case 102:
-            if (string.slice(start, start + 5) !== "false") {
-              break;
-            }
-            end += 4;
-            ch();
-            kind = "Boolean";
-            return;
-          case 110:
-            if (string.slice(start, start + 4) !== "null") {
-              break;
-            }
-            end += 3;
-            ch();
-            kind = "Null";
-            return;
-          case 116:
-            if (string.slice(start, start + 4) !== "true") {
-              break;
-            }
-            end += 3;
-            ch();
-            kind = "Boolean";
-            return;
-        }
-        kind = string[start];
-        ch();
-      }
-      function readString() {
-        ch();
-        while (code2 !== 34 && code2 > 31) {
-          if (code2 === 92) {
-            code2 = ch();
-            switch (code2) {
-              case 34:
-              case 47:
-              case 92:
-              case 98:
-              case 102:
-              case 110:
-              case 114:
-              case 116:
-                ch();
-                break;
-              case 117:
-                ch();
-                readHex();
-                readHex();
-                readHex();
-                readHex();
-                break;
-              default:
-                throw syntaxError("Bad character escape sequence.");
-            }
-          } else if (end === strLen) {
-            throw syntaxError("Unterminated string.");
-          } else {
-            ch();
-          }
-        }
-        if (code2 === 34) {
-          ch();
-          return;
-        }
-        throw syntaxError("Unterminated string.");
-      }
-      function readHex() {
-        if (
-          (code2 >= 48 && code2 <= 57) ||
-          (code2 >= 65 && code2 <= 70) ||
-          (code2 >= 97 && code2 <= 102)
-        ) {
-          return ch();
-        }
-        throw syntaxError("Expected hexadecimal digit.");
-      }
-      function readNumber() {
-        if (code2 === 45) {
-          ch();
-        }
-        if (code2 === 48) {
-          ch();
-        } else {
-          readDigits();
-        }
-        if (code2 === 46) {
-          ch();
-          readDigits();
-        }
-        if (code2 === 69 || code2 === 101) {
-          code2 = ch();
-          if (code2 === 43 || code2 === 45) {
-            ch();
-          }
-          readDigits();
-        }
-      }
-      function readDigits() {
-        if (code2 < 48 || code2 > 57) {
-          throw syntaxError("Expected decimal digit.");
-        }
-        do {
-          ch();
-        } while (code2 >= 48 && code2 <= 57);
-      }
-      var __read =
-        (commonjsGlobal && commonjsGlobal.__read) ||
-        function (o, n2) {
-          var m = typeof Symbol === "function" && o[Symbol.iterator];
-          if (!m) return o;
-          var i = m.call(o),
-            r2,
-            ar = [],
-            e;
-          try {
-            while ((n2 === void 0 || n2-- > 0) && !(r2 = i.next()).done)
-              ar.push(r2.value);
-          } catch (error2) {
-            e = { error: error2 };
-          } finally {
-            try {
-              if (r2 && !r2.done && (m = i["return"])) m.call(i);
-            } finally {
-              if (e) throw e.error;
-            }
-          }
-          return ar;
-        };
-      var __importDefault$2 =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(lint$1, "__esModule", { value: true });
-      var codemirror_1$2 = __importDefault$2(codemirror$2.exports);
-      var graphql_1 = require$$1$2;
-      var jsonParse_1 = __importDefault$2(jsonParse$1);
-      codemirror_1$2.default.registerHelper(
-        "lint",
-        "graphql-variables",
-        function (text3, options, editor) {
-          if (!text3) {
-            return [];
-          }
-          var ast2;
-          try {
-            ast2 = jsonParse_1.default(text3);
-          } catch (syntaxError2) {
-            if (syntaxError2.stack) {
-              throw syntaxError2;
-            }
-            return [lintError(editor, syntaxError2, syntaxError2.message)];
-          }
-          var variableToType = options.variableToType;
-          if (!variableToType) {
-            return [];
-          }
-          return validateVariables(editor, variableToType, ast2);
-        }
-      );
-      function validateVariables(editor, variableToType, variablesAST) {
-        var errors2 = [];
-        variablesAST.members.forEach(function (member) {
-          var _a2;
-          if (member) {
-            var variableName =
-              (_a2 = member.key) === null || _a2 === void 0
-                ? void 0
-                : _a2.value;
-            var type2 = variableToType[variableName];
-            if (!type2) {
-              errors2.push(
-                lintError(
-                  editor,
-                  member.key,
-                  'Variable "$' +
-                    variableName +
-                    '" does not appear in any GraphQL query.'
-                )
-              );
-            } else {
-              validateValue(type2, member.value).forEach(function (_a3) {
-                var _b = __read(_a3, 2),
-                  node = _b[0],
-                  message = _b[1];
-                errors2.push(lintError(editor, node, message));
-              });
-            }
-          }
-        });
-        return errors2;
-      }
-      function validateValue(type2, valueAST) {
-        if (!type2 || !valueAST) {
-          return [];
-        }
-        if (type2 instanceof graphql_1.GraphQLNonNull) {
-          if (valueAST.kind === "Null") {
-            return [
-              [
-                valueAST,
-                'Type "' + type2 + '" is non-nullable and cannot be null.',
-              ],
-            ];
-          }
-          return validateValue(type2.ofType, valueAST);
-        }
-        if (valueAST.kind === "Null") {
-          return [];
-        }
-        if (type2 instanceof graphql_1.GraphQLList) {
-          var itemType_1 = type2.ofType;
-          if (valueAST.kind === "Array") {
-            var values = valueAST.values || [];
-            return mapCat(values, function (item) {
-              return validateValue(itemType_1, item);
-            });
-          }
-          return validateValue(itemType_1, valueAST);
-        }
-        if (type2 instanceof graphql_1.GraphQLInputObjectType) {
-          if (valueAST.kind !== "Object") {
-            return [[valueAST, 'Type "' + type2 + '" must be an Object.']];
-          }
-          var providedFields_1 = /* @__PURE__ */ Object.create(null);
-          var fieldErrors_1 = mapCat(valueAST.members, function (member) {
-            var _a2;
-            var fieldName =
-              (_a2 =
-                member === null || member === void 0 ? void 0 : member.key) ===
-                null || _a2 === void 0
-                ? void 0
-                : _a2.value;
-            providedFields_1[fieldName] = true;
-            var inputField = type2.getFields()[fieldName];
-            if (!inputField) {
-              return [
-                [
-                  member.key,
-                  'Type "' +
-                    type2 +
-                    '" does not have a field "' +
-                    fieldName +
-                    '".',
-                ],
-              ];
-            }
-            var fieldType = inputField ? inputField.type : void 0;
-            return validateValue(fieldType, member.value);
-          });
-          Object.keys(type2.getFields()).forEach(function (fieldName) {
-            if (!providedFields_1[fieldName]) {
-              var fieldType = type2.getFields()[fieldName].type;
-              if (fieldType instanceof graphql_1.GraphQLNonNull) {
-                fieldErrors_1.push([
-                  valueAST,
-                  'Object of type "' +
-                    type2 +
-                    '" is missing required field "' +
-                    fieldName +
-                    '".',
-                ]);
-              }
-            }
-          });
-          return fieldErrors_1;
-        }
-        if (
-          (type2.name === "Boolean" && valueAST.kind !== "Boolean") ||
-          (type2.name === "String" && valueAST.kind !== "String") ||
-          (type2.name === "ID" &&
-            valueAST.kind !== "Number" &&
-            valueAST.kind !== "String") ||
-          (type2.name === "Float" && valueAST.kind !== "Number") ||
-          (type2.name === "Int" &&
-            (valueAST.kind !== "Number" ||
-              (valueAST.value | 0) !== valueAST.value))
-        ) {
-          return [[valueAST, 'Expected value of type "' + type2 + '".']];
-        }
-        if (
-          type2 instanceof graphql_1.GraphQLEnumType ||
-          type2 instanceof graphql_1.GraphQLScalarType
-        ) {
-          if (
-            (valueAST.kind !== "String" &&
-              valueAST.kind !== "Number" &&
-              valueAST.kind !== "Boolean" &&
-              valueAST.kind !== "Null") ||
-            isNullish(type2.parseValue(valueAST.value))
-          ) {
-            return [[valueAST, 'Expected value of type "' + type2 + '".']];
-          }
-        }
-        return [];
-      }
-      function lintError(editor, node, message) {
-        return {
-          message,
-          severity: "error",
-          type: "validation",
-          from: editor.posFromIndex(node.start),
-          to: editor.posFromIndex(node.end),
-        };
-      }
-      function isNullish(value) {
-        return value === null || value === void 0 || value !== value;
-      }
-      function mapCat(array, mapper) {
-        return Array.prototype.concat.apply([], array.map(mapper));
-      }
-      var lint = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: lint$1,
-          },
-          [lint$1]
-        )
-      );
-      var mode$3 = {};
-      var __importDefault$1 =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(mode$3, "__esModule", { value: true });
-      var codemirror_1$1 = __importDefault$1(codemirror$2.exports);
-      var graphql_language_service_1$1 = require$$1$1;
-      codemirror_1$1.default.defineMode(
-        "graphql-variables",
-        function (config2) {
-          var parser = graphql_language_service_1$1.onlineParser({
-            eatWhitespace: function (stream) {
-              return stream.eatSpace();
-            },
-            lexRules: LexRules$1,
-            parseRules: ParseRules$1,
-            editorConfig: { tabSize: config2.tabSize },
-          });
-          return {
-            config: config2,
-            startState: parser.startState,
-            token: parser.token,
-            indent: indent$1,
-            electricInput: /^\s*[}\]]/,
-            fold: "brace",
-            closeBrackets: {
-              pairs: '[]{}""',
-              explode: "[]{}",
-            },
-          };
-        }
-      );
-      function indent$1(state, textAfter) {
-        var _a2, _b;
-        var levels = state.levels;
-        var level =
-          !levels || levels.length === 0
-            ? state.indentLevel
-            : levels[levels.length - 1] -
-              ((
-                (_a2 = this.electricInput) === null || _a2 === void 0
-                  ? void 0
-                  : _a2.test(textAfter)
-              )
-                ? 1
-                : 0);
-        return (
-          (level || 0) *
-          (((_b = this.config) === null || _b === void 0
-            ? void 0
-            : _b.indentUnit) || 0)
-        );
-      }
-      var LexRules$1 = {
-        Punctuation: /^\[|]|\{|\}|:|,/,
-        Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,
-        String: /^"(?:[^"\\]|\\(?:"|\/|\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*"?/,
-        Keyword: /^true|false|null/,
-      };
-      var ParseRules$1 = {
-        Document: [
-          graphql_language_service_1$1.p("{"),
-          graphql_language_service_1$1.list(
-            "Variable",
-            graphql_language_service_1$1.opt(
-              graphql_language_service_1$1.p(",")
-            )
-          ),
-          graphql_language_service_1$1.p("}"),
-        ],
-        Variable: [
-          namedKey("variable"),
-          graphql_language_service_1$1.p(":"),
-          "Value",
-        ],
-        Value: function (token2) {
-          switch (token2.kind) {
-            case "Number":
-              return "NumberValue";
-            case "String":
-              return "StringValue";
-            case "Punctuation":
-              switch (token2.value) {
-                case "[":
-                  return "ListValue";
-                case "{":
-                  return "ObjectValue";
-              }
-              return null;
-            case "Keyword":
-              switch (token2.value) {
-                case "true":
-                case "false":
-                  return "BooleanValue";
-                case "null":
-                  return "NullValue";
-              }
-              return null;
-          }
-        },
-        NumberValue: [graphql_language_service_1$1.t("Number", "number")],
-        StringValue: [graphql_language_service_1$1.t("String", "string")],
-        BooleanValue: [graphql_language_service_1$1.t("Keyword", "builtin")],
-        NullValue: [graphql_language_service_1$1.t("Keyword", "keyword")],
-        ListValue: [
-          graphql_language_service_1$1.p("["),
-          graphql_language_service_1$1.list(
-            "Value",
-            graphql_language_service_1$1.opt(
-              graphql_language_service_1$1.p(",")
-            )
-          ),
-          graphql_language_service_1$1.p("]"),
-        ],
-        ObjectValue: [
-          graphql_language_service_1$1.p("{"),
-          graphql_language_service_1$1.list(
-            "ObjectField",
-            graphql_language_service_1$1.opt(
-              graphql_language_service_1$1.p(",")
-            )
-          ),
-          graphql_language_service_1$1.p("}"),
-        ],
-        ObjectField: [
-          namedKey("attribute"),
-          graphql_language_service_1$1.p(":"),
-          "Value",
-        ],
-      };
-      function namedKey(style) {
-        return {
-          style,
-          match: function (token2) {
-            return token2.kind === "String";
-          },
-          update: function (state, token2) {
-            state.name = token2.value.slice(1, -1);
-          },
-        };
-      }
-      var mode$2 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: mode$3,
-          },
-          [mode$3]
-        )
-      );
-      var javascript$2 = { exports: {} };
-      (function (module2, exports) {
-        (function (mod) {
-          mod(codemirror$2.exports);
-        })(function (CodeMirror) {
-          CodeMirror.defineMode("javascript", function (config2, parserConfig) {
-            var indentUnit = config2.indentUnit;
-            var statementIndent = parserConfig.statementIndent;
-            var jsonldMode = parserConfig.jsonld;
-            var jsonMode = parserConfig.json || jsonldMode;
-            var trackScope = parserConfig.trackScope !== false;
-            var isTS = parserConfig.typescript;
-            var wordRE = parserConfig.wordCharacters || /[\w$\xa1-\uffff]/;
-            var keywords = (function () {
-              function kw(type3) {
-                return { type: type3, style: "keyword" };
-              }
-              var A2 = kw("keyword a"),
-                B2 = kw("keyword b"),
-                C2 = kw("keyword c"),
-                D2 = kw("keyword d");
-              var operator = kw("operator"),
-                atom = { type: "atom", style: "atom" };
-              return {
-                if: kw("if"),
-                while: A2,
-                with: A2,
-                else: B2,
-                do: B2,
-                try: B2,
-                finally: B2,
-                return: D2,
-                break: D2,
-                continue: D2,
-                new: kw("new"),
-                delete: C2,
-                void: C2,
-                throw: C2,
-                debugger: kw("debugger"),
-                var: kw("var"),
-                const: kw("var"),
-                let: kw("var"),
-                function: kw("function"),
-                catch: kw("catch"),
-                for: kw("for"),
-                switch: kw("switch"),
-                case: kw("case"),
-                default: kw("default"),
-                in: operator,
-                typeof: operator,
-                instanceof: operator,
-                true: atom,
-                false: atom,
-                null: atom,
-                undefined: atom,
-                NaN: atom,
-                Infinity: atom,
-                this: kw("this"),
-                class: kw("class"),
-                super: kw("atom"),
-                yield: C2,
-                export: kw("export"),
-                import: kw("import"),
-                extends: C2,
-                await: C2,
-              };
-            })();
-            var isOperatorChar = /[+\-*&%=<>!?|~^@]/;
-            var isJsonldKeyword =
-              /^@(context|id|value|language|type|container|list|set|reverse|index|base|vocab|graph)"/;
-            function readRegexp(stream) {
-              var escaped = false,
-                next,
-                inSet = false;
-              while ((next = stream.next()) != null) {
-                if (!escaped) {
-                  if (next == "/" && !inSet) return;
-                  if (next == "[") inSet = true;
-                  else if (inSet && next == "]") inSet = false;
-                }
-                escaped = !escaped && next == "\\";
-              }
-            }
-            var type2, content;
-            function ret(tp, style, cont2) {
-              type2 = tp;
-              content = cont2;
-              return style;
-            }
-            function tokenBase(stream, state) {
-              var ch2 = stream.next();
-              if (ch2 == '"' || ch2 == "'") {
-                state.tokenize = tokenString(ch2);
-                return state.tokenize(stream, state);
-              } else if (
-                ch2 == "." &&
-                stream.match(/^\d[\d_]*(?:[eE][+\-]?[\d_]+)?/)
-              ) {
-                return ret("number", "number");
-              } else if (ch2 == "." && stream.match("..")) {
-                return ret("spread", "meta");
-              } else if (/[\[\]{}\(\),;\:\.]/.test(ch2)) {
-                return ret(ch2);
-              } else if (ch2 == "=" && stream.eat(">")) {
-                return ret("=>", "operator");
-              } else if (
-                ch2 == "0" &&
-                stream.match(/^(?:x[\dA-Fa-f_]+|o[0-7_]+|b[01_]+)n?/)
-              ) {
-                return ret("number", "number");
-              } else if (/\d/.test(ch2)) {
-                stream.match(
-                  /^[\d_]*(?:n|(?:\.[\d_]*)?(?:[eE][+\-]?[\d_]+)?)?/
-                );
-                return ret("number", "number");
-              } else if (ch2 == "/") {
-                if (stream.eat("*")) {
-                  state.tokenize = tokenComment;
-                  return tokenComment(stream, state);
-                } else if (stream.eat("/")) {
-                  stream.skipToEnd();
-                  return ret("comment", "comment");
-                } else if (expressionAllowed(stream, state, 1)) {
-                  readRegexp(stream);
-                  stream.match(/^\b(([gimyus])(?![gimyus]*\2))+\b/);
-                  return ret("regexp", "string-2");
-                } else {
-                  stream.eat("=");
-                  return ret("operator", "operator", stream.current());
-                }
-              } else if (ch2 == "`") {
-                state.tokenize = tokenQuasi;
-                return tokenQuasi(stream, state);
-              } else if (ch2 == "#" && stream.peek() == "!") {
-                stream.skipToEnd();
-                return ret("meta", "meta");
-              } else if (ch2 == "#" && stream.eatWhile(wordRE)) {
-                return ret("variable", "property");
-              } else if (
-                (ch2 == "<" && stream.match("!--")) ||
-                (ch2 == "-" &&
-                  stream.match("->") &&
-                  !/\S/.test(stream.string.slice(0, stream.start)))
-              ) {
-                stream.skipToEnd();
-                return ret("comment", "comment");
-              } else if (isOperatorChar.test(ch2)) {
-                if (ch2 != ">" || !state.lexical || state.lexical.type != ">") {
-                  if (stream.eat("=")) {
-                    if (ch2 == "!" || ch2 == "=") stream.eat("=");
-                  } else if (/[<>*+\-|&?]/.test(ch2)) {
-                    stream.eat(ch2);
-                    if (ch2 == ">") stream.eat(ch2);
-                  }
-                }
-                if (ch2 == "?" && stream.eat(".")) return ret(".");
-                return ret("operator", "operator", stream.current());
-              } else if (wordRE.test(ch2)) {
-                stream.eatWhile(wordRE);
-                var word2 = stream.current();
-                if (state.lastType != ".") {
-                  if (keywords.propertyIsEnumerable(word2)) {
-                    var kw = keywords[word2];
-                    return ret(kw.type, kw.style, word2);
-                  }
-                  if (
-                    word2 == "async" &&
-                    stream.match(
-                      /^(\s|\/\*([^*]|\*(?!\/))*?\*\/)*[\[\(\w]/,
-                      false
-                    )
-                  )
-                    return ret("async", "keyword", word2);
-                }
-                return ret("variable", "variable", word2);
-              }
-            }
-            function tokenString(quote) {
-              return function (stream, state) {
-                var escaped = false,
-                  next;
-                if (
-                  jsonldMode &&
-                  stream.peek() == "@" &&
-                  stream.match(isJsonldKeyword)
-                ) {
-                  state.tokenize = tokenBase;
-                  return ret("jsonld-keyword", "meta");
-                }
-                while ((next = stream.next()) != null) {
-                  if (next == quote && !escaped) break;
-                  escaped = !escaped && next == "\\";
-                }
-                if (!escaped) state.tokenize = tokenBase;
-                return ret("string", "string");
-              };
-            }
-            function tokenComment(stream, state) {
-              var maybeEnd = false,
-                ch2;
-              while ((ch2 = stream.next())) {
-                if (ch2 == "/" && maybeEnd) {
-                  state.tokenize = tokenBase;
-                  break;
-                }
-                maybeEnd = ch2 == "*";
-              }
-              return ret("comment", "comment");
-            }
-            function tokenQuasi(stream, state) {
-              var escaped = false,
-                next;
-              while ((next = stream.next()) != null) {
-                if (
-                  !escaped &&
-                  (next == "`" || (next == "$" && stream.eat("{")))
-                ) {
-                  state.tokenize = tokenBase;
-                  break;
-                }
-                escaped = !escaped && next == "\\";
-              }
-              return ret("quasi", "string-2", stream.current());
-            }
-            var brackets = "([{}])";
-            function findFatArrow(stream, state) {
-              if (state.fatArrowAt) state.fatArrowAt = null;
-              var arrow = stream.string.indexOf("=>", stream.start);
-              if (arrow < 0) return;
-              if (isTS) {
-                var m = /:\s*(?:\w+(?:<[^>]*>|\[\])?|\{[^}]*\})\s*$/.exec(
-                  stream.string.slice(stream.start, arrow)
-                );
-                if (m) arrow = m.index;
-              }
-              var depth = 0,
-                sawSomething = false;
-              for (var pos = arrow - 1; pos >= 0; --pos) {
-                var ch2 = stream.string.charAt(pos);
-                var bracket = brackets.indexOf(ch2);
-                if (bracket >= 0 && bracket < 3) {
-                  if (!depth) {
-                    ++pos;
-                    break;
-                  }
-                  if (--depth == 0) {
-                    if (ch2 == "(") sawSomething = true;
-                    break;
-                  }
-                } else if (bracket >= 3 && bracket < 6) {
-                  ++depth;
-                } else if (wordRE.test(ch2)) {
-                  sawSomething = true;
-                } else if (/["'\/`]/.test(ch2)) {
-                  for (; ; --pos) {
-                    if (pos == 0) return;
-                    var next = stream.string.charAt(pos - 1);
-                    if (next == ch2 && stream.string.charAt(pos - 2) != "\\") {
-                      pos--;
-                      break;
-                    }
-                  }
-                } else if (sawSomething && !depth) {
-                  ++pos;
-                  break;
-                }
-              }
-              if (sawSomething && !depth) state.fatArrowAt = pos;
-            }
-            var atomicTypes = {
-              atom: true,
-              number: true,
-              variable: true,
-              string: true,
-              regexp: true,
-              this: true,
-              import: true,
-              "jsonld-keyword": true,
-            };
-            function JSLexical(indented, column, type3, align, prev, info2) {
-              this.indented = indented;
-              this.column = column;
-              this.type = type3;
-              this.prev = prev;
-              this.info = info2;
-              if (align != null) this.align = align;
-            }
-            function inScope(state, varname) {
-              if (!trackScope) return false;
-              for (var v2 = state.localVars; v2; v2 = v2.next)
-                if (v2.name == varname) return true;
-              for (var cx2 = state.context; cx2; cx2 = cx2.prev) {
-                for (var v2 = cx2.vars; v2; v2 = v2.next)
-                  if (v2.name == varname) return true;
-              }
-            }
-            function parseJS(state, style, type3, content2, stream) {
-              var cc2 = state.cc;
-              cx.state = state;
-              cx.stream = stream;
-              (cx.marked = null), (cx.cc = cc2);
-              cx.style = style;
-              if (!state.lexical.hasOwnProperty("align"))
-                state.lexical.align = true;
-              while (true) {
-                var combinator = cc2.length
-                  ? cc2.pop()
-                  : jsonMode
-                  ? expression
-                  : statement;
-                if (combinator(type3, content2)) {
-                  while (cc2.length && cc2[cc2.length - 1].lex) cc2.pop()();
-                  if (cx.marked) return cx.marked;
-                  if (type3 == "variable" && inScope(state, content2))
-                    return "variable-2";
-                  return style;
-                }
-              }
-            }
-            var cx = { state: null, column: null, marked: null, cc: null };
-            function pass() {
-              for (var i = arguments.length - 1; i >= 0; i--)
-                cx.cc.push(arguments[i]);
-            }
-            function cont() {
-              pass.apply(null, arguments);
-              return true;
-            }
-            function inList(name2, list3) {
-              for (var v2 = list3; v2; v2 = v2.next)
-                if (v2.name == name2) return true;
-              return false;
-            }
-            function register(varname) {
-              var state = cx.state;
-              cx.marked = "def";
-              if (!trackScope) return;
-              if (state.context) {
-                if (
-                  state.lexical.info == "var" &&
-                  state.context &&
-                  state.context.block
-                ) {
-                  var newContext = registerVarScoped(varname, state.context);
-                  if (newContext != null) {
-                    state.context = newContext;
-                    return;
-                  }
-                } else if (!inList(varname, state.localVars)) {
-                  state.localVars = new Var(varname, state.localVars);
-                  return;
-                }
-              }
-              if (parserConfig.globalVars && !inList(varname, state.globalVars))
-                state.globalVars = new Var(varname, state.globalVars);
-            }
-            function registerVarScoped(varname, context) {
-              if (!context) {
-                return null;
-              } else if (context.block) {
-                var inner = registerVarScoped(varname, context.prev);
-                if (!inner) return null;
-                if (inner == context.prev) return context;
-                return new Context(inner, context.vars, true);
-              } else if (inList(varname, context.vars)) {
-                return context;
-              } else {
-                return new Context(
-                  context.prev,
-                  new Var(varname, context.vars),
-                  false
-                );
-              }
-            }
-            function isModifier(name2) {
-              return (
-                name2 == "public" ||
-                name2 == "private" ||
-                name2 == "protected" ||
-                name2 == "abstract" ||
-                name2 == "readonly"
-              );
-            }
-            function Context(prev, vars, block4) {
-              this.prev = prev;
-              this.vars = vars;
-              this.block = block4;
-            }
-            function Var(name2, next) {
-              this.name = name2;
-              this.next = next;
-            }
-            var defaultVars = new Var("this", new Var("arguments", null));
-            function pushcontext() {
-              cx.state.context = new Context(
-                cx.state.context,
-                cx.state.localVars,
-                false
-              );
-              cx.state.localVars = defaultVars;
-            }
-            function pushblockcontext() {
-              cx.state.context = new Context(
-                cx.state.context,
-                cx.state.localVars,
-                true
-              );
-              cx.state.localVars = null;
-            }
-            pushcontext.lex = pushblockcontext.lex = true;
-            function popcontext() {
-              cx.state.localVars = cx.state.context.vars;
-              cx.state.context = cx.state.context.prev;
-            }
-            popcontext.lex = true;
-            function pushlex(type3, info2) {
-              var result2 = function () {
-                var state = cx.state,
-                  indent2 = state.indented;
-                if (state.lexical.type == "stat")
-                  indent2 = state.lexical.indented;
-                else
-                  for (
-                    var outer = state.lexical;
-                    outer && outer.type == ")" && outer.align;
-                    outer = outer.prev
-                  )
-                    indent2 = outer.indented;
-                state.lexical = new JSLexical(
-                  indent2,
-                  cx.stream.column(),
-                  type3,
-                  null,
-                  state.lexical,
-                  info2
-                );
-              };
-              result2.lex = true;
-              return result2;
-            }
-            function poplex() {
-              var state = cx.state;
-              if (state.lexical.prev) {
-                if (state.lexical.type == ")")
-                  state.indented = state.lexical.indented;
-                state.lexical = state.lexical.prev;
-              }
-            }
-            poplex.lex = true;
-            function expect2(wanted) {
-              function exp(type3) {
-                if (type3 == wanted) return cont();
-                else if (
-                  wanted == ";" ||
-                  type3 == "}" ||
-                  type3 == ")" ||
-                  type3 == "]"
-                )
-                  return pass();
-                else return cont(exp);
-              }
-              return exp;
-            }
-            function statement(type3, value) {
-              if (type3 == "var")
-                return cont(
-                  pushlex("vardef", value),
-                  vardef,
-                  expect2(";"),
-                  poplex
-                );
-              if (type3 == "keyword a")
-                return cont(pushlex("form"), parenExpr, statement, poplex);
-              if (type3 == "keyword b")
-                return cont(pushlex("form"), statement, poplex);
-              if (type3 == "keyword d")
-                return cx.stream.match(/^\s*$/, false)
-                  ? cont()
-                  : cont(
-                      pushlex("stat"),
-                      maybeexpression,
-                      expect2(";"),
-                      poplex
-                    );
-              if (type3 == "debugger") return cont(expect2(";"));
-              if (type3 == "{")
-                return cont(
-                  pushlex("}"),
-                  pushblockcontext,
-                  block3,
-                  poplex,
-                  popcontext
-                );
-              if (type3 == ";") return cont();
-              if (type3 == "if") {
-                if (
-                  cx.state.lexical.info == "else" &&
-                  cx.state.cc[cx.state.cc.length - 1] == poplex
-                )
-                  cx.state.cc.pop()();
-                return cont(
-                  pushlex("form"),
-                  parenExpr,
-                  statement,
-                  poplex,
-                  maybeelse
-                );
-              }
-              if (type3 == "function") return cont(functiondef);
-              if (type3 == "for")
-                return cont(
-                  pushlex("form"),
-                  pushblockcontext,
-                  forspec,
-                  statement,
-                  popcontext,
-                  poplex
-                );
-              if (type3 == "class" || (isTS && value == "interface")) {
-                cx.marked = "keyword";
-                return cont(
-                  pushlex("form", type3 == "class" ? type3 : value),
-                  className,
-                  poplex
-                );
-              }
-              if (type3 == "variable") {
-                if (isTS && value == "declare") {
-                  cx.marked = "keyword";
-                  return cont(statement);
-                } else if (
-                  isTS &&
-                  (value == "module" || value == "enum" || value == "type") &&
-                  cx.stream.match(/^\s*\w/, false)
-                ) {
-                  cx.marked = "keyword";
-                  if (value == "enum") return cont(enumdef);
-                  else if (value == "type")
-                    return cont(
-                      typename,
-                      expect2("operator"),
-                      typeexpr,
-                      expect2(";")
-                    );
-                  else
-                    return cont(
-                      pushlex("form"),
-                      pattern,
-                      expect2("{"),
-                      pushlex("}"),
-                      block3,
-                      poplex,
-                      poplex
-                    );
-                } else if (isTS && value == "namespace") {
-                  cx.marked = "keyword";
-                  return cont(pushlex("form"), expression, statement, poplex);
-                } else if (isTS && value == "abstract") {
-                  cx.marked = "keyword";
-                  return cont(statement);
-                } else {
-                  return cont(pushlex("stat"), maybelabel);
-                }
-              }
-              if (type3 == "switch")
-                return cont(
-                  pushlex("form"),
-                  parenExpr,
-                  expect2("{"),
-                  pushlex("}", "switch"),
-                  pushblockcontext,
-                  block3,
-                  poplex,
-                  poplex,
-                  popcontext
-                );
-              if (type3 == "case") return cont(expression, expect2(":"));
-              if (type3 == "default") return cont(expect2(":"));
-              if (type3 == "catch")
-                return cont(
-                  pushlex("form"),
-                  pushcontext,
-                  maybeCatchBinding,
-                  statement,
-                  poplex,
-                  popcontext
-                );
-              if (type3 == "export")
-                return cont(pushlex("stat"), afterExport, poplex);
-              if (type3 == "import")
-                return cont(pushlex("stat"), afterImport, poplex);
-              if (type3 == "async") return cont(statement);
-              if (value == "@") return cont(expression, statement);
-              return pass(pushlex("stat"), expression, expect2(";"), poplex);
-            }
-            function maybeCatchBinding(type3) {
-              if (type3 == "(") return cont(funarg, expect2(")"));
-            }
-            function expression(type3, value) {
-              return expressionInner(type3, value, false);
-            }
-            function expressionNoComma(type3, value) {
-              return expressionInner(type3, value, true);
-            }
-            function parenExpr(type3) {
-              if (type3 != "(") return pass();
-              return cont(pushlex(")"), maybeexpression, expect2(")"), poplex);
-            }
-            function expressionInner(type3, value, noComma) {
-              if (cx.state.fatArrowAt == cx.stream.start) {
-                var body = noComma ? arrowBodyNoComma : arrowBody;
-                if (type3 == "(")
-                  return cont(
-                    pushcontext,
-                    pushlex(")"),
-                    commasep(funarg, ")"),
-                    poplex,
-                    expect2("=>"),
-                    body,
-                    popcontext
-                  );
-                else if (type3 == "variable")
-                  return pass(
-                    pushcontext,
-                    pattern,
-                    expect2("=>"),
-                    body,
-                    popcontext
-                  );
-              }
-              var maybeop = noComma ? maybeoperatorNoComma : maybeoperatorComma;
-              if (atomicTypes.hasOwnProperty(type3)) return cont(maybeop);
-              if (type3 == "function") return cont(functiondef, maybeop);
-              if (type3 == "class" || (isTS && value == "interface")) {
-                cx.marked = "keyword";
-                return cont(pushlex("form"), classExpression, poplex);
-              }
-              if (type3 == "keyword c" || type3 == "async")
-                return cont(noComma ? expressionNoComma : expression);
-              if (type3 == "(")
-                return cont(
-                  pushlex(")"),
-                  maybeexpression,
-                  expect2(")"),
-                  poplex,
-                  maybeop
-                );
-              if (type3 == "operator" || type3 == "spread")
-                return cont(noComma ? expressionNoComma : expression);
-              if (type3 == "[")
-                return cont(pushlex("]"), arrayLiteral, poplex, maybeop);
-              if (type3 == "{")
-                return contCommasep(objprop, "}", null, maybeop);
-              if (type3 == "quasi") return pass(quasi, maybeop);
-              if (type3 == "new") return cont(maybeTarget(noComma));
-              return cont();
-            }
-            function maybeexpression(type3) {
-              if (type3.match(/[;\}\)\],]/)) return pass();
-              return pass(expression);
-            }
-            function maybeoperatorComma(type3, value) {
-              if (type3 == ",") return cont(maybeexpression);
-              return maybeoperatorNoComma(type3, value, false);
-            }
-            function maybeoperatorNoComma(type3, value, noComma) {
-              var me2 =
-                noComma == false ? maybeoperatorComma : maybeoperatorNoComma;
-              var expr = noComma == false ? expression : expressionNoComma;
-              if (type3 == "=>")
-                return cont(
-                  pushcontext,
-                  noComma ? arrowBodyNoComma : arrowBody,
-                  popcontext
-                );
-              if (type3 == "operator") {
-                if (/\+\+|--/.test(value) || (isTS && value == "!"))
-                  return cont(me2);
-                if (
-                  isTS &&
-                  value == "<" &&
-                  cx.stream.match(/^([^<>]|<[^<>]*>)*>\s*\(/, false)
-                )
-                  return cont(
-                    pushlex(">"),
-                    commasep(typeexpr, ">"),
-                    poplex,
-                    me2
-                  );
-                if (value == "?") return cont(expression, expect2(":"), expr);
-                return cont(expr);
-              }
-              if (type3 == "quasi") {
-                return pass(quasi, me2);
-              }
-              if (type3 == ";") return;
-              if (type3 == "(")
-                return contCommasep(expressionNoComma, ")", "call", me2);
-              if (type3 == ".") return cont(property, me2);
-              if (type3 == "[")
-                return cont(
-                  pushlex("]"),
-                  maybeexpression,
-                  expect2("]"),
-                  poplex,
-                  me2
-                );
-              if (isTS && value == "as") {
-                cx.marked = "keyword";
-                return cont(typeexpr, me2);
-              }
-              if (type3 == "regexp") {
-                cx.state.lastType = cx.marked = "operator";
-                cx.stream.backUp(cx.stream.pos - cx.stream.start - 1);
-                return cont(expr);
-              }
-            }
-            function quasi(type3, value) {
-              if (type3 != "quasi") return pass();
-              if (value.slice(value.length - 2) != "${") return cont(quasi);
-              return cont(maybeexpression, continueQuasi);
-            }
-            function continueQuasi(type3) {
-              if (type3 == "}") {
-                cx.marked = "string-2";
-                cx.state.tokenize = tokenQuasi;
-                return cont(quasi);
-              }
-            }
-            function arrowBody(type3) {
-              findFatArrow(cx.stream, cx.state);
-              return pass(type3 == "{" ? statement : expression);
-            }
-            function arrowBodyNoComma(type3) {
-              findFatArrow(cx.stream, cx.state);
-              return pass(type3 == "{" ? statement : expressionNoComma);
-            }
-            function maybeTarget(noComma) {
-              return function (type3) {
-                if (type3 == ".")
-                  return cont(noComma ? targetNoComma : target2);
-                else if (type3 == "variable" && isTS)
-                  return cont(
-                    maybeTypeArgs,
-                    noComma ? maybeoperatorNoComma : maybeoperatorComma
-                  );
-                else return pass(noComma ? expressionNoComma : expression);
-              };
-            }
-            function target2(_, value) {
-              if (value == "target") {
-                cx.marked = "keyword";
-                return cont(maybeoperatorComma);
-              }
-            }
-            function targetNoComma(_, value) {
-              if (value == "target") {
-                cx.marked = "keyword";
-                return cont(maybeoperatorNoComma);
-              }
-            }
-            function maybelabel(type3) {
-              if (type3 == ":") return cont(poplex, statement);
-              return pass(maybeoperatorComma, expect2(";"), poplex);
-            }
-            function property(type3) {
-              if (type3 == "variable") {
-                cx.marked = "property";
-                return cont();
-              }
-            }
-            function objprop(type3, value) {
-              if (type3 == "async") {
-                cx.marked = "property";
-                return cont(objprop);
-              } else if (type3 == "variable" || cx.style == "keyword") {
-                cx.marked = "property";
-                if (value == "get" || value == "set") return cont(getterSetter);
-                var m;
-                if (
-                  isTS &&
-                  cx.state.fatArrowAt == cx.stream.start &&
-                  (m = cx.stream.match(/^\s*:\s*/, false))
-                )
-                  cx.state.fatArrowAt = cx.stream.pos + m[0].length;
-                return cont(afterprop);
-              } else if (type3 == "number" || type3 == "string") {
-                cx.marked = jsonldMode ? "property" : cx.style + " property";
-                return cont(afterprop);
-              } else if (type3 == "jsonld-keyword") {
-                return cont(afterprop);
-              } else if (isTS && isModifier(value)) {
-                cx.marked = "keyword";
-                return cont(objprop);
-              } else if (type3 == "[") {
-                return cont(expression, maybetype, expect2("]"), afterprop);
-              } else if (type3 == "spread") {
-                return cont(expressionNoComma, afterprop);
-              } else if (value == "*") {
-                cx.marked = "keyword";
-                return cont(objprop);
-              } else if (type3 == ":") {
-                return pass(afterprop);
-              }
-            }
-            function getterSetter(type3) {
-              if (type3 != "variable") return pass(afterprop);
-              cx.marked = "property";
-              return cont(functiondef);
-            }
-            function afterprop(type3) {
-              if (type3 == ":") return cont(expressionNoComma);
-              if (type3 == "(") return pass(functiondef);
-            }
-            function commasep(what, end2, sep) {
-              function proceed(type3, value) {
-                if (sep ? sep.indexOf(type3) > -1 : type3 == ",") {
-                  var lex2 = cx.state.lexical;
-                  if (lex2.info == "call") lex2.pos = (lex2.pos || 0) + 1;
-                  return cont(function (type4, value2) {
-                    if (type4 == end2 || value2 == end2) return pass();
-                    return pass(what);
-                  }, proceed);
-                }
-                if (type3 == end2 || value == end2) return cont();
-                if (sep && sep.indexOf(";") > -1) return pass(what);
-                return cont(expect2(end2));
-              }
-              return function (type3, value) {
-                if (type3 == end2 || value == end2) return cont();
-                return pass(what, proceed);
-              };
-            }
-            function contCommasep(what, end2, info2) {
-              for (var i = 3; i < arguments.length; i++)
-                cx.cc.push(arguments[i]);
-              return cont(pushlex(end2, info2), commasep(what, end2), poplex);
-            }
-            function block3(type3) {
-              if (type3 == "}") return cont();
-              return pass(statement, block3);
-            }
-            function maybetype(type3, value) {
-              if (isTS) {
-                if (type3 == ":") return cont(typeexpr);
-                if (value == "?") return cont(maybetype);
-              }
-            }
-            function maybetypeOrIn(type3, value) {
-              if (isTS && (type3 == ":" || value == "in"))
-                return cont(typeexpr);
-            }
-            function mayberettype(type3) {
-              if (isTS && type3 == ":") {
-                if (cx.stream.match(/^\s*\w+\s+is\b/, false))
-                  return cont(expression, isKW, typeexpr);
-                else return cont(typeexpr);
-              }
-            }
-            function isKW(_, value) {
-              if (value == "is") {
-                cx.marked = "keyword";
-                return cont();
-              }
-            }
-            function typeexpr(type3, value) {
-              if (
-                value == "keyof" ||
-                value == "typeof" ||
-                value == "infer" ||
-                value == "readonly"
-              ) {
-                cx.marked = "keyword";
-                return cont(value == "typeof" ? expressionNoComma : typeexpr);
-              }
-              if (type3 == "variable" || value == "void") {
-                cx.marked = "type";
-                return cont(afterType);
-              }
-              if (value == "|" || value == "&") return cont(typeexpr);
-              if (type3 == "string" || type3 == "number" || type3 == "atom")
-                return cont(afterType);
-              if (type3 == "[")
-                return cont(
-                  pushlex("]"),
-                  commasep(typeexpr, "]", ","),
-                  poplex,
-                  afterType
-                );
-              if (type3 == "{")
-                return cont(pushlex("}"), typeprops, poplex, afterType);
-              if (type3 == "(")
-                return cont(commasep(typearg, ")"), maybeReturnType, afterType);
-              if (type3 == "<") return cont(commasep(typeexpr, ">"), typeexpr);
-              if (type3 == "quasi") {
-                return pass(quasiType, afterType);
-              }
-            }
-            function maybeReturnType(type3) {
-              if (type3 == "=>") return cont(typeexpr);
-            }
-            function typeprops(type3) {
-              if (type3.match(/[\}\)\]]/)) return cont();
-              if (type3 == "," || type3 == ";") return cont(typeprops);
-              return pass(typeprop, typeprops);
-            }
-            function typeprop(type3, value) {
-              if (type3 == "variable" || cx.style == "keyword") {
-                cx.marked = "property";
-                return cont(typeprop);
-              } else if (
-                value == "?" ||
-                type3 == "number" ||
-                type3 == "string"
-              ) {
-                return cont(typeprop);
-              } else if (type3 == ":") {
-                return cont(typeexpr);
-              } else if (type3 == "[") {
-                return cont(
-                  expect2("variable"),
-                  maybetypeOrIn,
-                  expect2("]"),
-                  typeprop
-                );
-              } else if (type3 == "(") {
-                return pass(functiondecl, typeprop);
-              } else if (!type3.match(/[;\}\)\],]/)) {
-                return cont();
-              }
-            }
-            function quasiType(type3, value) {
-              if (type3 != "quasi") return pass();
-              if (value.slice(value.length - 2) != "${") return cont(quasiType);
-              return cont(typeexpr, continueQuasiType);
-            }
-            function continueQuasiType(type3) {
-              if (type3 == "}") {
-                cx.marked = "string-2";
-                cx.state.tokenize = tokenQuasi;
-                return cont(quasiType);
-              }
-            }
-            function typearg(type3, value) {
-              if (
-                (type3 == "variable" && cx.stream.match(/^\s*[?:]/, false)) ||
-                value == "?"
-              )
-                return cont(typearg);
-              if (type3 == ":") return cont(typeexpr);
-              if (type3 == "spread") return cont(typearg);
-              return pass(typeexpr);
-            }
-            function afterType(type3, value) {
-              if (value == "<")
-                return cont(
-                  pushlex(">"),
-                  commasep(typeexpr, ">"),
-                  poplex,
-                  afterType
-                );
-              if (value == "|" || type3 == "." || value == "&")
-                return cont(typeexpr);
-              if (type3 == "[") return cont(typeexpr, expect2("]"), afterType);
-              if (value == "extends" || value == "implements") {
-                cx.marked = "keyword";
-                return cont(typeexpr);
-              }
-              if (value == "?") return cont(typeexpr, expect2(":"), typeexpr);
-            }
-            function maybeTypeArgs(_, value) {
-              if (value == "<")
-                return cont(
-                  pushlex(">"),
-                  commasep(typeexpr, ">"),
-                  poplex,
-                  afterType
-                );
-            }
-            function typeparam() {
-              return pass(typeexpr, maybeTypeDefault);
-            }
-            function maybeTypeDefault(_, value) {
-              if (value == "=") return cont(typeexpr);
-            }
-            function vardef(_, value) {
-              if (value == "enum") {
-                cx.marked = "keyword";
-                return cont(enumdef);
-              }
-              return pass(pattern, maybetype, maybeAssign, vardefCont);
-            }
-            function pattern(type3, value) {
-              if (isTS && isModifier(value)) {
-                cx.marked = "keyword";
-                return cont(pattern);
-              }
-              if (type3 == "variable") {
-                register(value);
-                return cont();
-              }
-              if (type3 == "spread") return cont(pattern);
-              if (type3 == "[") return contCommasep(eltpattern, "]");
-              if (type3 == "{") return contCommasep(proppattern, "}");
-            }
-            function proppattern(type3, value) {
-              if (type3 == "variable" && !cx.stream.match(/^\s*:/, false)) {
-                register(value);
-                return cont(maybeAssign);
-              }
-              if (type3 == "variable") cx.marked = "property";
-              if (type3 == "spread") return cont(pattern);
-              if (type3 == "}") return pass();
-              if (type3 == "[")
-                return cont(
-                  expression,
-                  expect2("]"),
-                  expect2(":"),
-                  proppattern
-                );
-              return cont(expect2(":"), pattern, maybeAssign);
-            }
-            function eltpattern() {
-              return pass(pattern, maybeAssign);
-            }
-            function maybeAssign(_type, value) {
-              if (value == "=") return cont(expressionNoComma);
-            }
-            function vardefCont(type3) {
-              if (type3 == ",") return cont(vardef);
-            }
-            function maybeelse(type3, value) {
-              if (type3 == "keyword b" && value == "else")
-                return cont(pushlex("form", "else"), statement, poplex);
-            }
-            function forspec(type3, value) {
-              if (value == "await") return cont(forspec);
-              if (type3 == "(") return cont(pushlex(")"), forspec1, poplex);
-            }
-            function forspec1(type3) {
-              if (type3 == "var") return cont(vardef, forspec2);
-              if (type3 == "variable") return cont(forspec2);
-              return pass(forspec2);
-            }
-            function forspec2(type3, value) {
-              if (type3 == ")") return cont();
-              if (type3 == ";") return cont(forspec2);
-              if (value == "in" || value == "of") {
-                cx.marked = "keyword";
-                return cont(expression, forspec2);
-              }
-              return pass(expression, forspec2);
-            }
-            function functiondef(type3, value) {
-              if (value == "*") {
-                cx.marked = "keyword";
-                return cont(functiondef);
-              }
-              if (type3 == "variable") {
-                register(value);
-                return cont(functiondef);
-              }
-              if (type3 == "(")
-                return cont(
-                  pushcontext,
-                  pushlex(")"),
-                  commasep(funarg, ")"),
-                  poplex,
-                  mayberettype,
-                  statement,
-                  popcontext
-                );
-              if (isTS && value == "<")
-                return cont(
-                  pushlex(">"),
-                  commasep(typeparam, ">"),
-                  poplex,
-                  functiondef
-                );
-            }
-            function functiondecl(type3, value) {
-              if (value == "*") {
-                cx.marked = "keyword";
-                return cont(functiondecl);
-              }
-              if (type3 == "variable") {
-                register(value);
-                return cont(functiondecl);
-              }
-              if (type3 == "(")
-                return cont(
-                  pushcontext,
-                  pushlex(")"),
-                  commasep(funarg, ")"),
-                  poplex,
-                  mayberettype,
-                  popcontext
-                );
-              if (isTS && value == "<")
-                return cont(
-                  pushlex(">"),
-                  commasep(typeparam, ">"),
-                  poplex,
-                  functiondecl
-                );
-            }
-            function typename(type3, value) {
-              if (type3 == "keyword" || type3 == "variable") {
-                cx.marked = "type";
-                return cont(typename);
-              } else if (value == "<") {
-                return cont(pushlex(">"), commasep(typeparam, ">"), poplex);
-              }
-            }
-            function funarg(type3, value) {
-              if (value == "@") cont(expression, funarg);
-              if (type3 == "spread") return cont(funarg);
-              if (isTS && isModifier(value)) {
-                cx.marked = "keyword";
-                return cont(funarg);
-              }
-              if (isTS && type3 == "this") return cont(maybetype, maybeAssign);
-              return pass(pattern, maybetype, maybeAssign);
-            }
-            function classExpression(type3, value) {
-              if (type3 == "variable") return className(type3, value);
-              return classNameAfter(type3, value);
-            }
-            function className(type3, value) {
-              if (type3 == "variable") {
-                register(value);
-                return cont(classNameAfter);
-              }
-            }
-            function classNameAfter(type3, value) {
-              if (value == "<")
-                return cont(
-                  pushlex(">"),
-                  commasep(typeparam, ">"),
-                  poplex,
-                  classNameAfter
-                );
-              if (
-                value == "extends" ||
-                value == "implements" ||
-                (isTS && type3 == ",")
-              ) {
-                if (value == "implements") cx.marked = "keyword";
-                return cont(isTS ? typeexpr : expression, classNameAfter);
-              }
-              if (type3 == "{") return cont(pushlex("}"), classBody, poplex);
-            }
-            function classBody(type3, value) {
-              if (
-                type3 == "async" ||
-                (type3 == "variable" &&
-                  (value == "static" ||
-                    value == "get" ||
-                    value == "set" ||
-                    (isTS && isModifier(value))) &&
-                  cx.stream.match(/^\s+[\w$\xa1-\uffff]/, false))
-              ) {
-                cx.marked = "keyword";
-                return cont(classBody);
-              }
-              if (type3 == "variable" || cx.style == "keyword") {
-                cx.marked = "property";
-                return cont(classfield, classBody);
-              }
-              if (type3 == "number" || type3 == "string")
-                return cont(classfield, classBody);
-              if (type3 == "[")
-                return cont(
-                  expression,
-                  maybetype,
-                  expect2("]"),
-                  classfield,
-                  classBody
-                );
-              if (value == "*") {
-                cx.marked = "keyword";
-                return cont(classBody);
-              }
-              if (isTS && type3 == "(") return pass(functiondecl, classBody);
-              if (type3 == ";" || type3 == ",") return cont(classBody);
-              if (type3 == "}") return cont();
-              if (value == "@") return cont(expression, classBody);
-            }
-            function classfield(type3, value) {
-              if (value == "!") return cont(classfield);
-              if (value == "?") return cont(classfield);
-              if (type3 == ":") return cont(typeexpr, maybeAssign);
-              if (value == "=") return cont(expressionNoComma);
-              var context = cx.state.lexical.prev,
-                isInterface = context && context.info == "interface";
-              return pass(isInterface ? functiondecl : functiondef);
-            }
-            function afterExport(type3, value) {
-              if (value == "*") {
-                cx.marked = "keyword";
-                return cont(maybeFrom, expect2(";"));
-              }
-              if (value == "default") {
-                cx.marked = "keyword";
-                return cont(expression, expect2(";"));
-              }
-              if (type3 == "{")
-                return cont(
-                  commasep(exportField, "}"),
-                  maybeFrom,
-                  expect2(";")
-                );
-              return pass(statement);
-            }
-            function exportField(type3, value) {
-              if (value == "as") {
-                cx.marked = "keyword";
-                return cont(expect2("variable"));
-              }
-              if (type3 == "variable")
-                return pass(expressionNoComma, exportField);
-            }
-            function afterImport(type3) {
-              if (type3 == "string") return cont();
-              if (type3 == "(") return pass(expression);
-              if (type3 == ".") return pass(maybeoperatorComma);
-              return pass(importSpec, maybeMoreImports, maybeFrom);
-            }
-            function importSpec(type3, value) {
-              if (type3 == "{") return contCommasep(importSpec, "}");
-              if (type3 == "variable") register(value);
-              if (value == "*") cx.marked = "keyword";
-              return cont(maybeAs);
-            }
-            function maybeMoreImports(type3) {
-              if (type3 == ",") return cont(importSpec, maybeMoreImports);
-            }
-            function maybeAs(_type, value) {
-              if (value == "as") {
-                cx.marked = "keyword";
-                return cont(importSpec);
-              }
-            }
-            function maybeFrom(_type, value) {
-              if (value == "from") {
-                cx.marked = "keyword";
-                return cont(expression);
-              }
-            }
-            function arrayLiteral(type3) {
-              if (type3 == "]") return cont();
-              return pass(commasep(expressionNoComma, "]"));
-            }
-            function enumdef() {
-              return pass(
-                pushlex("form"),
-                pattern,
-                expect2("{"),
-                pushlex("}"),
-                commasep(enummember, "}"),
-                poplex,
-                poplex
-              );
-            }
-            function enummember() {
-              return pass(pattern, maybeAssign);
-            }
-            function isContinuedStatement(state, textAfter) {
-              return (
-                state.lastType == "operator" ||
-                state.lastType == "," ||
-                isOperatorChar.test(textAfter.charAt(0)) ||
-                /[,.]/.test(textAfter.charAt(0))
-              );
-            }
-            function expressionAllowed(stream, state, backUp) {
-              return (
-                (state.tokenize == tokenBase &&
-                  /^(?:operator|sof|keyword [bcd]|case|new|export|default|spread|[\[{}\(,;:]|=>)$/.test(
-                    state.lastType
-                  )) ||
-                (state.lastType == "quasi" &&
-                  /\{\s*$/.test(
-                    stream.string.slice(0, stream.pos - (backUp || 0))
-                  ))
-              );
-            }
-            return {
-              startState: function (basecolumn) {
-                var state = {
-                  tokenize: tokenBase,
-                  lastType: "sof",
-                  cc: [],
-                  lexical: new JSLexical(
-                    (basecolumn || 0) - indentUnit,
-                    0,
-                    "block",
-                    false
-                  ),
-                  localVars: parserConfig.localVars,
-                  context:
-                    parserConfig.localVars && new Context(null, null, false),
-                  indented: basecolumn || 0,
-                };
-                if (
-                  parserConfig.globalVars &&
-                  typeof parserConfig.globalVars == "object"
-                )
-                  state.globalVars = parserConfig.globalVars;
-                return state;
-              },
-              token: function (stream, state) {
-                if (stream.sol()) {
-                  if (!state.lexical.hasOwnProperty("align"))
-                    state.lexical.align = false;
-                  state.indented = stream.indentation();
-                  findFatArrow(stream, state);
-                }
-                if (state.tokenize != tokenComment && stream.eatSpace())
-                  return null;
-                var style = state.tokenize(stream, state);
-                if (type2 == "comment") return style;
-                state.lastType =
-                  type2 == "operator" && (content == "++" || content == "--")
-                    ? "incdec"
-                    : type2;
-                return parseJS(state, style, type2, content, stream);
-              },
-              indent: function (state, textAfter) {
-                if (
-                  state.tokenize == tokenComment ||
-                  state.tokenize == tokenQuasi
-                )
-                  return CodeMirror.Pass;
-                if (state.tokenize != tokenBase) return 0;
-                var firstChar = textAfter && textAfter.charAt(0),
-                  lexical = state.lexical,
-                  top2;
-                if (!/^\s*else\b/.test(textAfter))
-                  for (var i = state.cc.length - 1; i >= 0; --i) {
-                    var c = state.cc[i];
-                    if (c == poplex) lexical = lexical.prev;
-                    else if (c != maybeelse && c != popcontext) break;
-                  }
-                while (
-                  (lexical.type == "stat" || lexical.type == "form") &&
-                  (firstChar == "}" ||
-                    ((top2 = state.cc[state.cc.length - 1]) &&
-                      (top2 == maybeoperatorComma ||
-                        top2 == maybeoperatorNoComma) &&
-                      !/^[,\.=+\-*:?[\(]/.test(textAfter)))
-                )
-                  lexical = lexical.prev;
-                if (
-                  statementIndent &&
-                  lexical.type == ")" &&
-                  lexical.prev.type == "stat"
-                )
-                  lexical = lexical.prev;
-                var type3 = lexical.type,
-                  closing = firstChar == type3;
-                if (type3 == "vardef")
-                  return (
-                    lexical.indented +
-                    (state.lastType == "operator" || state.lastType == ","
-                      ? lexical.info.length + 1
-                      : 0)
-                  );
-                else if (type3 == "form" && firstChar == "{")
-                  return lexical.indented;
-                else if (type3 == "form") return lexical.indented + indentUnit;
-                else if (type3 == "stat")
-                  return (
-                    lexical.indented +
-                    (isContinuedStatement(state, textAfter)
-                      ? statementIndent || indentUnit
-                      : 0)
-                  );
-                else if (
-                  lexical.info == "switch" &&
-                  !closing &&
-                  parserConfig.doubleIndentSwitch != false
-                )
-                  return (
-                    lexical.indented +
-                    (/^(?:case|default)\b/.test(textAfter)
-                      ? indentUnit
-                      : 2 * indentUnit)
-                  );
-                else if (lexical.align)
-                  return lexical.column + (closing ? 0 : 1);
-                else return lexical.indented + (closing ? 0 : indentUnit);
-              },
-              electricInput: /^\s*(?:case .*?:|default:|\{|\})$/,
-              blockCommentStart: jsonMode ? null : "/*",
-              blockCommentEnd: jsonMode ? null : "*/",
-              blockCommentContinue: jsonMode ? null : " * ",
-              lineComment: jsonMode ? null : "//",
-              fold: "brace",
-              closeBrackets: "()[]{}''\"\"``",
-              helperType: jsonMode ? "json" : "javascript",
-              jsonldMode,
-              jsonMode,
-              expressionAllowed,
-              skipExpression: function (state) {
-                parseJS(
-                  state,
-                  "atom",
-                  "atom",
-                  "true",
-                  new CodeMirror.StringStream("", 2, null)
-                );
-              },
-            };
-          });
-          CodeMirror.registerHelper("wordChars", "javascript", /[\w$]/);
-          CodeMirror.defineMIME("text/javascript", "javascript");
-          CodeMirror.defineMIME("text/ecmascript", "javascript");
-          CodeMirror.defineMIME("application/javascript", "javascript");
-          CodeMirror.defineMIME("application/x-javascript", "javascript");
-          CodeMirror.defineMIME("application/ecmascript", "javascript");
-          CodeMirror.defineMIME("application/json", {
-            name: "javascript",
-            json: true,
-          });
-          CodeMirror.defineMIME("application/x-json", {
-            name: "javascript",
-            json: true,
-          });
-          CodeMirror.defineMIME("application/manifest+json", {
-            name: "javascript",
-            json: true,
-          });
-          CodeMirror.defineMIME("application/ld+json", {
-            name: "javascript",
-            jsonld: true,
-          });
-          CodeMirror.defineMIME("text/typescript", {
-            name: "javascript",
-            typescript: true,
-          });
-          CodeMirror.defineMIME("application/typescript", {
-            name: "javascript",
-            typescript: true,
-          });
-        });
-      })();
-      var javascript = javascript$2.exports;
-      var javascript$1 = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: javascript,
-          },
-          [javascript$2.exports]
-        )
-      );
-      var mode$1 = {};
-      var __importDefault =
-        (commonjsGlobal && commonjsGlobal.__importDefault) ||
-        function (mod) {
-          return mod && mod.__esModule ? mod : { default: mod };
-        };
-      Object.defineProperty(mode$1, "__esModule", { value: true });
-      var codemirror_1 = __importDefault(codemirror$2.exports);
-      var graphql_language_service_1 = require$$1$1;
-      codemirror_1.default.defineMode("graphql-results", function (config2) {
-        var parser = graphql_language_service_1.onlineParser({
-          eatWhitespace: function (stream) {
-            return stream.eatSpace();
-          },
-          lexRules: LexRules,
-          parseRules: ParseRules,
-          editorConfig: { tabSize: config2.tabSize },
-        });
-        return {
-          config: config2,
-          startState: parser.startState,
-          token: parser.token,
-          indent,
-          electricInput: /^\s*[}\]]/,
-          fold: "brace",
-          closeBrackets: {
-            pairs: '[]{}""',
-            explode: "[]{}",
-          },
-        };
-      });
-      function indent(state, textAfter) {
-        var _a2, _b;
-        var levels = state.levels;
-        var level =
-          !levels || levels.length === 0
-            ? state.indentLevel
-            : levels[levels.length - 1] -
-              ((
-                (_a2 = this.electricInput) === null || _a2 === void 0
-                  ? void 0
-                  : _a2.test(textAfter)
-              )
-                ? 1
-                : 0);
-        return (
-          (level || 0) *
-          (((_b = this.config) === null || _b === void 0
-            ? void 0
-            : _b.indentUnit) || 0)
-        );
-      }
-      var LexRules = {
-        Punctuation: /^\[|]|\{|\}|:|,/,
-        Number: /^-?(?:0|(?:[1-9][0-9]*))(?:\.[0-9]*)?(?:[eE][+-]?[0-9]+)?/,
-        String: /^"(?:[^"\\]|\\(?:"|\/|\\|b|f|n|r|t|u[0-9a-fA-F]{4}))*"?/,
-        Keyword: /^true|false|null/,
-      };
-      var ParseRules = {
-        Document: [
-          graphql_language_service_1.p("{"),
-          graphql_language_service_1.list(
-            "Entry",
-            graphql_language_service_1.p(",")
-          ),
-          graphql_language_service_1.p("}"),
-        ],
-        Entry: [
-          graphql_language_service_1.t("String", "def"),
-          graphql_language_service_1.p(":"),
-          "Value",
-        ],
-        Value: function (token2) {
-          switch (token2.kind) {
-            case "Number":
-              return "NumberValue";
-            case "String":
-              return "StringValue";
-            case "Punctuation":
-              switch (token2.value) {
-                case "[":
-                  return "ListValue";
-                case "{":
-                  return "ObjectValue";
-              }
-              return null;
-            case "Keyword":
-              switch (token2.value) {
-                case "true":
-                case "false":
-                  return "BooleanValue";
-                case "null":
-                  return "NullValue";
-              }
-              return null;
-          }
-        },
-        NumberValue: [graphql_language_service_1.t("Number", "number")],
-        StringValue: [graphql_language_service_1.t("String", "string")],
-        BooleanValue: [graphql_language_service_1.t("Keyword", "builtin")],
-        NullValue: [graphql_language_service_1.t("Keyword", "keyword")],
-        ListValue: [
-          graphql_language_service_1.p("["),
-          graphql_language_service_1.list(
-            "Value",
-            graphql_language_service_1.p(",")
-          ),
-          graphql_language_service_1.p("]"),
-        ],
-        ObjectValue: [
-          graphql_language_service_1.p("{"),
-          graphql_language_service_1.list(
-            "ObjectField",
-            graphql_language_service_1.p(",")
-          ),
-          graphql_language_service_1.p("}"),
-        ],
-        ObjectField: [
-          graphql_language_service_1.t("String", "property"),
-          graphql_language_service_1.p(":"),
-          "Value",
-        ],
-      };
-      var mode = /* @__PURE__ */ Object.freeze(
-        /* @__PURE__ */ _mergeNamespaces(
-          {
-            __proto__: null,
-            [Symbol.toStringTag]: "Module",
-            default: mode$1,
-          },
-          [mode$1]
-        )
-      );
-      export { renderYogaGraphiQL };
-
-      var endpoint = window.location.pathname.substring(
+      const endpoint = window.location.pathname.substring(
         0,
         window.location.pathname.length - "/graphql".length
       );
 
-      renderYogaGraphiQL(window.document.querySelector("#root"), {
+      renderYogaGraphiQL(root, {
         endpoint,
+        title: "The GraphiQL",
+        logo: React.createElement("img", {
+          src: "https://storage.googleapis.com/graph-web/favicon.png",
+          crossOrigin: "anonymous",
+          style: {
+            height: "42px",
+          },
+        }),
       });
     </script>
   </body>
diff --git a/server/http/src/lib.rs b/server/http/src/lib.rs
index c5621bcf7ab..b1be017783a 100644
--- a/server/http/src/lib.rs
+++ b/server/http/src/lib.rs
@@ -1,11 +1,5 @@
-extern crate futures;
 extern crate graph;
 extern crate graph_graphql;
-#[cfg(test)]
-extern crate graph_mock;
-extern crate graphql_parser;
-extern crate http;
-extern crate hyper;
 extern crate serde;
 
 mod request;
@@ -13,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 8c659a7c199..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(),
         )),
     }?;
@@ -51,7 +51,11 @@ mod tests {
     use std::collections::HashMap;
 
     use graph::{
-        data::{query::QueryTarget, value::Object},
+        data::{
+            query::QueryTarget,
+            value::{Object, Word},
+        },
+        hyper::body::Bytes,
         prelude::*,
     };
 
@@ -66,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 } }\", \
@@ -118,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);
     }
@@ -128,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 } }\", \
@@ -143,7 +140,7 @@ mod tests {
     #[test]
     fn parses_variables() {
         let request = parse_graphql_request(
-            &hyper::body::Bytes::from(
+            &Bytes::from(
                 "\
                  {\
                  \"query\": \"{ user { name } }\", \
@@ -156,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![(String::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 a99e8bafe05..8aad5eb0d18 100644
--- a/server/http/src/server.rs
+++ b/server/http/src/server.rs
@@ -1,29 +1,23 @@
-use std::net::{Ipv4Addr, SocketAddrV4};
+use std::sync::Arc;
 
-use hyper::service::make_service_fn;
-use hyper::Server;
+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, *};
-use thiserror::Error;
-
-/// 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 {
@@ -35,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!(
@@ -58,27 +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 |_| {
-            futures03::future::ok::<_, Error>(GraphQLService::new(
-                logger_for_service.clone(),
-                graphql_runner.clone(),
-                ws_port,
-                node_id.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)));
+        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 5d0ef6ded14..66a799caed3 100644
--- a/server/http/src/service.rs
+++ b/server/http/src/service.rs
@@ -1,45 +1,57 @@
 use std::convert::TryFrom;
-use std::pin::Pin;
-use std::task::Context;
-use std::task::Poll;
+use std::env;
+use std::sync::Arc;
 use std::time::Instant;
 
-use graph::prelude::*;
-use graph::semver::VersionReq;
-use graph::{components::server::query::GraphQLServerError, data::query::QueryTarget};
-use http::header;
-use http::header::{
+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_TYPE, LOCATION,
+    CONTENT_LENGTH, CONTENT_TYPE, LOCATION,
 };
-use hyper::service::Service;
-use hyper::{Body, Method, Request, Response, StatusCode};
+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::semver::VersionReq;
+use graph::slog::Logger;
+use graph::slog::error;
+use graph::url::form_urlencoded;
+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>
@@ -47,61 +59,55 @@ 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>"
+        });
+        let response_str = serde_json::to_string(&response_obj).unwrap();
+
         Ok(Response::builder()
             .status(200)
             .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-            .header(CONTENT_TYPE, "text/plain")
-            .body(Body::from(String::from(
-                "Access deployed subgraphs by deployment ID at \
-                /subgraphs/id/<ID> or by name at /subgraphs/name/<NAME>",
-            )))
+            .header(CONTENT_TYPE, "application/json")
+            .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")
-                .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
             });
@@ -109,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()
@@ -167,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);
@@ -194,52 +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")
-                .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")
-                    .body(Body::from("Redirecting..."))
+                    .header(CONTENT_TYPE, "text/plain; charset=utf-8")
+                    .body(Full::from("Redirecting..."))
                     .unwrap()
             })
     }
 
-    /// Handles 404s.
-    fn handle_not_found(&self) -> GraphQLServiceResponse {
-        async {
-            Ok(Response::builder()
-                .status(StatusCode::NOT_FOUND)
-                .header(CONTENT_TYPE, "text/plain")
-                .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                .body(Body::from("Not found"))
-                .unwrap())
+    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) -> ServerResult {
+        Ok(client_error("Can't use mutations with GET method"))
+    }
+    /// Handles requests without content type.
+    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) -> ServerResult {
+        Ok(client_error("Body is required"))
+    }
+
+    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;
         }
-        .boxed()
+        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();
@@ -252,114 +320,140 @@ where
             segments.collect::<Vec<_>>()
         };
 
+        let headers = req.headers();
+        let content_type = headers.get("content-type");
+
+        let less_strict_graphql_compliance = env::var("LESS_STRICT_GRAPHQL_COMPLIANCE").is_ok();
+
+        if !less_strict_graphql_compliance {
+            if method == Method::POST && (content_type.is_none()) {
+                return self.handle_requests_without_content_type();
+            }
+
+            if method == Method::POST && !self.has_request_body(&req) {
+                return self.handle_requests_without_body();
+            }
+        }
+
+        // Filter out empty strings from path segments
+        fn filter_and_join_segments(segments: &[&str]) -> String {
+            segments
+                .iter()
+                .filter(|&&segment| !segment.is_empty())
+                .copied()
+                .collect::<Vec<&str>>()
+                .join("/")
+        }
+
+        let is_mutation = req
+            .uri()
+            .query()
+            .and_then(|query_str| {
+                form_urlencoded::parse(query_str.as_bytes())
+                    .find(|(key, _)| key == "query")
+                    .map(|(_, value)| value.into_owned())
+            })
+            .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", "name", _, _, "graphql"])
+            | (Method::GET, &["subgraphs", "name", .., "graphql"])
             | (Method::GET, &["subgraphs", "network", _, _, "graphql"])
             | (Method::GET, &["subgraphs", "graphql"]) => self.handle_graphiql(),
 
+            (Method::GET, _path @ ["subgraphs", "name", ..]) if is_mutation => {
+                self.handle_mutations()
+            }
             (Method::GET, path @ ["subgraphs", "id", _])
-            | (Method::GET, path @ ["subgraphs", "name", _])
-            | (Method::GET, path @ ["subgraphs", "name", _, _])
+            | (Method::GET, path @ ["subgraphs", "name", ..])
             | (Method::GET, path @ ["subgraphs", "network", _, _]) => {
-                let dest = format!("/{}/graphql", path.join("/"));
-                self.handle_temp_redirect(dest).boxed()
+                let filtered_path = filter_and_join_segments(path);
+                let dest = format!("/{}/graphql", filtered_path);
+                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, &["subgraphs", "name", subgraph_name]) => self
-                .handle_graphql_query_by_name(subgraph_name.to_owned(), req)
-                .boxed(),
-            (Method::POST, ["subgraphs", "name", subgraph_name_part1, subgraph_name_part2]) => {
-                let subgraph_name = format!("{}/{}", subgraph_name_part1, subgraph_name_part2);
-                self.handle_graphql_query_by_name(subgraph_name, req)
-                    .boxed()
-            }
-            (Method::POST, ["subgraphs", "network", subgraph_name_part1, subgraph_name_part2]) => {
-                let subgraph_name =
-                    format!("network/{}/{}", subgraph_name_part1, subgraph_name_part2);
-                self.handle_graphql_query_by_name(subgraph_name, req)
-                    .boxed()
+            (Method::POST, path @ ["subgraphs", "name", ..]) => {
+                let subgraph_name = filter_and_join_segments(&path[2..]);
+                self.handle_graphql_query_by_name(subgraph_name, req).await
             }
 
-            (Method::OPTIONS, ["subgraphs", "name", _])
-            | (Method::OPTIONS, ["subgraphs", "name", _, _])
-            | (Method::OPTIONS, ["subgraphs", "network", _, _]) => self.handle_graphql_options(req),
+            (Method::OPTIONS, ["subgraphs", "name", ..]) => self.handle_graphql_options(req),
 
             _ => 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();
 
-    fn call(&mut self, req: Request<Body>) -> Self::Future {
-        let logger = self.logger.clone();
-        let service = self.clone();
+                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);
 
-        // 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(_)) => Ok(Response::builder()
+                let response_obj = json!({
+                    "QueryError": err.to_string()
+                });
+                let response_str = serde_json::to_string(&response_obj).unwrap();
+
+                Response::builder()
                     .status(400)
-                    .header(CONTENT_TYPE, "text/plain")
+                    .header(CONTENT_TYPE, "application/json")
                     .header(ACCESS_CONTROL_ALLOW_ORIGIN, "*")
-                    .body(Body::from(err.to_string()))
-                    .unwrap()),
-                Err(err @ GraphQLServerError::QueryError(_)) => {
-                    error!(logger, "GraphQLService 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, "GraphQLService 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())
-                }
+                    .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 graph::data::value::Object;
-    use http::status::StatusCode;
-    use hyper::service::Service;
-    use hyper::{Body, Method, Request};
-
-    use graph::data::{
-        graphql::effort::LoadManager,
-        query::{QueryResults, QueryTarget},
-    };
+    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 graph::data::query::{QueryResults, QueryTarget, SqlQueryReq};
     use graph::prelude::*;
 
     use crate::test_utils;
@@ -380,6 +474,7 @@ mod tests {
         fn observe_query_parsing(&self, _duration: Duration, _results: &QueryResults) {}
         fn observe_query_validation(&self, _duration: Duration, _id: &DeploymentHash) {}
         fn observe_query_validation_error(&self, _error_codes: Vec<&str>, _id: &DeploymentHash) {}
+        fn observe_query_blocks_behind(&self, _blocks_behind: i32, _id: &DeploymentHash) {}
     }
 
     #[async_trait]
@@ -397,86 +492,110 @@ mod tests {
         }
 
         async fn run_query(self: Arc<Self>, _query: Query, _target: QueryTarget) -> QueryResults {
-            QueryResults::from(Object::from_iter(
-                vec![(
-                    String::from("name"),
-                    r::Value::String(String::from("Jordi")),
-                )]
-                .into_iter(),
-            ))
+            QueryResults::from(Object::from_iter(vec![(
+                Word::from("name"),
+                r::Value::String(String::from("Jordi")),
+            )]))
         }
 
-        async fn run_subscription(
-            self: Arc<Self>,
-            _subscription: Subscription,
-            _target: QueryTarget,
-        ) -> Result<SubscriptionResult, SubscriptionError> {
-            unreachable!();
+        fn metrics(&self) -> Arc<dyn GraphQLMetrics> {
+            Arc::new(TestGraphQLMetrics)
         }
 
-        fn load_manager(&self) -> Arc<LoadManager> {
+        async fn run_sql_query(
+            self: Arc<Self>,
+            _req: SqlQueryReq,
+        ) -> Result<Vec<SqlQueryObject>, QueryExecutionError> {
             unimplemented!()
         }
+    }
 
-        fn metrics(&self) -> Arc<dyn GraphQLMetrics> {
-            Arc::new(TestGraphQLMetrics)
-        }
+    #[graph::test]
+    async fn querying_not_found_routes_responds_correctly() {
+        let logger = Logger::root(slog::Discard, o!());
+        let graphql_runner = Arc::new(TestGraphQlRunner);
+
+        let service = GraphQLService::new(logger, graphql_runner);
+
+        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(Full::from("{}"))
+            .unwrap();
+
+        let response = service.call(request).await;
+
+        let content_type_header = response.status();
+        assert_eq!(content_type_header, StatusCode::OK);
+
+        let content_type_header = response.headers().get(CONTENT_TYPE).unwrap();
+        assert_eq!(content_type_header, "application/json");
+
+        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());
+
+        assert!(json.is_ok(), "Response body is not valid JSON");
+
+        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)
             .uri(format!(
                 "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");
 
-        assert_eq!(
-            message,
-            "GraphQL server error (client error): The \"query\" field is missing in request data"
-        );
+        let response = json!({
+            "error": "GraphQL server error (client error): The \"query\" field is missing in request data".to_string()
+        });
+
+        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)
             .uri(format!(
                 "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 data = test_utils::assert_successful_response(response);
+        let response = service.call(request).await;
+
+        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 22935598ee7..114b729e385 100644
--- a/server/http/src/test_utils.rs
+++ b/server/http/src/test_utils.rs
@@ -1,47 +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_eq!(response.status(), StatusCode::OK);
     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 {
@@ -61,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 589e10d696b..a7d43360cf5 100644
--- a/server/http/tests/server.rs
+++ b/server/http/tests/server.rs
@@ -1,15 +1,15 @@
-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::{
-    graphql::effort::LoadManager,
     query::{QueryResults, QueryTarget},
-    value::Object,
+    value::{Object, Word},
 };
 use graph::prelude::*;
-
-use graph_server_http::test_utils;
 use graph_server_http::GraphQLServer as HyperGraphQLServer;
 
 use tokio::time::sleep;
@@ -21,6 +21,7 @@ impl GraphQLMetrics for TestGraphQLMetrics {
     fn observe_query_parsing(&self, _duration: Duration, _results: &QueryResults) {}
     fn observe_query_validation(&self, _duration: Duration, _id: &DeploymentHash) {}
     fn observe_query_validation_error(&self, _error_codes: Vec<&str>, _id: &DeploymentHash) {}
+    fn observe_query_blocks_behind(&self, _blocks_behind: i32, _id: &DeploymentHash) {}
 }
 
 /// A simple stupid query runner for testing.
@@ -55,243 +56,284 @@ impl GraphQlRunner for TestGraphQlRunner {
                 .unwrap()
                 == &r::Value::String(String::from("John"))
         {
-            Object::from_iter(
-                vec![(String::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![(
-                    String::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 load_manager(&self) -> Arc<LoadManager> {
-        unimplemented!()
-    }
-
     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 graph_mock::MockMetricsRegistry;
+    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(MockMetricsRegistry::new()));
-                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))
-                                .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, "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(MockMetricsRegistry::new()));
-            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))
-                            .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(MockMetricsRegistry::new()));
-            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))
-                            .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\"}"
+        );
     }
 
-    #[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(MockMetricsRegistry::new()));
-            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 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());
+    }
+
+    #[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!) { \
@@ -301,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 9088d7ff1ab..549b56c4365 100644
--- a/server/index-node/Cargo.toml
+++ b/server/index-node/Cargo.toml
@@ -4,17 +4,10 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-blake3 = "1.3"
-either = "1.8.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" }
-graphql-parser = "0.4.0"
-http = "0.2"
-hyper = "0.14"
-lazy_static = "1.2.0"
-serde = "1.0"
+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 6d65630e9ad..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;
@@ -98,14 +92,14 @@ where
             failed: vi.failed,
             description: vi.description.as_deref(),
             repository: vi.repository.as_deref(),
-            schema: vi.schema.document.to_string(),
+            schema: vi.schema.document_string(),
             network: vi.network.as_str()
         };
         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 498e2149532..5d23483265e 100644
--- a/server/index-node/src/resolver.rs
+++ b/server/index-node/src/resolver.rs
@@ -1,22 +1,42 @@
 use std::collections::BTreeMap;
-use std::convert::TryInto;
 
-use either::Either;
+use async_trait::async_trait;
 use graph::data::query::Trace;
-use web3::types::Address;
+use graph::data::store::Id;
+use graph::prelude::alloy::primitives::Address;
+use graph::schema::EntityType;
 
+use git_testament::{CommitKind, git_testament};
+use graph::amp;
 use graph::blockchain::{Blockchain, BlockchainKind, BlockchainMap};
-use graph::components::store::{BlockStore, EntityType, Store};
+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::features::detect_features;
-use graph::data::subgraph::status;
-use graph::data::value::{Object, Word};
+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;
 
+/// Timeout for calls to fetch the block from JSON-RPC or Firehose.
+const BLOCK_HASH_FROM_NUMBER_TIMEOUT: Duration = Duration::from_secs(10);
+
+git_testament!(TESTAMENT);
+
+lazy_static! {
+    static ref VERSION: Version = Version {
+        version: env!("CARGO_PKG_VERSION").to_string(),
+        commit: match TESTAMENT.commit {
+            CommitKind::FromTag(_, hash, _, _) => hash.to_string(),
+            CommitKind::NoTags(hash, _) => hash.to_string(),
+            _ => "unknown".to_string(),
+        }
+    };
+}
+
 #[derive(Clone, Debug)]
 struct PublicProofOfIndexingRequest {
     pub deployment: DeploymentHash,
@@ -38,6 +58,21 @@ impl TryFromValue for PublicProofOfIndexingRequest {
     }
 }
 
+#[derive(Clone, Debug)]
+struct Version {
+    version: String,
+    commit: String,
+}
+
+impl IntoValue for Version {
+    fn into_value(self) -> r::Value {
+        object! {
+            version: self.version,
+            commit: self.commit,
+        }
+    }
+}
+
 #[derive(Debug)]
 struct PublicProofOfIndexingResult {
     pub deployment: DeploymentHash,
@@ -61,19 +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>,
     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 {
@@ -84,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 {
@@ -101,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> {
@@ -128,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> {
@@ -148,12 +195,13 @@ 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))
     }
 
-    fn resolve_block_data(&self, field: &a::Field) -> Result<r::Value, QueryExecutionError> {
+    async fn resolve_block_data(&self, field: &a::Field) -> Result<r::Value, QueryExecutionError> {
         let network = field
             .get_required::<String>("network")
             .expect("Valid network required");
@@ -162,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!(
@@ -174,7 +222,7 @@ impl<S: Store> IndexNodeResolver<S> {
             return Ok(r::Value::Null);
         };
 
-        let blocks_res = chain_store.blocks(&[block_hash.cheap_clone()]);
+        let blocks_res = chain_store.blocks(vec![block_hash.cheap_clone()]).await;
         Ok(match blocks_res {
             Ok(blocks) if blocks.is_empty() => {
                 error!(
@@ -187,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!(
@@ -213,62 +275,10 @@ impl<S: Store> IndexNodeResolver<S> {
             .get_required::<BlockNumber>("blockNumber")
             .expect("Valid blockNumber required");
 
-        macro_rules! try_resolve_for_chain {
-            ( $typ:path ) => {
-                let blockchain = self.blockchain_map.get::<$typ>(network.to_string()).ok();
-
-                if let Some(blockchain) = blockchain {
-                    debug!(
-                        self.logger,
-                        "Fetching block hash from number";
-                        "network" => &network,
-                        "block_number" => block_number,
-                    );
-
-                    let block_ptr_res = blockchain
-                        .block_pointer_from_number(&self.logger, block_number)
-                        .await;
-
-                        if let Err(e) = block_ptr_res {
-                            warn!(
-                                self.logger,
-                                "Failed to fetch block hash from number";
-                                "network" => &network,
-                                "chain" => <$typ as Blockchain>::KIND.to_string(),
-                                "block_number" => block_number,
-                                "error" => e.to_string(),
-                            );
-                            return Ok(r::Value::Null);
-                        }
-
-                    let block_ptr = block_ptr_res.unwrap();
-                    return Ok(r::Value::String(block_ptr.hash_hex()));
-                }
-            };
-        }
-
-        // 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);
-
-        // 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
-        // add a new `try_resolve!` macro invocation above for your new chain
-        // type.
-        match BlockchainKind::Ethereum {
-            // Note: we don't actually care about substreams here.
-            BlockchainKind::Substreams
-            | BlockchainKind::Arweave
-            | BlockchainKind::Ethereum
-            | BlockchainKind::Cosmos
-            | BlockchainKind::Near => (),
+        match self.block_ptr_for_number(network, block_number).await? {
+            Some(block_ptr) => Ok(r::Value::String(block_ptr.hash_hex())),
+            None => Ok(r::Value::Null),
         }
-
-        // The given network does not exist.
-        Ok(r::Value::Null)
     }
 
     async fn resolve_cached_ethereum_calls(
@@ -285,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 {
@@ -297,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,
@@ -324,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!(
@@ -364,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")
@@ -382,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) => {
@@ -406,7 +413,7 @@ impl<S: Store> IndexNodeResolver<S> {
         Ok(poi)
     }
 
-    fn resolve_public_proofs_of_indexing(
+    async fn resolve_public_proofs_of_indexing(
         &self,
         field: &a::Field,
     ) -> Result<r::Value, QueryExecutionError> {
@@ -421,44 +428,44 @@ impl<S: Store> IndexNodeResolver<S> {
             return Err(QueryExecutionError::TooExpensive);
         }
 
-        Ok(r::Value::List(
-            requests
-                .into_iter()
-                .map(|request| {
-                    match futures::executor::block_on(
-                        self.store.get_public_proof_of_indexing(
-                            &request.deployment,
-                            request.block_number,
-                        ),
-                    ) {
-                        Ok(Some(poi)) => (Some(poi), request),
-                        Ok(None) => (None, request),
-                        Err(e) => {
-                            error!(
-                                self.logger,
-                                "Failed to query public proof of indexing";
-                                "subgraph" => &request.deployment,
-                                "block" => format!("{}", request.block_number),
-                                "error" => format!("{:?}", e)
-                            );
-                            (None, request)
-                        }
-                    }
-                })
-                .map(|(poi_result, request)| PublicProofOfIndexingResult {
+        let mut public_poi_results = vec![];
+        for request in requests {
+            let (poi_result, request) = match self
+                .store
+                .get_public_proof_of_indexing(&request.deployment, request.block_number, self)
+                .await
+            {
+                Ok(Some(poi)) => (Some(poi), request),
+                Ok(None) => (None, request),
+                Err(e) => {
+                    error!(
+                        self.logger,
+                        "Failed to query public proof of indexing";
+                        "subgraph" => &request.deployment,
+                        "block" => format!("{}", request.block_number),
+                        "error" => format!("{:?}", e)
+                    );
+                    (None, request)
+                }
+            };
+
+            public_poi_results.push(
+                PublicProofOfIndexingResult {
                     deployment: request.deployment,
                     block: match poi_result {
                         Some((ref block, _)) => block.clone(),
                         None => PartialBlockPtr::from(request.block_number),
                     },
                     proof_of_indexing: poi_result.map(|(_, poi)| poi),
-                })
-                .map(IntoValue::into_value)
-                .collect(),
-        ))
+                }
+                .into_value(),
+            )
+        }
+
+        Ok(r::Value::List(public_poi_results))
     }
 
-    fn resolve_indexing_status_for_version(
+    async fn resolve_indexing_status_for_version(
         &self,
         field: &a::Field,
 
@@ -475,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()
@@ -487,6 +497,87 @@ impl<S: Store> IndexNodeResolver<S> {
             .unwrap_or(r::Value::Null))
     }
 
+    async fn validate_and_extract_features<C, SgStore>(
+        subgraph_store: &Arc<SgStore>,
+        unvalidated_subgraph_manifest: UnvalidatedSubgraphManifest<C>,
+    ) -> Result<DeploymentFeatures, QueryExecutionError>
+    where
+        C: Blockchain,
+        SgStore: SubgraphStore,
+    {
+        match unvalidated_subgraph_manifest
+            .validate(subgraph_store.clone(), false)
+            .await
+        {
+            Ok(subgraph_manifest) => Ok(subgraph_manifest.deployment_features()),
+            Err(_) => Err(QueryExecutionError::InvalidSubgraphManifest),
+        }
+    }
+
+    async fn get_features_from_ipfs(
+        &self,
+        deployment_hash: &DeploymentHash,
+    ) -> Result<DeploymentFeatures, QueryExecutionError> {
+        let raw_yaml: serde_yaml::Mapping = {
+            let file_bytes = self
+                .link_resolver
+                .cat(
+                    &LinkResolverContext::new(deployment_hash, &self.logger),
+                    &deployment_hash.to_ipfs_link(),
+                )
+                .await
+                .map_err(SubgraphManifestResolveError::ResolveError)?;
+
+            serde_yaml::from_slice(&file_bytes).map_err(SubgraphManifestResolveError::ParseError)?
+        };
+
+        let kind = BlockchainKind::from_manifest(&raw_yaml)
+            .map_err(SubgraphManifestResolveError::ResolveError)?;
+
+        let max_spec_version = ENV_VARS.max_spec_version.clone();
+
+        let result = match kind {
+            BlockchainKind::Ethereum => {
+                let unvalidated_subgraph_manifest =
+                    UnvalidatedSubgraphManifest::<graph_chain_ethereum::Chain>::resolve(
+                        deployment_hash.clone(),
+                        raw_yaml,
+                        &self.link_resolver,
+                        self.amp_client.cheap_clone(),
+                        &self.logger,
+                        max_spec_version,
+                    )
+                    .await?;
+
+                Self::validate_and_extract_features(
+                    &self.store.subgraph_store(),
+                    unvalidated_subgraph_manifest,
+                )
+                .await?
+            }
+            BlockchainKind::Near => {
+                let unvalidated_subgraph_manifest =
+                    UnvalidatedSubgraphManifest::<graph_chain_near::Chain>::resolve(
+                        deployment_hash.clone(),
+                        raw_yaml,
+                        &self.link_resolver,
+                        self.amp_client.cheap_clone(),
+                        &self.logger,
+                        max_spec_version,
+                    )
+                    .await?;
+
+                Self::validate_and_extract_features(
+                    &self.store.subgraph_store(),
+                    unvalidated_subgraph_manifest,
+                )
+                .await?
+            }
+        };
+
+        Ok(result)
+    }
+
     async fn resolve_subgraph_features(
         &self,
         field: &a::Field,
@@ -494,125 +585,35 @@ impl<S: Store> IndexNodeResolver<S> {
         // We can safely unwrap because the argument is non-nullable and has been validated.
         let subgraph_id = field.get_required::<String>("subgraphId").unwrap();
 
-        // TODO:
-        //
-        // An interesting optimization would involve trying to get the subgraph manifest from the
-        // SubgraphStore before hitting IPFS, but we must fix a dependency cycle between the `graph`
-        // and `server` crates first.
-        //
-        // 1. implement a new method in subgraph store to retrieve the SubgraphManifest of a given deployment id
-        // 2. try to fetch this subgraph from our SubgraphStore before hitting IPFS
-
         // Try to build a deployment hash with the input string
         let deployment_hash = DeploymentHash::new(subgraph_id).map_err(|invalid_qm_hash| {
             QueryExecutionError::SubgraphDeploymentIdError(invalid_qm_hash)
         })?;
 
-        let ValidationPostProcessResult {
-            features,
-            errors,
-            network,
-        } = {
-            let raw: serde_yaml::Mapping = {
-                let file_bytes = self
-                    .link_resolver
-                    .cat(&self.logger, &deployment_hash.to_ipfs_link())
-                    .await
-                    .map_err(SubgraphManifestResolveError::ResolveError)?;
-
-                serde_yaml::from_slice(&file_bytes)
-                    .map_err(SubgraphManifestResolveError::ParseError)?
-            };
-
-            let kind = BlockchainKind::from_manifest(&raw)
-                .map_err(SubgraphManifestResolveError::ResolveError)?;
-            match kind {
-                BlockchainKind::Ethereum => {
-                    let unvalidated_subgraph_manifest =
-                        UnvalidatedSubgraphManifest::<graph_chain_ethereum::Chain>::resolve(
-                            deployment_hash,
-                            raw,
-                            &self.link_resolver,
-                            &self.logger,
-                            ENV_VARS.max_spec_version.clone(),
-                        )
-                        .await?;
+        let subgraph_store = self.store.subgraph_store();
+        let features = match subgraph_store.subgraph_features(&deployment_hash).await? {
+            Some(features) => {
+                let mut deployment_features = features.clone();
+                let features = &mut deployment_features.features;
 
-                    validate_and_extract_features(
-                        &self.store.subgraph_store(),
-                        unvalidated_subgraph_manifest,
-                    )
-                    .await?
+                if deployment_features.has_declared_calls {
+                    features.push("declaredEthCalls".to_string());
                 }
-
-                BlockchainKind::Cosmos => {
-                    let unvalidated_subgraph_manifest =
-                        UnvalidatedSubgraphManifest::<graph_chain_cosmos::Chain>::resolve(
-                            deployment_hash,
-                            raw,
-                            &self.link_resolver,
-                            &self.logger,
-                            ENV_VARS.max_spec_version.clone(),
-                        )
-                        .await?;
-
-                    validate_and_extract_features(
-                        &self.store.subgraph_store(),
-                        unvalidated_subgraph_manifest,
-                    )
-                    .await?
+                if deployment_features.has_aggregations {
+                    features.push("aggregations".to_string());
                 }
-
-                BlockchainKind::Near => {
-                    let unvalidated_subgraph_manifest =
-                        UnvalidatedSubgraphManifest::<graph_chain_near::Chain>::resolve(
-                            deployment_hash,
-                            raw,
-                            &self.link_resolver,
-                            &self.logger,
-                            ENV_VARS.max_spec_version.clone(),
-                        )
-                        .await?;
-
-                    validate_and_extract_features(
-                        &self.store.subgraph_store(),
-                        unvalidated_subgraph_manifest,
-                    )
-                    .await?
+                if !deployment_features.immutable_entities.is_empty() {
+                    features.push("immutableEntities".to_string());
                 }
-
-                BlockchainKind::Arweave => {
-                    let unvalidated_subgraph_manifest =
-                        UnvalidatedSubgraphManifest::<graph_chain_arweave::Chain>::resolve(
-                            deployment_hash,
-                            raw,
-                            &self.link_resolver,
-                            &self.logger,
-                            ENV_VARS.max_spec_version.clone(),
-                        )
-                        .await?;
-
-                    validate_and_extract_features(
-                        &self.store.subgraph_store(),
-                        unvalidated_subgraph_manifest,
-                    )
-                    .await?
+                if deployment_features.has_bytes_as_ids {
+                    features.push("bytesAsIds".to_string());
                 }
-                // TODO(filipe): Kick this can down the road!
-                BlockchainKind::Substreams => unimplemented!(),
+                deployment_features
             }
+            None => self.get_features_from_ipfs(&deployment_hash).await?,
         };
 
-        // We then bulid a GraphqQL `Object` value that contains the feature detection and
-        // validation results and send it back as a response.
-        let response = [
-            ("features".to_string(), features),
-            ("errors".to_string(), errors),
-            ("network".to_string(), network),
-        ];
-        let response = Object::from_iter(response);
-
-        Ok(r::Value::Object(response))
+        Ok(features.into_value())
     }
 
     fn resolve_api_versions(&self, _field: &a::Field) -> Result<r::Value, QueryExecutionError> {
@@ -621,105 +622,93 @@ impl<S: Store> IndexNodeResolver<S> {
                 .iter()
                 .map(|version| {
                     r::Value::Object(Object::from_iter(vec![(
-                        "version".to_string(),
+                        "version".into(),
                         r::Value::String(version.to_string()),
                     )]))
                 })
                 .collect(),
         ))
     }
-}
 
-struct ValidationPostProcessResult {
-    features: r::Value,
-    errors: r::Value,
-    network: r::Value,
-}
+    fn version(&self) -> Result<r::Value, QueryExecutionError> {
+        Ok(VERSION.clone().into_value())
+    }
 
-async fn validate_and_extract_features<C, SgStore>(
-    subgraph_store: &Arc<SgStore>,
-    unvalidated_subgraph_manifest: UnvalidatedSubgraphManifest<C>,
-) -> Result<ValidationPostProcessResult, QueryExecutionError>
-where
-    C: Blockchain,
-    SgStore: SubgraphStore,
-{
-    // Validate the subgraph we've just obtained.
-    //
-    // Note that feature valiadation errors will be inside the error variant vector (because
-    // `validate` also validates subgraph features), so we must filter them out to build our
-    // response.
-    let subgraph_validation: Either<_, _> = match unvalidated_subgraph_manifest
-        .validate(subgraph_store.clone(), false)
-        .await
-    {
-        Ok(subgraph_manifest) => Either::Left(subgraph_manifest),
-        Err(validation_errors) => {
-            // We must ensure that all the errors are of the `FeatureValidationError`
-            // variant and that there is at least one error of that kind.
-            let feature_validation_errors: Vec<_> = validation_errors
-                .into_iter()
-                .filter(|error| {
-                    matches!(
-                        error,
-                        SubgraphManifestValidationError::FeatureValidationError(_)
-                    )
-                })
-                .collect();
-
-            if !feature_validation_errors.is_empty() {
-                Either::Right(feature_validation_errors)
-            } else {
-                // If other error variants are present or there are no feature validation
-                // errors, we must return early with an error.
-                //
-                // It might be useful to return a more thoughtful error, but that is not the
-                // purpose of this endpoint.
-                return Err(QueryExecutionError::InvalidSubgraphManifest);
-            }
-        }
-    };
+    async fn block_ptr_for_number(
+        &self,
+        network: String,
+        block_number: BlockNumber,
+    ) -> Result<Option<BlockPtr>, QueryExecutionError> {
+        macro_rules! try_resolve_for_chain {
+            ( $typ:path ) => {
+                let blockchain = self.blockchain_map.get::<$typ>(network.as_str().into()).ok();
 
-    // At this point, we have either:
-    // 1. A valid subgraph manifest with no errors.
-    // 2. No subgraph manifest and a set of feature validation errors.
-    //
-    // For this step we must collect whichever results we have into GraphQL `Value` types.
-    match subgraph_validation {
-        Either::Left(subgraph_manifest) => {
-            let features = r::Value::List(
-                detect_features(&subgraph_manifest)
-                    .map_err(|_| QueryExecutionError::InvalidSubgraphManifest)?
-                    .iter()
-                    .map(ToString::to_string)
-                    .map(r::Value::String)
-                    .collect(),
-            );
-            let errors = r::Value::List(vec![]);
-            let network = r::Value::String(subgraph_manifest.network_name());
+                if let Some(blockchain) = blockchain {
+                    debug!(
+                        self.logger,
+                        "Fetching block hash from number";
+                        "network" => &network,
+                        "block_number" => block_number,
+                    );
 
-            Ok(ValidationPostProcessResult {
-                features,
-                errors,
-                network,
-            })
+                let block_ptr_res = tokio::time::timeout(BLOCK_HASH_FROM_NUMBER_TIMEOUT, blockchain
+                    .block_pointer_from_number(&self.logger, block_number)
+                    .map_err(Error::from))
+                    .await
+                    .map_err(Error::from)
+                    .and_then(|x| x);
+
+                        if let Err(e) = block_ptr_res {
+                            warn!(
+                                self.logger,
+                                "Failed to fetch block hash from number";
+                                "network" => &network,
+                                "chain" => <$typ as Blockchain>::KIND.to_string(),
+                                "block_number" => block_number,
+                                "error" => e.to_string(),
+                            );
+                            return Ok(None);
+                        }
+
+                    let block_ptr = block_ptr_res.unwrap();
+                    return Ok(Some(block_ptr));
+                }
+            };
         }
-        Either::Right(errors) => {
-            let features = r::Value::List(vec![]);
-            let errors = r::Value::List(
-                errors
-                    .iter()
-                    .map(ToString::to_string)
-                    .map(r::Value::String)
-                    .collect(),
-            );
-            let network = r::Value::Null;
-            Ok(ValidationPostProcessResult {
-                features,
-                errors,
-                network,
-            })
+
+        // 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_near::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
+        // add a new `try_resolve!` macro invocation above for your new chain
+        // type.
+        match BlockchainKind::Ethereum {
+            // Note: we don't actually care about substreams here.
+            BlockchainKind::Ethereum | BlockchainKind::Near => (),
         }
+
+        // The given network does not exist.
+        Ok(None)
+    }
+}
+
+#[async_trait]
+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,
+        block_number: BlockNumber,
+    ) -> Result<Option<BlockPtr>, Error> {
+        self.block_ptr_for_number(network, block_number)
+            .map_err(Error::from)
+            .await
     }
 }
 
@@ -729,7 +718,7 @@ fn entity_changes_to_graphql(entity_changes: Vec<EntityOperation>) -> r::Value {
 
     // First, we isolate updates and deletions with the same entity type.
     let mut updates: BTreeMap<EntityType, Vec<Entity>> = BTreeMap::new();
-    let mut deletions: BTreeMap<EntityType, Vec<Word>> = BTreeMap::new();
+    let mut deletions: BTreeMap<EntityType, Vec<Id>> = BTreeMap::new();
 
     for change in entity_changes {
         match change {
@@ -750,7 +739,7 @@ fn entity_changes_to_graphql(entity_changes: Vec<EntityOperation>) -> r::Value {
     let mut deletions_graphql: Vec<r::Value> = Vec::with_capacity(deletions.len());
 
     for (entity_type, mut entities) in updates {
-        entities.sort_unstable_by_key(|e| e.id().unwrap_or("no-id".to_string()));
+        entities.sort_unstable_by_key(|e| e.id());
         updates_graphql.push(object! {
             type: entity_type.to_string(),
             entities:
@@ -760,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(),
                         )
                     })
@@ -784,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<tokio::sync::OwnedSemaphorePermit, 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,
@@ -813,7 +806,7 @@ impl<S: Store> Resolver for IndexNodeResolver<S> {
             scalar_type.name.as_str(),
         ) {
             ("Query", "proofOfIndexing", "Bytes") => self.resolve_proof_of_indexing(field),
-            ("Query", "blockData", "JSONObject") => self.resolve_block_data(field),
+            ("Query", "blockData", "JSONObject") => self.resolve_block_data(field).await,
             ("Query", "blockHashFromNumber", "Bytes") => {
                 self.resolve_block_hash_from_number(field).await
             }
@@ -836,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
@@ -847,7 +841,7 @@ impl<S: Store> Resolver for IndexNodeResolver<S> {
 
             // The top-level `publicProofsOfIndexing` field
             (None, "PublicProofOfIndexingResult", "publicProofsOfIndexing") => {
-                self.resolve_public_proofs_of_indexing(field)
+                self.resolve_public_proofs_of_indexing(field).await
             }
 
             // Resolve fields of `Object` values (e.g. the `chains` field of `ChainIndexingStatus`)
@@ -865,15 +859,16 @@ 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(),
 
             // Resolve fields of `Object` values (e.g. the `latestBlock` field of `EthereumBlock`)
             (value, _) => Ok(value.unwrap_or(r::Value::Null)),
diff --git a/server/index-node/src/schema.graphql b/server/index-node/src/schema.graphql
index e5216540189..10475d75a0d 100644
--- a/server/index-node/src/schema.graphql
+++ b/server/index-node/src/schema.graphql
@@ -40,6 +40,7 @@ type Query {
   entityChangesInBlock(subgraphId: String!, blockNumber: Int!): EntityChanges!
   blockData(network: String!, blockHash: Bytes!): JSONObject
   blockHashFromNumber(network: String!, blockNumber: Int!): Bytes
+  version: Version!
   cachedEthereumCalls(
     network: String!
     blockHash: Bytes!
@@ -47,6 +48,11 @@ type Query {
   apiVersions(subgraphId: String!): [ApiVersion!]!
 }
 
+type Version {
+  version: String!
+  commit: String!
+}
+
 type SubgraphIndexingStatus {
   subgraph: String!
   synced: Boolean!
@@ -64,7 +70,16 @@ type SubgraphIndexingStatus {
   nonFatalErrors: [SubgraphError!]!
   chains: [ChainIndexingStatus!]!
   entityCount: BigInt!
+
+  "null if deployment is not assigned to an indexing node"
   node: String
+  "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 {
@@ -136,8 +151,11 @@ type CachedEthereumCall {
 }
 
 type SubgraphFeatures {
+  apiVersion: String
+  specVersion: String!
   features: [Feature!]!
-  errors: [String!]!
+  dataSources: [String!]!
+  handlers: [String!]!
   network: String
 }
 
@@ -146,6 +164,10 @@ enum Feature {
   grafting
   fullTextSearch
   ipfsOnEthereumContracts
+  aggregations
+  declaredEthCalls
+  immutableEntities
+  bytesAsIds
 }
 
 input BlockInput {
@@ -187,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 bc3852770f1..957d0b4dd9f 100644
--- a/server/index-node/src/schema.rs
+++ b/server/index-node/src/schema.rs
@@ -1,11 +1,14 @@
-use graph::prelude::*;
+use graph::{
+    prelude::*,
+    schema::{ApiSchema, Schema},
+};
 
 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_api_schema(
+            ApiSchema::from_graphql_schema(
                 Schema::new(DeploymentHash::new("indexnode").unwrap(), document).unwrap(),
             )
             .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 3f013449fa9..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;
 
@@ -28,59 +35,41 @@ impl GraphQLMetrics for NoopGraphQLMetrics {
     fn observe_query_parsing(&self, _duration: Duration, _results: &QueryResults) {}
     fn observe_query_validation(&self, _duration: Duration, _id: &DeploymentHash) {}
     fn observe_query_validation_error(&self, _error_codes: Vec<&str>, _id: &DeploymentHash) {}
+    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,
         }
     }
 
@@ -89,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,
@@ -141,8 +135,6 @@ where
             Err(e) => return Ok(QueryResults::from(QueryResult::from(e))),
         };
 
-        let load_manager = self.graphql_runner.load_manager();
-
         // Run the query using the index node resolver
         let query_clone = query.cheap_clone();
         let logger = self.logger.cheap_clone();
@@ -151,18 +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,
-                load_manager,
+                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()
@@ -172,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();
@@ -245,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()
+            }
+        }
     }
 }
 
@@ -316,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
@@ -348,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,
@@ -374,16 +343,18 @@ impl ValidatedRequest {
 
 #[cfg(test)]
 mod tests {
-    use graph::{data::value::Object, prelude::*};
+    use graph::{
+        data::value::{Object, Word},
+        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]
@@ -416,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()
         );
     }
 
@@ -433,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);
     }
@@ -465,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![(String::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 c720905345e..401a457c57e 100644
--- a/server/json-rpc/src/lib.rs
+++ b/server/json-rpc/src/lib.rs
@@ -1,250 +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,
-            )
-            .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>,
-}
-
-#[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 1b171b5f8bc..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.3.0", 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 6aa08b62e04..96732c44c28 100644
--- a/store/postgres/Cargo.toml
+++ b/store/postgres/Cargo.toml
@@ -4,42 +4,45 @@ version.workspace = true
 edition.workspace = true
 
 [dependencies]
-async-trait = "0.1.50"
-blake3 = "1.3"
-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"
-fallible-iterator = "0.2.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" }
-graph-graphql = { path = "../../graphql" }
-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.45"
-postgres-openssl = "0.5.0"
-rand = "0.8.4"
-serde = "1.0"
-uuid = { version = "1.3.0", features = ["v4"] }
-stable-hash_legacy = { version = "0.3.3", package = "stable-hash" }
-diesel_derives = "1.4.1"
-anyhow = "1.0.69"
-git-testament = "0.2.4"
-itertools = "0.10.5"
-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.3.0"
+pretty_assertions = "1.4.1"
+sqlparser = { workspace = true }
+thiserror = { workspace = true }
+serde_yaml.workspace = true
+arrow = { workspace = true }
+parquet = { workspace = true }
 
 [dev-dependencies]
-futures = "0.3"
-clap = "3.2.23"
-graphql-parser = "0.4.0"
-test-store = { path = "../test-store" }
-hex-literal = "0.3"
-graph-chain-ethereum = { path = "../../chain/ethereum" }
-graph-mock = { path = "../../mock" }
+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 94daa9657f4..e7fde150fe9 100644
--- a/store/postgres/examples/layout.rs
+++ b/store/postgres/examples/layout.rs
@@ -1,21 +1,44 @@
 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;
 use std::{fs, sync::Arc};
 
-use graph::prelude::{DeploymentHash, Schema};
+use graph::prelude::DeploymentHash;
 use graph_store_postgres::{
     command_support::{Catalog, Column, ColumnType, Layout, Namespace},
     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 {
@@ -52,6 +75,8 @@ fn print_diesel_tables(layout: &Layout) {
             ColumnType::BigDecimal | ColumnType::BigInt => "Numeric",
             ColumnType::Bytes => "Binary",
             ColumnType::Int => "Integer",
+            ColumnType::Int8 => "Int8",
+            ColumnType::Timestamp => "Timestamp",
             ColumnType::String | ColumnType::Enum(_) | ColumnType::TSVector(_) => "Text",
         }
         .to_owned();
@@ -71,7 +96,9 @@ fn print_diesel_tables(layout: &Layout) {
             ColumnType::BigDecimal | ColumnType::BigInt => "BigDecimal",
             ColumnType::Bytes => "Vec<u8>",
             ColumnType::Int => "i32",
+            ColumnType::Int8 => "i64",
             ColumnType::String | ColumnType::Enum(_) | ColumnType::TSVector(_) => "String",
+            ColumnType::Timestamp => "Timestamp",
         }
         .to_owned();
 
@@ -122,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(
-        Schema::parse(&schema, subgraph.clone()),
+        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()),
@@ -153,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/2023-03-06-002954_add_pruning/down.sql b/store/postgres/migrations/2023-03-06-002954_add_pruning/down.sql
new file mode 100644
index 00000000000..270b6e55f27
--- /dev/null
+++ b/store/postgres/migrations/2023-03-06-002954_add_pruning/down.sql
@@ -0,0 +1,2 @@
+alter table subgraphs.subgraph_manifest
+      drop column history_blocks;
diff --git a/store/postgres/migrations/2023-03-06-002954_add_pruning/up.sql b/store/postgres/migrations/2023-03-06-002954_add_pruning/up.sql
new file mode 100644
index 00000000000..4e6b80254bc
--- /dev/null
+++ b/store/postgres/migrations/2023-03-06-002954_add_pruning/up.sql
@@ -0,0 +1,4 @@
+alter table subgraphs.subgraph_manifest
+  add column history_blocks int4
+             not null default 2147483647
+             check (history_blocks > 0);
diff --git a/store/postgres/migrations/2023-03-06-233030_add_last_pruned_block/down.sql b/store/postgres/migrations/2023-03-06-233030_add_last_pruned_block/down.sql
new file mode 100644
index 00000000000..25195963d0b
--- /dev/null
+++ b/store/postgres/migrations/2023-03-06-233030_add_last_pruned_block/down.sql
@@ -0,0 +1,2 @@
+alter table subgraphs.table_stats
+      drop column last_pruned_block;
diff --git a/store/postgres/migrations/2023-03-06-233030_add_last_pruned_block/up.sql b/store/postgres/migrations/2023-03-06-233030_add_last_pruned_block/up.sql
new file mode 100644
index 00000000000..3cb31928a1a
--- /dev/null
+++ b/store/postgres/migrations/2023-03-06-233030_add_last_pruned_block/up.sql
@@ -0,0 +1,2 @@
+alter table subgraphs.table_stats
+  add column last_pruned_block int4;
diff --git a/store/postgres/migrations/2023-03-28-004152_trigger_remap/down.sql b/store/postgres/migrations/2023-03-28-004152_trigger_remap/down.sql
new file mode 100644
index 00000000000..bba31ad7e3f
--- /dev/null
+++ b/store/postgres/migrations/2023-03-28-004152_trigger_remap/down.sql
@@ -0,0 +1,2 @@
+-- No schema changes, migration is only there to trigger remapping of
+-- foreign metadata
diff --git a/store/postgres/migrations/2023-03-28-004152_trigger_remap/up.sql b/store/postgres/migrations/2023-03-28-004152_trigger_remap/up.sql
new file mode 100644
index 00000000000..c88c945ef6e
--- /dev/null
+++ b/store/postgres/migrations/2023-03-28-004152_trigger_remap/up.sql
@@ -0,0 +1,3 @@
+-- No schema changes, migration is only there to trigger remapping of
+-- foreign metadata
+select 1;
diff --git a/store/postgres/migrations/2023-05-23-1715-update-subgraph-deployment-assignment/down.sql b/store/postgres/migrations/2023-05-23-1715-update-subgraph-deployment-assignment/down.sql
new file mode 100644
index 00000000000..0bb6211f8b3
--- /dev/null
+++ b/store/postgres/migrations/2023-05-23-1715-update-subgraph-deployment-assignment/down.sql
@@ -0,0 +1,4 @@
+-- Define the 'down' migration to remove the 'paused_at' and 'assigned_at' fields from 'subgraph_deployment_assignment' table
+ALTER TABLE subgraphs.subgraph_deployment_assignment
+DROP COLUMN paused_at,
+DROP COLUMN assigned_at;
\ No newline at end of file
diff --git a/store/postgres/migrations/2023-05-23-1715-update-subgraph-deployment-assignment/up.sql b/store/postgres/migrations/2023-05-23-1715-update-subgraph-deployment-assignment/up.sql
new file mode 100644
index 00000000000..ee76b78db8d
--- /dev/null
+++ b/store/postgres/migrations/2023-05-23-1715-update-subgraph-deployment-assignment/up.sql
@@ -0,0 +1,4 @@
+-- Define the 'up' migration to add the 'paused_at' and 'assigned_at' fields to 'subgraph_deployment_assignment' table
+ALTER TABLE subgraphs.subgraph_deployment_assignment
+ADD COLUMN paused_at TIMESTAMPTZ NULL,
+ADD COLUMN assigned_at TIMESTAMPTZ NULL;
\ No newline at end of file
diff --git a/store/postgres/migrations/2023-06-06-054643_create_subgraph_features_table/down.sql b/store/postgres/migrations/2023-06-06-054643_create_subgraph_features_table/down.sql
new file mode 100644
index 00000000000..b0db38c4fee
--- /dev/null
+++ b/store/postgres/migrations/2023-06-06-054643_create_subgraph_features_table/down.sql
@@ -0,0 +1 @@
+DROP TABLE subgraph_features;
\ No newline at end of file
diff --git a/store/postgres/migrations/2023-06-06-054643_create_subgraph_features_table/up.sql b/store/postgres/migrations/2023-06-06-054643_create_subgraph_features_table/up.sql
new file mode 100644
index 00000000000..06fde3c6e2c
--- /dev/null
+++ b/store/postgres/migrations/2023-06-06-054643_create_subgraph_features_table/up.sql
@@ -0,0 +1,8 @@
+-- Creates a new table subgraph_features
+create table if not exists subgraphs.subgraph_features (
+  id text primary key,
+  spec_version text not null,
+  api_version text null,
+  features text [] not null DEFAULT '{}',
+  data_sources text [] not null DEFAULT '{}'
+);
\ No newline at end of file
diff --git a/store/postgres/migrations/2023-06-16-135622_add_network_to_subgraph_features_table/down.sql b/store/postgres/migrations/2023-06-16-135622_add_network_to_subgraph_features_table/down.sql
new file mode 100644
index 00000000000..43a8973a1e7
--- /dev/null
+++ b/store/postgres/migrations/2023-06-16-135622_add_network_to_subgraph_features_table/down.sql
@@ -0,0 +1,2 @@
+ALTER TABLE subgraphs.subgraph_features
+DROP COLUMN network;
\ No newline at end of file
diff --git a/store/postgres/migrations/2023-06-16-135622_add_network_to_subgraph_features_table/up.sql b/store/postgres/migrations/2023-06-16-135622_add_network_to_subgraph_features_table/up.sql
new file mode 100644
index 00000000000..1f14a1e9262
--- /dev/null
+++ b/store/postgres/migrations/2023-06-16-135622_add_network_to_subgraph_features_table/up.sql
@@ -0,0 +1,3 @@
+TRUNCATE TABLE subgraphs.subgraph_features;
+ALTER TABLE subgraphs.subgraph_features
+ADD COLUMN network text not null;
\ No newline at end of file
diff --git a/store/postgres/migrations/2023-08-23-143628_add_handlers_to_subgraph_features/down.sql b/store/postgres/migrations/2023-08-23-143628_add_handlers_to_subgraph_features/down.sql
new file mode 100644
index 00000000000..4aad5cb0599
--- /dev/null
+++ b/store/postgres/migrations/2023-08-23-143628_add_handlers_to_subgraph_features/down.sql
@@ -0,0 +1,2 @@
+alter table subgraphs.subgraph_features
+drop column handlers;
diff --git a/store/postgres/migrations/2023-08-23-143628_add_handlers_to_subgraph_features/up.sql b/store/postgres/migrations/2023-08-23-143628_add_handlers_to_subgraph_features/up.sql
new file mode 100644
index 00000000000..5be75ae6c81
--- /dev/null
+++ b/store/postgres/migrations/2023-08-23-143628_add_handlers_to_subgraph_features/up.sql
@@ -0,0 +1,6 @@
+truncate table subgraphs.subgraph_features;
+
+alter table
+    subgraphs.subgraph_features
+add
+    column handlers text [] not null default '{}';
\ No newline at end of file
diff --git a/store/postgres/migrations/2023-12-15-182102_add_first_last_fn/down.sql b/store/postgres/migrations/2023-12-15-182102_add_first_last_fn/down.sql
new file mode 100644
index 00000000000..c7a5cd23bd3
--- /dev/null
+++ b/store/postgres/migrations/2023-12-15-182102_add_first_last_fn/down.sql
@@ -0,0 +1,4 @@
+drop aggregate public.last;
+drop aggregate public.first;
+drop function public.last_agg;
+drop function public.first_agg;
diff --git a/store/postgres/migrations/2023-12-15-182102_add_first_last_fn/up.sql b/store/postgres/migrations/2023-12-15-182102_add_first_last_fn/up.sql
new file mode 100644
index 00000000000..764f58203ed
--- /dev/null
+++ b/store/postgres/migrations/2023-12-15-182102_add_first_last_fn/up.sql
@@ -0,0 +1,27 @@
+-- From https://wiki.postgresql.org/wiki/First/last_(aggregate)
+
+-- Create a function that always returns the first non-NULL value:
+CREATE OR REPLACE FUNCTION public.first_agg (anyelement, anyelement)
+  RETURNS anyelement
+  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS
+'SELECT $1';
+
+-- Then wrap an aggregate around it:
+CREATE OR REPLACE AGGREGATE public.first (anyelement) (
+  SFUNC    = public.first_agg
+, STYPE    = anyelement
+, PARALLEL = safe
+);
+
+-- Create a function that always returns the last non-NULL value:
+CREATE OR REPLACE FUNCTION public.last_agg (anyelement, anyelement)
+  RETURNS anyelement
+  LANGUAGE sql IMMUTABLE STRICT PARALLEL SAFE AS
+'SELECT $2';
+
+-- Then wrap an aggregate around it:
+CREATE OR REPLACE AGGREGATE public.last (anyelement) (
+  SFUNC    = public.last_agg
+, STYPE    = anyelement
+, PARALLEL = safe
+);
diff --git a/store/postgres/migrations/2024-01-05-170000_ds_corruption_fix_up/down.sql b/store/postgres/migrations/2024-01-05-170000_ds_corruption_fix_up/down.sql
new file mode 100644
index 00000000000..7fa4091bf48
--- /dev/null
+++ b/store/postgres/migrations/2024-01-05-170000_ds_corruption_fix_up/down.sql
@@ -0,0 +1 @@
+-- "I can't go back to yesterday because I was a different person then."
diff --git a/store/postgres/migrations/2024-01-05-170000_ds_corruption_fix_up/up.sql b/store/postgres/migrations/2024-01-05-170000_ds_corruption_fix_up/up.sql
new file mode 100644
index 00000000000..8a08a1f3cf2
--- /dev/null
+++ b/store/postgres/migrations/2024-01-05-170000_ds_corruption_fix_up/up.sql
@@ -0,0 +1,96 @@
+/*
+
+
+This migration exists to fix up DB inconsistencies caused by a bug that was already fixed in this PR:
+https://github.com/graphprotocol/graph-node/pull/5083
+
+What it does is:
+1. select latest_ethereum_block_number from subgraphs.subgraph_deployment where deployment = '$Qm..';
+2. With that value, check if there are any data sources with a higher block:
+   select count(*) from sgd*.data_sources$ where lower(block_range) > $latest_block;
+3. If there are, then we need to intervene in that subgraph by removing all such data sources:
+   delete from sgd*.data_sources$ where lower(block_range) > $latest_block;
+4. It also unclamps any data sources that need unclamping (even though I don't think we ever clamp them).
+*/
+
+CREATE TEMPORARY TABLE temp_sgd_last_block (
+    deployment_schema text,
+    last_block_from_registry numeric,
+    is_ok boolean,
+    is_upper_limit_too_high boolean
+);
+
+-- collect the latest block number from SG deployment details
+INSERT INTO temp_sgd_last_block (deployment_schema, last_block_from_registry)
+SELECT d.name, latest_ethereum_block_number
+  FROM subgraphs.subgraph_deployment AS sd
+  JOIN deployment_schemas AS d ON sd.deployment = d.subgraph
+ WHERE d.name IN (SELECT relnamespace::regnamespace::name
+                    FROM pg_class
+                   WHERE relname LIKE 'data_sources$%' AND relkind = 'r'
+                 );
+
+-- check if the block numbers in the tables are OK
+-- if not, it can be
+-- - either the lower bound is higher than the last block
+-- - or the lower is fine, but the higher is past the last block
+DO $do$
+DECLARE
+    s text;
+BEGIN
+    FOR s IN SELECT deployment_schema FROM temp_sgd_last_block
+    LOOP
+        EXECUTE format($$
+        UPDATE temp_sgd_last_block
+           SET is_ok = NOT EXISTS (SELECT 1
+                                     FROM %1$I."data_sources$"
+                                    WHERE lower(block_range) > last_block_from_registry
+                                    LIMIT 1)
+                       AND NOT EXISTS (SELECT 1
+                                         FROM %1$I."data_sources$"
+                                        WHERE upper(block_range) > last_block_from_registry 
+                                          AND lower(block_range) <= last_block_from_registry
+                                        LIMIT 1),
+               is_upper_limit_too_high = EXISTS (SELECT 1
+                                                   FROM %1$I."data_sources$"
+                                                  WHERE upper(block_range) > last_block_from_registry 
+                                                    AND lower(block_range) <= last_block_from_registry
+                                                  LIMIT 1)
+         WHERE deployment_schema = '%1$s'  
+                $$, s);
+    END LOOP;
+END;
+$do$;
+
+SELECT * FROM temp_sgd_last_block WHERE NOT is_ok;
+
+DO $do$
+DECLARE
+    schema text;
+    last_block_from_registry integer;
+    cnt bigint;
+BEGIN
+    FOR schema, last_block_from_registry IN SELECT deployment_schema, t.last_block_from_registry
+                                           FROM temp_sgd_last_block AS t
+                                          WHERE NOT is_ok AND NOT is_upper_limit_too_high
+    LOOP
+        EXECUTE format($$SELECT count(9) FROM %I."data_sources$"$$, schema) INTO cnt;
+        RAISE NOTICE 'before DELETE % has % rows', schema, cnt;
+        EXECUTE format($$DELETE FROM %I."data_sources$" WHERE lower(block_range) > %s $$, schema, last_block_from_registry);
+        GET DIAGNOSTICS cnt = ROW_COUNT;
+        RAISE NOTICE 'DELETEd % rows from %', cnt, schema;
+    END LOOP;
+
+    FOR schema, last_block_from_registry IN SELECT deployment_schema, t.last_block_from_registry 
+                                           FROM temp_sgd_last_block AS t
+                                          WHERE NOT is_ok AND is_upper_limit_too_high
+    LOOP
+        EXECUTE format($$UPDATE %I."data_sources$" 
+                            SET block_range = range_merge(block_range, (%2$s,))
+                          WHERE upper(block_range) > %2$s 
+                                                    AND lower(block_range) <= %2$s $$, schema, last_block_from_registry);
+        GET DIAGNOSTICS cnt = ROW_COUNT;
+        RAISE NOTICE 'UPDATE affected % rows on %', cnt, schema;
+    END LOOP;
+END;
+$do$;
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 ead57b35532..6e9b9fbf0ac 100644
--- a/store/postgres/src/advisory_lock.rs
+++ b/store/postgres/src/advisory_lock.rs
@@ -6,77 +6,163 @@
 //! 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;
 
-/// 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)?;
+/// A locking scope for a particular deployment. We use different scopes for
+/// different purposes, and in each scope we use an advisory lock for each
+/// deployment.
+struct Scope {
+    id: i32,
+}
+
+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.
+    async fn try_lock(
+        &self,
+        conn: &mut AsyncPgConnection,
+        id: DeploymentId,
+    ) -> Result<bool, StoreError> {
+        #[derive(QueryableByName)]
+        struct Locked {
+            #[diesel(sql_type = Bool)]
+            locked: bool,
+        }
+
+        sql_query(format!(
+            "select pg_try_advisory_lock({}, {id}) as locked",
+            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
+    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)
+    }
 
-    Ok(())
+    /// Unlock the deployment in this scope with the given id.
+    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)
+    }
 }
 
-/// Release the migration lock.
-pub(crate) fn unlock_migration(conn: &PgConnection) -> Result<(), StoreError> {
-    sql_query("select pg_advisory_unlock(1)").execute(conn)?;
-    Ok(())
+const COPY: Scope = Scope { id: 1 };
+const WRITE: Scope = Scope { id: 2 };
+const PRUNE: Scope = Scope { id: 3 };
+
+/// 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)))
+            })
+    }
+
+    const LOCK: &str = "select pg_advisory_lock(1)";
+    const UNLOCK: &str = "select pg_advisory_unlock(1)";
+
+    execute(conn, LOCK, "failed to acquire migration lock").await?;
+    let res = f(conn).await;
+    execute(conn, UNLOCK, "failed to release migration lock").await?;
+    res
 }
 
-pub(crate) fn lock_copying(conn: &PgConnection, dst: &Site) -> Result<(), StoreError> {
-    sql_query(format!("select pg_advisory_lock(1, {})", dst.id))
-        .execute(conn)
-        .map(|_| ())
-        .map_err(StoreError::from)
+/// 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) async fn lock_copying(
+    conn: &mut AsyncPgConnection,
+    dst: &Site,
+) -> Result<(), StoreError> {
+    COPY.lock(conn, dst.id).await
 }
 
-pub(crate) fn unlock_copying(conn: &PgConnection, dst: &Site) -> Result<(), StoreError> {
-    sql_query(format!("select pg_advisory_unlock(1, {})", dst.id))
-        .execute(conn)
-        .map(|_| ())
-        .map_err(StoreError::from)
+/// Release the lock acquired with `lock_copying`.
+pub(crate) async fn unlock_copying(
+    conn: &mut AsyncPgConnection,
+    dst: &Site,
+) -> Result<(), StoreError> {
+    COPY.unlock(conn, dst.id).await
 }
 
-/// Try to lock deployment `site` with a session lock. 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,
+/// 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) async fn lock_deployment_session(
+    conn: &mut AsyncPgConnection,
     site: &Site,
 ) -> Result<bool, StoreError> {
-    #[derive(QueryableByName)]
-    struct Locked {
-        #[sql_type = "Bool"]
-        locked: bool,
-    }
-
-    sql_query(format!(
-        "select pg_try_advisory_lock(2, {}) as locked",
-        site.id
-    ))
-    .get_result::<Locked>(conn)
-    .map(|res| res.locked)
-    .map_err(StoreError::from)
+    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> {
-    sql_query(format!("select pg_advisory_unlock(2, {})", site.id))
-        .execute(conn)
-        .map(|_| ())
-        .map_err(StoreError::from)
+    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) async fn try_lock_pruning(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+) -> Result<bool, StoreError> {
+    PRUNE.try_lock(conn, site.id).await
+}
+
+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 a8d85e4c21c..d6877957dea 100644
--- a/store/postgres/src/block_range.rs
+++ b/store/postgres/src/block_range.rs
@@ -1,19 +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 std::io::Write;
+use graph::env::ENV_VARS;
 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";
@@ -30,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
@@ -50,19 +52,9 @@ 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>);
 
-// Doing this properly by implementing Clone for Bound is currently
-// a nightly-only feature, so we need to work around that
-fn clone_bound(bound: Bound<&BlockNumber>) -> Bound<BlockNumber> {
-    match bound {
-        Bound::Included(nr) => Bound::Included(*nr),
-        Bound::Excluded(nr) => Bound::Excluded(*nr),
-        Bound::Unbounded => Bound::Unbounded,
-    }
-}
-
 pub(crate) fn first_block_in_range(
     bound: &(Bound<BlockNumber>, Bound<BlockNumber>),
 ) -> Option<BlockNumber> {
@@ -87,28 +79,31 @@ pub(crate) fn block_number(block_ptr: &BlockPtr) -> BlockNumber {
 
 impl From<RangeFrom<BlockNumber>> for BlockRange {
     fn from(range: RangeFrom<BlockNumber>) -> BlockRange {
-        BlockRange(
-            clone_bound(range.start_bound()),
-            clone_bound(range.end_bound()),
-        )
+        BlockRange(range.start_bound().cloned(), range.end_bound().cloned())
+    }
+}
+
+impl From<std::ops::Range<BlockNumber>> for BlockRange {
+    fn from(range: std::ops::Range<BlockNumber>) -> BlockRange {
+        BlockRange(Bound::Included(range.start), Bound::Excluded(range.end))
     }
 }
 
 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(");
@@ -120,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(");
@@ -139,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 {
@@ -174,8 +251,15 @@ impl<'a> BlockRangeColumn<'a> {
 }
 
 impl<'a> BlockRangeColumn<'a> {
-    /// Output SQL that matches only rows whose block range contains `block`
-    pub fn contains(&self, out: &mut AstPass<Pg>) -> QueryResult<()> {
+    /// Output SQL that matches only rows whose block range contains `block`.
+    ///
+    /// `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<'b>(
+        &'b self,
+        out: &mut AstPass<'_, 'b, Pg>,
+        filters_by_id: bool,
+    ) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
 
         match self {
@@ -183,11 +267,16 @@ impl<'a> BlockRangeColumn<'a> {
                 self.name(out);
                 out.push_sql(" @> ");
                 out.push_bind_param::<Integer, _>(block)?;
-                if table.is_account_like && *block < BLOCK_NUMBER_MAX {
+
+                let should_use_brin = !filters_by_id || ENV_VARS.store.use_brin_for_all_query_types;
+                if table.is_account_like && *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
+                    // 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(");
                     out.push_identifier(BLOCK_RANGE_COLUMN)?;
                     out.push_sql("), 2147483647) > ");
@@ -214,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 {
@@ -235,18 +317,6 @@ impl<'a> BlockRangeColumn<'a> {
         }
     }
 
-    /// 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(&self, out: &mut AstPass<Pg>) -> QueryResult<()> {
-        match self {
-            BlockRangeColumn::Mutable { block, .. } => {
-                let block_range: BlockRange = (*block..).into();
-                out.push_bind_param::<Range<Integer>, _>(&block_range)
-            }
-            BlockRangeColumn::Immutable { block, .. } => out.push_bind_param::<Integer, _>(block),
-        }
-    }
-
     /// Output an expression that matches rows that are the latest version
     /// of their entity
     pub fn latest(&self, out: &mut AstPass<Pg>) {
@@ -262,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);
@@ -279,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(");
@@ -306,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 79bc4db40f7..4bc9b105c57 100644
--- a/store/postgres/src/block_store.rs
+++ b/store/postgres/src/block_store.rs
@@ -1,55 +1,55 @@
-use std::{
-    collections::{HashMap, HashSet},
-    iter::FromIterator,
-    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,
-    prelude::{error, warn, BlockNumber, BlockPtr, Logger, ENV_VARS},
-};
-use graph::{
-    constraint_violation,
-    prelude::{anyhow, CheapClone},
+    components::store::{BlockStore as BlockStoreTrait, QueryPermit},
+    derive::CheapClone,
+    prelude::{BlockNumber, BlockPtr, ENV_VARS, Logger, error, info, warn},
+    slog::o,
 };
 use graph::{
-    prelude::{tokio, StoreError},
-    util::timed_cache::TimedCache,
+    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, 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) {
@@ -81,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,
@@ -93,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)]
@@ -125,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)
@@ -138,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(())
     }
 }
@@ -171,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
@@ -179,10 +217,14 @@ 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,
     chain_head_cache: TimedCache<String, HashMap<String, BlockPtr>>,
+    chain_store_metrics: Arc<ChainStoreMetrics>,
 }
 
 impl BlockStore {
@@ -197,128 +239,72 @@ 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, Vec<ChainIdentifier>, Shard)>,
+        // (network, shard, cache_size)
+        shards: Vec<(String, Shard, BlockNumber)>,
         // shard -> pool
         pools: HashMap<Shard, ConnectionPool>,
         sender: Arc<NotificationSender>,
+        chain_store_metrics: Arc<ChainStoreMetrics>,
     ) -> Result<Self, StoreError> {
         // Cache chain head pointers for this long when returning
         // information from `chain_head_pointers`
         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,
-        };
-
-        fn reduce_idents(
-            chain_name: &str,
-            idents: Vec<ChainIdentifier>,
-        ) -> Result<Option<ChainIdentifier>, StoreError> {
-            let mut idents: HashSet<ChainIdentifier> = HashSet::from_iter(idents.into_iter());
-            match idents.len() {
-                0 => Ok(None),
-                1 => Ok(idents.drain().next()),
-                _ => Err(anyhow!(
-                    "conflicting network identifiers for chain {}: {:?}",
-                    chain_name,
-                    idents
-                )
-                .into()),
-            }
-        }
-
-        /// 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: &Option<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;
-            }
-            match ident {
-                Some(ident) => {
-                    if chain.net_version != ident.net_version {
-                        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
-                }
-                None => {
-                    warn!(logger, "Failed to get net version and genesis hash from provider. Assuming it has not changed");
-                    true
-                }
-            }
-        }
+            chain_store_metrics,
+        });
+        let block_store = Self { inner };
 
         // For each configured chain, add a chain store
-        for (chain_name, idents, shard) in chains {
-            let ident = reduce_idents(&chain_name, idents)?;
-            match (
-                existing_chains
-                    .iter()
-                    .find(|chain| chain.name == chain_name),
-                ident,
-            ) {
-                (Some(chain), ident) => {
-                    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, Some(ident)) => {
-                    let chain = primary::add_chain(
-                        block_store.mirror.primary(),
-                        &chain_name,
-                        &ident,
-                        &shard,
-                    )?;
-                    block_store.add_chain_store(&chain, ChainStatus::Ingestible, true)?;
-                }
-                (None, None) => {
-                    error!(
+        for (chain_name, shard, _cache_size) in chains {
+            if let Some(chain) = existing_chains
+                .iter()
+                .find(|chain| chain.name == chain_name)
+            {
+                if chain.shard != shard {
+                    warn!(
                         &block_store.logger,
-                        " the chain {} is new but we could not get a network identifier for it",
-                        chain_name
+                        "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?;
             };
         }
 
@@ -327,7 +313,6 @@ impl BlockStore {
         let configured_chains = block_store
             .stores
             .read()
-            .unwrap()
             .keys()
             .cloned()
             .collect::<Vec<_>>();
@@ -335,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) -> tokio::sync::OwnedSemaphorePermit {
-        self.mirror
-            .primary()
-            .query_permit()
-            .await
-            .expect("the primary is never disabled")
+    pub(crate) async fn query_permit_primary(&self) -> QueryPermit {
+        self.mirror.primary().query_permit().await
     }
 
-    fn add_chain_store(
+    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)
+    }
+
+    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(),
@@ -365,22 +381,34 @@ impl BlockStore {
             self.sender.clone(),
         );
         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)
     }
@@ -388,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
                 }
@@ -413,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;
         }
@@ -446,56 +476,188 @@ 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(())
     }
 
-    fn truncate_block_caches(&self) -> Result<(), StoreError> {
-        for store in self.stores.read().unwrap().values() {
-            store.truncate_block_cache()?
+    // 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.
+    //
+    // This is to prevent an issue where firehose stores "shallow" blocks (with null data) in `chainX.blocks`
+    // table but RPC provider requires those blocks to be full.
+    //
+    // - This issue only affects ethereum chains.
+    // - This issue only happens when switching providers from firehose back to RPC. it is gated by
+    // the presence of a cursor in the public.ethereum_networks table for a chain configured without firehose.
+    // - Only the shallow blocks close to HEAD need to be deleted, the older blocks don't need data.
+    // - Deleting everything or creating an index on empty data would cause too much performance
+    // hit on graph-node startup.
+    //
+    // Discussed here: https://github.com/graphprotocol/graph-node/pull/4790
+    pub async fn cleanup_ethereum_shallow_blocks(
+        &self,
+        eth_rpc_only_nets: Vec<String>,
+    ) -> Result<(), StoreError> {
+        for store in self.stores() {
+            if !eth_rpc_only_nets.contains(&store.chain) {
+                continue;
+            };
+
+            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).await?;
+            }
         }
         Ok(())
     }
 
-    pub fn update_db_version(&self) -> Result<(), StoreError> {
+    async fn truncate_block_caches(&self) -> Result<(), StoreError> {
+        for store in self.stores() {
+            store.truncate_block_cache().await?;
+        }
+        Ok(())
+    }
+
+    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 eb289dbf48d..0fbee8ff416 100644
--- a/store/postgres/src/catalog.rs
+++ b/store/postgres/src/catalog.rs
@@ -1,13 +1,15 @@
+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 graph::components::store::EntityType;
+use diesel::{OptionalExtension, insert_into};
+use diesel_async::{RunQueryDsl, SimpleAsyncConnection};
 use graph::components::store::VersionStats;
+use graph::prelude::BlockNumber;
+use graph::schema::EntityType;
 use itertools::Itertools;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::fmt::Write;
@@ -18,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,
 };
 
@@ -100,6 +104,7 @@ table! {
         deployment -> Integer,
         table_name -> Text,
         is_account_like -> Nullable<Bool>,
+        last_pruned_block -> Nullable<Integer>,
     }
 }
 
@@ -124,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;
 
@@ -135,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,
@@ -180,33 +186,51 @@ pub struct Catalog {
 
     /// Set of tables which have an explicit causality region column.
     pub(crate) entities_with_causality_region: BTreeSet<EntityType>,
+
+    /// Whether the database supports `int4_minmax_multi_ops` etc.
+    /// See the [Postgres docs](https://www.postgresql.org/docs/15/brin-builtin-opclasses.html)
+    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 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,
             text_columns,
             use_poi,
             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(
+    pub async fn for_creation(
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
         entities_with_causality_region: BTreeSet<EntityType>,
-    ) -> Self {
-        Catalog {
+    ) -> Result<Self, StoreError> {
+        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,
             text_columns: HashMap::default(),
             // DDL generation creates a POI table
@@ -215,7 +239,9 @@ impl Catalog {
             // see: attr-bytea-prefix
             use_bytea_prefix: true,
             entities_with_causality_region,
-        }
+            has_minmax_multi_ops,
+            pg_stats_has_range_bounds_histogram,
+        })
     }
 
     /// Make a catalog as if the given `schema` did not exist in the database
@@ -231,6 +257,8 @@ impl Catalog {
             use_poi: false,
             use_bytea_prefix: true,
             entities_with_causality_region,
+            has_minmax_multi_ops: false,
+            pg_stats_has_range_bounds_histogram: false,
         })
     }
 
@@ -242,10 +270,145 @@ impl Catalog {
             .map(|cols| cols.contains(column.as_str()))
             .unwrap_or(false)
     }
+
+    /// The operator classes to use for BRIN indexes. The first entry if the
+    /// operator class for `int4`, the second is for `int8`
+    pub fn minmax_ops(&self) -> (&str, &str) {
+        const MINMAX_OPS: (&str, &str) = ("int4_minmax_ops", "int8_minmax_ops");
+        const MINMAX_MULTI_OPS: (&str, &str) = ("int4_minmax_multi_ops", "int8_minmax_multi_ops");
+
+        if self.has_minmax_multi_ops {
+            MINMAX_MULTI_OPS
+        } else {
+            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 = "
@@ -255,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)
@@ -274,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,
     }
@@ -290,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())
@@ -319,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| {
@@ -343,67 +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<i64, 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).map_err(StoreError::from)
+    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()
@@ -418,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,
@@ -434,19 +632,20 @@ 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> {
-    let src_nsp = if src.shard == dst.shard {
-        "subgraphs".to_string()
-    } else {
-        ForeignServer::metadata_schema(&src.shard)
-    };
+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)
-         select $2 as deployment, ts.table_name, ts.is_account_like
+        "insert into subgraphs.table_stats(deployment, table_name, is_account_like, last_pruned_block)
+         select $2 as deployment, ts.table_name, ts.is_account_like, ts.last_pruned_block
            from {src_nsp}.table_stats ts
           where ts.deployment = $1",
         src_nsp = src_nsp
@@ -454,7 +653,30 @@ 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 async fn set_last_pruned_block(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+    table_name: &SqlName,
+    last_pruned_block: BlockNumber,
+) -> Result<(), StoreError> {
+    use table_stats as ts;
+
+    insert_into(ts::table)
+        .values((
+            ts::deployment.eq(site.id),
+            ts::table_name.eq(table_name.as_str()),
+            ts::last_pruned_block.eq(last_pruned_block),
+        ))
+        .on_conflict((ts::deployment, ts::table_name))
+        .do_update()
+        .set(ts::last_pruned_block.eq(last_pruned_block))
+        .execute(conn)
+        .await?;
+    Ok(())
 }
 
 pub(crate) mod table_schema {
@@ -469,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>,
     }
 
@@ -500,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> {
@@ -519,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())
@@ -529,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,
@@ -563,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 {}.{}",
@@ -574,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,
     }
 
@@ -600,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,
     }
 
@@ -631,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> {
@@ -645,73 +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, namespace: &Namespace) -> 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,
-    }
-
-    impl From<DbStats> for VersionStats {
-        fn from(s: DbStats) -> Self {
-            VersionStats {
-                entities: s.entities,
-                versions: s.versions,
-                tablename: s.tablename,
-                ratio: s.ratio,
-            }
-        }
-    }
-
-    // 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
-           from pg_namespace n, pg_class c, pg_stats s
-          where n.nspname = $1
-            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::<Text, _>(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>,
     }
 
@@ -719,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
@@ -729,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, \
@@ -740,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;
@@ -772,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));
 
@@ -786,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],
@@ -798,6 +1083,147 @@ 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(())
 }
+
+/// Return the names of all tables in the `namespace` that need to be
+/// analyzed. Whether a table needs to be analyzed is determined with the
+/// same logic that Postgres' [autovacuum
+/// daemon](https://www.postgresql.org/docs/current/routine-vacuuming.html#AUTOVACUUM)
+/// uses
+pub(crate) async fn needs_autoanalyze(
+    conn: &mut AsyncPgConnection,
+    namespace: &Namespace,
+) -> Result<Vec<SqlName>, StoreError> {
+    const QUERY: &str = "select relname \
+                           from pg_stat_user_tables \
+                          where (select setting::numeric from pg_settings where name = 'autovacuum_analyze_threshold') \
+                              + (select setting::numeric from pg_settings where name = 'autovacuum_analyze_scale_factor')*(n_live_tup + n_dead_tup) < n_mod_since_analyze
+                            and schemaname = $1";
+
+    #[derive(Queryable, QueryableByName)]
+    struct TableName {
+        #[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![]);
+
+    Ok(tables)
+}
+
+/// Check whether the database for `conn` supports the `minmax_multi_ops`
+/// introduced in Postgres 14
+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 {
+        #[diesel(sql_type = Bool)]
+        has_ops: bool,
+    }
+
+    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 e3b760ca790..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, 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, MetricsRegistry, 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()
@@ -55,7 +51,7 @@ pub struct BlockIngestorMetrics {
 }
 
 impl BlockIngestorMetrics {
-    pub fn new(registry: Arc<dyn MetricsRegistry>) -> Self {
+    pub fn new(registry: Arc<MetricsRegistry>) -> Self {
         Self {
             chain_head_number: registry
                 .new_gauge_vec(
@@ -96,7 +92,7 @@ pub(crate) struct ChainHeadUpdateSender {
 }
 
 impl ChainHeadUpdateListener {
-    pub fn new(logger: &Logger, registry: Arc<dyn MetricsRegistry>, postgres_url: String) -> Self {
+    pub fn new(logger: &Logger, registry: Arc<MetricsRegistry>, postgres_url: String) -> Self {
         let logger = logger.new(o!("component" => "ChainHeadUpdateListener"));
         let ingestor_metrics = Arc::new(BlockIngestorMetrics::new(registry.clone()));
         let counter = registry
@@ -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 c6f423a6dfa..3160afebfab 100644
--- a/store/postgres/src/chain_store.rs
+++ b/store/postgres/src/chain_store.rs
@@ -1,10 +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 graph::parking_lot::RwLock;
+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, 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},
@@ -12,21 +26,85 @@ 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)]
+struct JsonBlock {
+    ptr: BlockPtr,
+    parent_hash: BlockHash,
+    data: Option<json::Value>,
+}
+
+impl JsonBlock {
+    fn new(ptr: BlockPtr, parent_hash: BlockHash, data: Option<json::Value>) -> Self {
+        JsonBlock {
+            ptr,
+            parent_hash,
+            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
 mod public {
@@ -47,38 +125,51 @@ 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;
 
+    use super::JsonBlock;
+
     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;
@@ -120,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()
             ))
         }
     }
@@ -181,6 +272,10 @@ mod data {
             self.table.column::<BigInt, _>("number")
         }
 
+        fn parent_hash(&self) -> DynColumn<Bytea> {
+            self.table.column::<Bytea, _>("parent_hash")
+        }
+
         fn data(&self) -> DynColumn<Jsonb> {
             self.table.column::<Jsonb, _>("data")
         }
@@ -274,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 {
@@ -295,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())
         }
     }
 
@@ -311,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);
             }
@@ -332,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!(
                     "
@@ -346,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);
 
@@ -365,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(())
                 }
             }
@@ -380,49 +477,101 @@ 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) async fn cleanup_shallow_blocks(
+            &self,
+            conn: &mut AsyncPgConnection,
+            lowest_block: i32,
+        ) -> Result<(), StoreError> {
+            let table_name = match &self {
+                Storage::Shared => ETHEREUM_BLOCKS_TABLE_NAME,
+                Storage::Private(Schema { blocks, .. }) => &blocks.qname,
+            };
+            conn.batch_execute(&format!(
+                "delete from {} WHERE number >= {} AND data->'block'->'data' = 'null'::jsonb;",
+                table_name, lowest_block,
+            ))
+            .await?;
             Ok(())
         }
 
+        pub(super) async fn remove_cursor(
+            &self,
+            conn: &mut AsyncPgConnection,
+            chain: &str,
+        ) -> Result<Option<BlockNumber>, StoreError> {
+            use diesel::dsl::not;
+            use public::ethereum_networks as n;
+
+            let head_block_number = update(
+                n::table
+                    .filter(n::name.eq(chain))
+                    .filter(not(n::head_block_cursor.is_null())),
+            )
+            .set(n::head_block_cursor.eq(None as Option<String>))
+            .returning(n::head_block_number)
+            .get_result::<Option<i64>>(conn)
+            .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,
@@ -458,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, .. }) => {
@@ -489,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],
-        ) -> Result<Vec<json::Value>, Error> {
-            use diesel::dsl::any;
+            numbers: &[BlockNumber],
+        ) -> Result<Vec<JsonBlock>, StoreError> {
+            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
@@ -510,34 +708,120 @@ mod data {
             // Json object is what should be in 'block'
             //
             // see also 7736e440-4c6b-11ec-8c4d-b42e99f52061
-            match self {
+            let x = match self {
                 Storage::Shared => {
                     use public::ethereum_blocks as b;
 
                     b::table
-                        .select(sql::<Jsonb>("coalesce(data -> 'block', data)"))
+                        .select((
+                            b::hash,
+                            b::number,
+                            b::parent_hash,
+                            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)),
-                        ))))
-                        .load::<json::Value>(conn)
+                        .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(sql::<Jsonb>("coalesce(data -> 'block', data)"))
-                    .filter(
-                        blocks
-                            .hash()
-                            .eq(any(Vec::from_iter(hashes.iter().map(|h| h.as_slice())))),
-                    )
-                    .load::<json::Value>(conn),
-            }
-            .map_err(Into::into)
+                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
+                }
+            }?;
+            Ok(x.into_iter()
+                .map(|(hash, nr, parent, data)| {
+                    JsonBlock::new(BlockPtr::new(hash, nr as i32), parent, Some(data))
+                })
+                .collect())
+        }
+
+        /// 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) fn block_hashes_by_block_number(
+        pub(super) async fn block_hashes_by_block_number(
             &self,
-            conn: &PgConnection,
+            conn: &mut AsyncPgConnection,
             chain: &str,
             number: BlockNumber,
         ) -> Result<Vec<BlockHash>, Error> {
@@ -549,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,
@@ -585,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, .. }) => {
@@ -596,6 +882,7 @@ mod data {
                         .bind::<BigInt, _>(number)
                         .bind::<Bytea, _>(hash.as_slice())
                         .execute(conn)
+                        .await
                         .map_err(Error::from)
                 }
             }
@@ -603,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')";
 
@@ -616,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
@@ -690,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,
@@ -732,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")
                         }
@@ -753,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;
@@ -763,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 {
@@ -775,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()
@@ -785,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)),
                         )),
                     }
                 }
@@ -877,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> {
@@ -905,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, .. }) => {
@@ -915,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;
@@ -938,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, .. }) => {
@@ -950,34 +1441,36 @@ 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;
                     use public::eth_call_meta as meta;
 
                     cache::table
-                        .find(id.as_ref())
+                        .find::<&[u8]>(id.as_ref())
                         .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)
                 }
@@ -995,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();
@@ -1022,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
@@ -1041,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,
@@ -1057,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 {
@@ -1069,6 +1621,7 @@ mod data {
                             .filter(cache::block_number.le(to)),
                     )
                     .execute(conn)
+                    .await
                     .map_err(Error::from)?;
                     Ok(())
                 }
@@ -1084,41 +1637,226 @@ 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";
 
-                    update(meta::table.find(contract_address.as_ref()))
-                        .set(meta::accessed_at.eq(sql("CURRENT_DATE")))
-                        .execute(conn)
-                }
-                Storage::Private(Schema { call_meta, .. }) => {
-                    let query = format!(
-                        "update {} set accessed_at = CURRENT_DATE where contract_address = $1",
+            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!(
+                        "update {} set accessed_at = CURRENT_DATE where contract_address = $1",
                         call_meta.qname
                     );
                     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,
@@ -1137,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 {
@@ -1161,6 +1901,7 @@ mod data {
                             // branch to avoid unnecessary updates (not entirely
                             // trivial with diesel)
                             .execute(conn)
+                            .await
                     } else {
                         Ok(0)
                     }
@@ -1180,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
@@ -1191,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);
 
@@ -1208,6 +1951,7 @@ mod data {
                         sql_query(query)
                             .bind::<Bytea, _>(contract_address)
                             .execute(conn)
+                            .await
                     } else {
                         Ok(0)
                     }
@@ -1218,15 +1962,7 @@ mod data {
 
         #[cfg(debug_assertions)]
         // used by `super::set_chain` for test support
-        pub(super) fn set_chain(
-            &self,
-            conn: &PgConnection,
-            chain_name: &str,
-            genesis_hash: &str,
-            chain: Vec<&dyn Block>,
-        ) {
-            use public::ethereum_networks as n;
-
+        pub(super) async fn remove_chain(&self, conn: &mut AsyncPgConnection, chain_name: &str) {
             match self {
                 Storage::Shared => {
                     use public::eth_call_cache as c;
@@ -1235,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,
@@ -1251,30 +1988,18 @@ mod data {
                         let query = format!("delete from {}", qname);
                         sql_query(query)
                             .execute(conn)
+                            .await
                             .unwrap_or_else(|_| panic!("Failed to delete {}", qname));
                     }
                 }
             }
-
-            for block in &chain {
-                self.upsert_block(conn, chain_name, *block, true).unwrap();
-            }
-
-            diesel::update(n::table.filter(n::name.eq(chain_name)))
-                .set((
-                    n::genesis_block_hash.eq(genesis_hash),
-                    n::head_block_hash.eq::<Option<&str>>(None),
-                    n::head_block_number.eq::<Option<i64>>(None),
-                ))
-                .execute(conn)
-                .unwrap();
         }
 
         /// 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!(
                 "
@@ -1300,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
@@ -1322,12 +2053,278 @@ from (
     }
 }
 
+#[derive(Debug)]
+pub struct ChainStoreMetrics {
+    chain_head_cache_size: Box<GaugeVec>,
+    chain_head_cache_oldest_block_num: Box<GaugeVec>,
+    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 {
+    pub fn new(registry: Arc<MetricsRegistry>) -> Self {
+        let chain_head_cache_size = registry
+            .new_gauge_vec(
+                "chain_head_cache_num_blocks",
+                "Number of blocks in the chain head cache",
+                vec!["network".to_string()],
+            )
+            .expect("Can't register the gauge");
+        let chain_head_cache_oldest_block_num = registry
+            .new_gauge_vec(
+                "chain_head_cache_oldest_block",
+                "Block number of the oldest block currently present in the chain head cache",
+                vec!["network".to_string()],
+            )
+            .expect("Can't register the gauge");
+        let chain_head_cache_latest_block_num = registry
+            .new_gauge_vec(
+                "chain_head_cache_latest_block",
+                "Block number of the latest block currently present in the chain head cache",
+                vec!["network".to_string()],
+            )
+            .expect("Can't register the gauge");
+
+        let chain_head_cache_hits = registry
+            .new_counter_vec(
+                "chain_head_cache_hits",
+                "Number of times the chain head cache was hit",
+                vec!["network".to_string()],
+            )
+            .expect("Can't register the counter");
+        let chain_head_cache_misses = registry
+            .new_counter_vec(
+                "chain_head_cache_misses",
+                "Number of times the chain head cache was missed",
+                vec!["network".to_string()],
+            )
+            .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,
+        }
+    }
+
+    pub fn add_block(&self, network: &str) {
+        self.chain_head_cache_size
+            .with_label_values(&[network])
+            .inc();
+    }
+
+    pub fn remove_block(&self, network: &str) {
+        self.chain_head_cache_size
+            .with_label_values(&[network])
+            .dec();
+    }
+
+    pub fn record_cache_hit(&self, network: &str) {
+        self.chain_head_cache_hits
+            .get_metric_with_label_values(&[network])
+            .unwrap()
+            .inc();
+    }
+
+    pub fn record_cache_miss(&self, network: &str) {
+        self.chain_head_cache_misses
+            .get_metric_with_label_values(&[network])
+            .unwrap()
+            .inc();
+    }
+
+    pub fn record_hit_and_miss(&self, network: &str, hits: usize, misses: usize) {
+        self.chain_head_cache_hits
+            .get_metric_with_label_values(&[network])
+            .unwrap()
+            .inc_by(hits as f64);
+        self.chain_head_cache_misses
+            .get_metric_with_label_values(&[network])
+            .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);
+    }
+}
+
+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 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,
-    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
@@ -1336,42 +2333,93 @@ pub struct ChainStore {
     // with the database and to correctly implement invalidation. So, a
     // conservative approach is acceptable.
     recent_blocks_cache: RecentBlocksCache,
+    // 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 {
     pub(crate) fn new(
+        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.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,
-            recent_blocks_cache: RecentBlocksCache::new(recent_blocks_cache_capacity),
+            recent_blocks_cache,
+            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),
@@ -1383,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)),
@@ -1423,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,
@@ -1445,177 +2512,284 @@ 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`
     #[cfg(debug_assertions)]
-    pub fn set_chain(&self, genesis_hash: &str, chain: Vec<&dyn Block>) {
-        let conn = self.pool.get().expect("can get a database connection");
+    pub async fn set_chain(
+        &self,
+        genesis_hash: &str,
+        chain: Vec<Arc<dyn Block>>,
+    ) -> Vec<(BlockPtr, BlockHash)> {
+        let mut conn = self
+            .pool
+            .get()
+            .await
+            .expect("can get a database connection");
 
-        self.storage
-            .set_chain(&conn, &self.chain, genesis_hash, 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((
+                n::genesis_block_hash.eq(genesis_hash),
+                n::head_block_hash.eq::<Option<&str>>(None),
+                n::head_block_number.eq::<Option<i64>>(None),
+            ))
+            .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 truncate_block_cache(&self) -> Result<(), StoreError> {
-        let conn = self.get_conn()?;
-        self.storage.truncate_block_cache(&conn)?;
+    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(())
     }
-}
 
-#[async_trait]
-impl ChainStoreTrait for ChainStore {
-    fn genesis_block_ptr(&self) -> Result<BlockPtr, Error> {
-        Ok(self.genesis_block_ptr.clone())
+    // remove_cursor delete the chain_store cursor and return true if it was present
+    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
     }
 
-    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() {
-            self.recent_blocks_cache
-                .insert_block(block.ptr(), block.data().ok(), parent_hash);
-        }
+    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(())
+    }
 
-        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)
+    async fn blocks_from_store(
+        self: &Arc<Self>,
+        hashes: Vec<BlockHash>,
+    ) -> Result<Vec<JsonBlock>, StoreError> {
+        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())
     }
 
-    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)?;
+    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 mut block_map = BTreeMap::new();
+
+        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))),
-                    };
+        let genesis_block_ptr = self.genesis_block_ptr().await?.hash.as_b256();
 
-                    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 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));
+        }
 
-    async fn cached_head_ptr(self: Arc<Self>) -> Result<Option<BlockPtr>, Error> {
-        match self.recent_blocks_cache.chain_head_ptr() {
-            Some(head) => Ok(Some(head)),
-            None => self.chain_head_ptr().await,
+        // 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)
             })
@@ -1629,50 +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)?;
+        self.chain_head_update_sender.send(&hash, number).await?;
 
-        pool.with_conn(move |conn, _| {
-            conn.transaction(|| -> Result<(), StoreError> {
-                storage
-                    .upsert_block(conn, &network, block.as_ref(), true)
-                    .map_err(CancelableError::from)?;
+        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)?;
+            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(())
     }
 
-    fn blocks(&self, hashes: &[BlockHash]) -> Result<Vec<json::Value>, Error> {
-        let conn = self.get_conn()?;
-        self.storage.blocks(&conn, &self.chain, hashes)
+    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.and_then(CachedBlock::from_json))
+                .collect();
+            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 {
+            Vec::new()
+        };
+
+        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",
@@ -1680,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_block(&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> {
@@ -1708,7 +3141,7 @@ impl ChainStoreTrait for ChainStore {
 
         #[derive(QueryableByName)]
         struct MinBlock {
-            #[sql_type = "Integer"]
+            #[diesel(sql_type = Integer)]
             block: i32,
         }
 
@@ -1731,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,
@@ -1739,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()
     }
 }
 
@@ -1825,49 +3385,64 @@ mod recent_blocks_cache {
     use super::*;
     use std::collections::BTreeMap;
 
-    struct CachedBlock {
-        ptr: BlockPtr,
-        data: Option<json::Value>,
-        parent_hash: BlockHash,
-    }
-
     struct Inner {
-        // Note: we only ever store blocks in this cache that have a continuous
-        // line of ancestry between each other. Line of ancestry is verified by
-        // comparing parent hashes. Because of NEAR, however, we cannot
-        // guarantee that there are no block number gaps, as block numbers are
-        // not strictly continuous:
-        //   #14 (Hash ABC1, Parent XX) -> #17 (Hash EBD2, Parent ABC1)
-        blocks: BTreeMap<BlockNumber, CachedBlock>,
+        network: String,
+        metrics: Arc<ChainStoreMetrics>,
+        // A list of blocks by block number. The list has at most `capacity`
+        // 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, CacheBlock>,
         // We only store these many blocks.
         capacity: usize,
     }
 
     impl Inner {
-        fn get_block(
+        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: &BlockPtr,
+            child_ptr: &BlockPtr,
             offset: BlockNumber,
-        ) -> Option<(&BlockPtr, Option<&json::Value>)> {
-            // Before we can go find the ancestor, we need to make sure that
-            // we're looking for the ancestor of the right block, i.e. check if
-            // the hash (and number) of the child matches.
-            let child_is_cached = &self.blocks.get(&child.number)?.ptr == child;
-
-            if child_is_cached {
-                let ancestor_block_number = child.number - offset;
-                let block = self.blocks.get(&ancestor_block_number)?;
-                Some((&block.ptr, block.data.as_ref()))
-            } else {
-                None
+        ) -> Option<(&BlockPtr, Option<&CachedBlock>)> {
+            let child = self.blocks.get(&child_ptr.number)?;
+            if &child.ptr != child_ptr {
+                return None;
             }
+            let ancestor_block_number = child.ptr.number - offset;
+            let mut child = child;
+            for number in (ancestor_block_number..child_ptr.number).rev() {
+                let parent = self.blocks.get(&number)?;
+                if child.parent_hash != parent.ptr.hash {
+                    return None;
+                }
+                child = parent;
+            }
+            Some((&child.ptr, child.data.as_ref()))
         }
 
         fn chain_head(&self) -> Option<&BlockPtr> {
             self.blocks.last_key_value().map(|b| &b.1.ptr)
         }
 
-        fn earliest_block(&self) -> Option<&CachedBlock> {
+        fn earliest_block(&self) -> Option<&CacheBlock> {
             self.blocks.first_key_value().map(|b| b.1)
         }
 
@@ -1877,52 +3452,28 @@ mod recent_blocks_cache {
             }
         }
 
-        fn insert_block(
-            &mut self,
-            ptr: BlockPtr,
-            data: Option<json::Value>,
-            parent_hash: BlockHash,
-        ) {
-            fn is_parent_of(parent: &BlockPtr, child: &CachedBlock) -> bool {
-                child.parent_hash == parent.hash
-            }
+        fn update_write_metrics(&self) {
+            self.metrics
+                .chain_head_cache_size
+                .get_metric_with_label_values(&[&self.network])
+                .unwrap()
+                .set(self.blocks.len() as f64);
 
-            let block = CachedBlock {
-                ptr,
-                data,
-                parent_hash,
-            };
+            self.metrics
+                .chain_head_cache_oldest_block_num
+                .get_metric_with_label_values(&[&self.network])
+                .unwrap()
+                .set(self.earliest_block().map(|b| b.ptr.number).unwrap_or(0) as f64);
 
-            let Some(chain_head) = self.chain_head() else {
-                // We don't have anything in the cache, so we're free to store
-                // everything we want.
-                self.blocks.insert(block.ptr.number, block);
-                return;
-            };
-
-            if is_parent_of(chain_head, &block) {
-                // We have a new chain head that is a direct child of our
-                // previous chain head, so we get to keep all items in the
-                // cache.
-                self.blocks.insert(block.ptr.number, block);
-            } else if block.ptr.number > chain_head.number {
-                // We have a new chain head, but it's not a direct child of
-                // our previous chain head. This means that we must
-                // invalidate all the items in the cache before inserting
-                // this block.
-                self.blocks.clear();
-                self.blocks.insert(block.ptr.number, block);
-            } else {
-                // Unwrap: we have checked already that the cache is not empty,
-                // at the beginning of this function body.
-                let earliest_block = self.earliest_block().unwrap();
-                // Let's check if this is the parent of the earliest block in the
-                // cache.
-                if is_parent_of(&block.ptr, earliest_block) {
-                    self.blocks.insert(block.ptr.number, block);
-                }
-            }
+            self.metrics
+                .chain_head_cache_latest_block_num
+                .get_metric_with_label_values(&[&self.network])
+                .unwrap()
+                .set(self.chain_head().map(|b| b.number).unwrap_or(0) as f64);
+        }
 
+        fn insert_block(&mut self, block: CacheBlock) {
+            self.blocks.insert(block.ptr.number, block);
             self.evict_if_necessary();
         }
     }
@@ -1936,46 +3487,122 @@ mod recent_blocks_cache {
     }
 
     impl RecentBlocksCache {
-        pub fn new(capacity: usize) -> Self {
+        pub fn new(capacity: usize, network: String, metrics: Arc<ChainStoreMetrics>) -> Self {
             RecentBlocksCache {
                 inner: RwLock::new(Inner {
+                    network,
+                    metrics,
                     blocks: BTreeMap::new(),
                     capacity,
                 }),
             }
         }
 
-        pub fn chain_head_ptr(&self) -> Option<BlockPtr> {
+        pub fn register_hit(&self) {
             let inner = self.inner.read();
-            inner.chain_head().cloned()
+            inner.metrics.record_cache_hit(&inner.network);
         }
 
         pub fn clear(&self) {
-            self.inner.write().blocks.clear()
+            self.inner.write().blocks.clear();
+            self.inner.read().update_write_metrics();
         }
 
-        pub fn get_block(
+        pub fn get_ancestor(
             &self,
             child: &BlockPtr,
             offset: BlockNumber,
-        ) -> Option<(BlockPtr, Option<json::Value>)> {
-            self.inner
+        ) -> Option<(BlockPtr, Option<CachedBlock>)> {
+            let block_opt = self
+                .inner
                 .read()
-                .get_block(child, offset)
-                .map(|b| (b.0.clone(), b.1.cloned()))
+                .get_ancestor(child, offset)
+                .map(|b| (b.0.clone(), b.1.cloned()));
+
+            let inner = self.inner.read();
+            if block_opt.is_some() {
+                inner.metrics.record_cache_hit(&inner.network);
+            } else {
+                inner.metrics.record_cache_miss(&inner.network);
+            }
+
+            block_opt
+        }
+
+        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()
+                .filter_map(|hash| inner.get_block_by_hash(hash))
+                .map(|(ptr, value)| (ptr.clone(), value.clone()))
+                .collect();
+            inner.metrics.record_hit_and_miss(
+                &inner.network,
+                blocks.len(),
+                hashes.len() - blocks.len(),
+            );
+            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 fn insert_block(
-            &self,
-            ptr: BlockPtr,
-            data: Option<json::Value>,
-            parent_hash: BlockHash,
-        ) {
-            self.inner.write().insert_block(ptr, data, parent_hash)
+        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
+                .read()
+                .blocks
+                .values()
+                .map(|block| (block.ptr.clone(), block.parent_hash.clone()))
+                .collect()
         }
     }
 }
@@ -2002,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 95890fac9d7..00000000000
--- a/store/postgres/src/connection_pool.rs
+++ /dev/null
@@ -1,1222 +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::constraint_violation;
-use graph::prelude::tokio;
-use graph::prelude::tokio::time::Instant;
-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,
-        MetricsRegistry, 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`
-    pub fn metadata_schema(shard: &Shard) -> String {
-        format!("{}_subgraphs", Self::name(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",
-        ] {
-            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<dyn 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() && !ENV_VARS.store.connection_try_always {
-            // 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. `TRY_ALWAYS` allows users to force us to try
-            // regardless.
-            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<tokio::sync::OwnedSemaphorePermit, StoreError> {
-        let pool = match &*self.inner.lock(&self.logger) {
-            PoolState::Created(pool, _) | PoolState::Ready(pool) => pool.clone(),
-            PoolState::Disabled => {
-                return Err(StoreError::DatabaseDisabled);
-            }
-        };
-        Ok(pool.query_permit().await)
-    }
-
-    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("no connection to the server")
-            || 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<dyn 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<dyn 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(|had_migrations| {
-                if had_migrations {
-                    coord.propagate_schema_change(&self.shard)
-                } else {
-                    Ok(())
-                }
-            });
-        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");
-
-/// 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<bool, 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 had_migrations = catalog::migration_count(conn)? != old_count;
-
-    // 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);
-        }
-    }
-
-    if 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(had_migrations)
-}
-
-/// 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<dyn 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`
-    fn propagate_schema_change(&self, shard: &Shard) -> Result<(), StoreError> {
-        let server = self
-            .servers
-            .iter()
-            .find(|server| &server.shard == shard)
-            .ok_or_else(|| constraint_violation!("unknown shard {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()
-    }
-}
diff --git a/store/postgres/src/copy.rs b/store/postgres/src/copy.rs
index 7399aeeedb8..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::{
-    components::store::EntityType,
-    constraint_violation,
-    prelude::{info, o, warn, BlockNumber, BlockPtr, Logger, StoreError, ENV_VARS},
+    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 = EntityType::new(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,102 +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
+            .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: 0,
+            current_vid,
             target_vid,
+            cancelled: AtomicBool::new(false),
         }
     }
 
@@ -638,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
@@ -648,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) {
@@ -673,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
@@ -680,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 {
@@ -695,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>,
@@ -707,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
@@ -715,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,
@@ -733,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)
@@ -815,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
@@ -823,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
@@ -836,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 d63f3bab71b..76cde305bcb 100644
--- a/store/postgres/src/deployment.rs
+++ b/store/postgres/src/deployment.rs
@@ -1,42 +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 graph::{blockchain::block_stream::FirehoseCursor, data::subgraph::schema::SubgraphError};
+use diesel_async::{RunQueryDsl, SimpleAsyncConnection};
+use graph::prelude::alloy::primitives::B256;
 use graph::{
-    components::store::EntityType,
-    prelude::{
-        anyhow, bigdecimal::ToPrimitive, hex, web3::types::H256, BigDecimal, BlockNumber, BlockPtr,
-        DeploymentHash, DeploymentState, Schema, StoreError,
-    },
+    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::{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,
@@ -53,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,
@@ -83,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}")),
         }
     }
 }
@@ -105,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",
@@ -113,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()),
@@ -122,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,
     }
 }
 
@@ -179,6 +207,9 @@ table! {
         // Names stored as present in the schema, not in snake case.
         entities_with_causality_region -> Array<Text>,
         on_sync -> Nullable<Text>,
+        // How many blocks of history to keep, defaults to `i32::max` for
+        // unlimited history
+        history_blocks -> Integer,
     }
 }
 
@@ -194,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))
     };
@@ -229,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 `{}`",
@@ -249,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(|_| {
@@ -291,158 +328,233 @@ pub fn debug_fork(
     }
 }
 
-pub fn schema(conn: &PgConnection, site: &Site) -> Result<(Schema, 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)?;
-    Schema::parse(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 fn manifest_info(
-    conn: &PgConnection,
+pub struct ManifestInfo {
+    pub description: Option<String>,
+    pub repository: Option<String>,
+    pub spec_version: String,
+    pub instrument: bool,
+}
+
+impl ManifestInfo {
+    pub async fn load(
+        conn: &mut AsyncPgConnection,
+        site: &Site,
+    ) -> Result<ManifestInfo, StoreError> {
+        use subgraph_manifest as sm;
+        let (description, repository, spec_version, features): (
+            Option<String>,
+            Option<String>,
+            String,
+            Vec<String>,
+        ) = sm::table
+            .select((
+                sm::description,
+                sm::repository,
+                sm::spec_version,
+                sm::features,
+            ))
+            .filter(sm::id.eq(site.id))
+            .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
+        // cause any headaches
+        let instrument = features.iter().any(|s| s == "instrument");
+
+        Ok(ManifestInfo {
+            description,
+            repository,
+            spec_version,
+            instrument,
+        })
+    }
+}
+
+// Return how many blocks of history this subgraph should keep
+pub async fn history_blocks(
+    conn: &mut AsyncPgConnection,
     site: &Site,
-) -> Result<(Schema, Option<String>, Option<String>, String), StoreError> {
+) -> Result<BlockNumber, StoreError> {
     use subgraph_manifest as sm;
-    let (s, description, repository, spec_version): (
-        String,
-        Option<String>,
-        Option<String>,
-        String,
-    ) = sm::table
-        .select((
-            sm::schema,
-            sm::description,
-            sm::repository,
-            sm::spec_version,
-        ))
+    sm::table
+        .select(sm::history_blocks)
         .filter(sm::id.eq(site.id))
-        .first(conn)?;
-    Schema::parse(s.as_str(), site.deployment.clone())
-        .map_err(StoreError::Unknown)
-        .map(|schema| (schema, description, repository, spec_version))
+        .first::<BlockNumber>(conn)
+        .await
+        .map_err(StoreError::from)
 }
 
-#[allow(dead_code)]
-pub fn features(conn: &PgConnection, site: &Site) -> Result<BTreeSet<SubgraphFeature>, StoreError> {
+pub async fn set_history_blocks(
+    conn: &mut AsyncPgConnection,
+    site: &Site,
+    history_blocks: BlockNumber,
+) -> Result<(), 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()
+    update(sm::table.filter(sm::id.eq(site.id)))
+        .set(sm::history_blocks.eq(history_blocks))
+        .execute(conn)
+        .await
+        .map(|_| ())
+        .map_err(StoreError::from)
 }
 
-/// 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,
-    full_count_query: &str,
     count: i32,
-) -> Result<(), StoreError> {
-    use crate::diesel::BoolExpressionMethods;
-    use subgraph_deployment as d;
+) -> Result<BlockNumber, StoreError> {
+    use deployment as d;
+    use head as h;
 
-    // Work around a Diesel issue with serializing BigDecimals to numeric
-    let number = format!("{}::numeric", ptr.number);
+    let count_sql = entity_count_sql(count);
 
-    let count_sql = if count == 0 {
-        // This amounts to a noop - the entity count does not change
-        "entity_count".to_string()
-    } else {
-        entity_count_sql(full_count_query, count)
-    };
+    // 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,
+        ));
+    }
 
-    let row_count = 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),
-    ))
-    .execute(conn)
-    .map_err(StoreError::from)?;
+    reset_reorg_count(conn, site).await?;
 
-    match row_count {
+    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(()),
+        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 {
@@ -451,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
             )
@@ -549,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 {
@@ -571,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,
@@ -584,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((
             _,
@@ -618,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,
@@ -632,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, _>(
@@ -702,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),
     };
 
@@ -720,26 +931,49 @@ 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))?;
+    update_deployment_status(conn, id, SubgraphHealth::Failed, Some(error_id), None).await?;
+
+    Ok(())
+}
+
+pub async fn update_non_fatal_errors(
+    conn: &mut AsyncPgConnection,
+    deployment_id: &DeploymentHash,
+    health: SubgraphHealth,
+    non_fatal_errors: Option<&[SubgraphError]>,
+) -> Result<(), StoreError> {
+    let error_ids = non_fatal_errors.map(|errors| {
+        errors
+            .iter()
+            .map(|error| {
+                hex::encode(stable_hash_legacy::utils::stable_hash::<SetHasher, _>(
+                    error,
+                ))
+            })
+            .collect::<Vec<_>>()
+    });
+
+    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> {
@@ -748,172 +982,219 @@ 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_default()),
         ))
         .execute(conn)
+        .await
         .map(|_| ())
         .map_err(StoreError::from)
 }
 
-/// Insert the errors and check if the subgraph needs to be set as unhealthy.
-pub(crate) fn insert_subgraph_errors(
-    conn: &PgConnection,
+/// Insert the errors and check if the subgraph needs to be set as
+/// 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) async fn insert_subgraph_errors(
+    logger: &Logger,
+    conn: &mut AsyncPgConnection,
     id: &DeploymentHash,
     deterministic_errors: &[SubgraphError],
-    block: BlockNumber,
+    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, 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> {
     use subgraph_manifest as sm;
 
     sm::table
         .filter(sm::id.eq(id))
         .select(sm::entities_with_causality_region)
-        .get_result(conn)
+        .get_result::<Vec<String>>(conn)
+        .await
         .map_err(|e| e.into())
+        .map(|ents| {
+            // It is possible to have entity types in
+            // `entities_with_causality_region` that are not mentioned in
+            // the schema.
+            ents.into_iter()
+                .filter_map(|ent| schema.entity_type(&ent).ok())
+                .collect()
+        })
 }
 
 /// 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,
 ) -> Result<usize, StoreError> {
     use subgraph_error as e;
 
-    let src_nsp = if src.shard == dst.shard {
-        "subgraphs".to_string()
-    } else {
-        ForeignServer::metadata_schema(&src.shard)
-    };
+    let src_nsp = ForeignServer::metadata_schema_in(&src.shard, &dst.shard);
 
     // Check whether there are any errors for dst which indicates we already
     // did copy
     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);
     }
@@ -943,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
@@ -952,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 {
@@ -1005,34 +1287,44 @@ pub fn create_deployment(
                 schema,
                 raw_yaml,
                 entities_with_causality_region,
+                history_blocks,
             },
         start_block,
         graft_base,
         graft_block,
         debug_fork,
-    } = deployment;
+        history_blocks_override,
+    } = 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());
+    let entities_with_causality_region = Vec::from_iter(
+        entities_with_causality_region
+            .into_iter()
+            .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),
@@ -1049,119 +1341,155 @@ pub fn create_deployment(
         m::start_block_number.eq(start_block.as_ref().map(|ptr| ptr.number)),
         m::raw_yaml.eq(raw_yaml),
         m::entities_with_causality_region.eq(entities_with_causality_region),
+        m::history_blocks.eq(history_blocks_override.unwrap_or(history_blocks)),
     );
 
     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(())
 }
 
-fn entity_count_sql(full_count_query: &str, count: i32) -> String {
-    // The big complication in this query is how to determine what the
-    // new entityCount should be. We want to make sure that if the entityCount
-    // is NULL or the special value `-1`, it gets recomputed. Using `-1` here
-    // makes it possible to manually set the `entityCount` to that value
-    // to force a recount; setting it to `NULL` is not desirable since
-    // `entityCount` on the GraphQL level is not nullable, and so setting
-    // `entityCount` to `NULL` could cause errors at that layer; temporarily
-    // returning `-1` is more palatable. To be exact, recounts have to be
-    // done here, from the subgraph writer.
-    //
-    // The first argument of `coalesce` will be `NULL` if the entity count
-    // is `NULL` or `-1`, forcing `coalesce` to evaluate its second
-    // argument, the query to count entities. In all other cases,
-    // `coalesce` does not evaluate its second argument
-    format!(
-        "coalesce((nullif(entity_count, -1)) + ({count}),
-                  ({full_count_query}))",
-        full_count_query = full_count_query,
-        count = count
-    )
+fn entity_count_sql(count: i32) -> String {
+    format!("entity_count + ({count})")
 }
 
-pub fn update_entity_count(
-    conn: &PgConnection,
+pub async fn update_entity_count(
+    conn: &mut AsyncPgConnection,
     site: &Site,
-    full_count_query: &str,
     count: i32,
 ) -> Result<(), StoreError> {
-    use subgraph_deployment as d;
+    use head as h;
 
     if count == 0 {
         return Ok(());
     }
 
-    let count_sql = entity_count_sql(full_count_query, count);
-    update(d::table.filter(d::id.eq(site.id)))
-        .set(d::entity_count.eq(sql(&count_sql)))
-        .execute(conn)?;
+    let count_sql = entity_count_sql(count);
+    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(())
 }
 
-pub fn set_earliest_block(
-    conn: &PgConnection,
+/// Set the earliest block of `site` to the larger of `earliest_block` and
+/// the current value. This means that the `earliest_block_number` can never
+/// 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 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))
-        .execute(conn)?;
+        .filter(d::earliest_block_number.lt(earliest_block))
+        .execute(conn)
+        .await?;
     Ok(())
 }
 
-pub fn on_sync(conn: &PgConnection, id: impl Into<DeploymentId>) -> Result<OnSync, StoreError> {
+/// 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 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}.deployment where id = {})",
+        src.id
+    );
+
+    update(d::table.filter(d::id.eq(dst.id)))
+        .set(d::earliest_block_number.eq(sql(&query)))
+        .execute(conn)
+        .await?;
+
+    Ok(())
+}
+
+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()
         )),
@@ -1173,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 699183b18b8..d764d451ad6 100644
--- a/store/postgres/src/deployment_store.rs
+++ b/store/postgres/src/deployment_store.rs
@@ -1,55 +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::components::store::{EntityKey, EntityType, PruneReporter, StoredDynamicDataSource};
+use graph::blockchain::BlockTime;
+use graph::blockchain::block_stream::{EntitySourceOperation, FirehoseCursor};
+use graph::components::store::write::RowGroup;
+use graph::components::store::{
+    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::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::{
-    tokio, 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 itertools::Itertools;
 use lru_time_cache::LruCache;
-use rand::{seq::SliceRandom, thread_rng};
-use std::borrow::Cow;
+use rand::{rng, seq::SliceRandom};
 use std::collections::{BTreeMap, HashMap};
 use std::convert::Into;
-use std::iter::FromIterator;
 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::time::Instant;
+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, POI_OBJECT};
+use graph::data::subgraph::schema::{DeploymentCreate, SubgraphError};
+use graph::internal_error;
 use graph::prelude::{
-    anyhow, debug, info, o, warn, web3, ApiSchema, AttributeNames, BlockNumber, BlockPtr,
-    CheapClone, DeploymentHash, DeploymentState, Entity, EntityModification, EntityQuery, Error,
-    Logger, QueryExecutionError, Schema, 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_graphql::prelude::api_schema;
-use web3::types::Address;
+use graph::schema::{ApiSchema, EntityKey, EntityType, InputSchema};
 
-use crate::block_range::{block_number, BLOCK_COLUMN, BLOCK_RANGE_COLUMN};
-use crate::catalog;
+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::{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.
@@ -67,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: Arc<Schema>,
     /// 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
@@ -80,11 +85,16 @@ pub(crate) struct SubgraphInfo {
     pub(crate) description: Option<String>,
     pub(crate) repository: Option<String>,
     pub(crate) poi_version: ProofOfIndexingVersion,
+    pub(crate) instrument: bool,
 }
 
+type PruneHandle = JoinHandle<Result<(), StoreError>>;
+
 pub struct StoreInner {
     logger: Logger,
 
+    primary: Primary,
+
     pool: ConnectionPool,
     read_only_pools: Vec<ConnectionPool>,
 
@@ -103,15 +113,15 @@ pub struct StoreInner {
     /// hosts this because it lives long enough, but it is managed from
     /// the entities module
     pub(crate) layout_cache: LayoutCache,
+
+    prune_handles: Mutex<HashMap<DeploymentId, PruneHandle>>,
 }
 
 /// 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 {
@@ -122,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>,
@@ -145,365 +156,228 @@ 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,
             conn_round_robin_counter: AtomicUsize::new(0),
             subgraph_cache: Mutex::new(LruCache::with_capacity(100)),
             layout_cache: LayoutCache::new(ENV_VARS.store.query_stats_refresh_interval),
+            prune_handles: Mutex::new(HashMap::new()),
         };
 
         DeploymentStore(Arc::new(store))
     }
 
-    pub(crate) fn create_deployment(
+    pub(crate) async fn create_deployment(
         &self,
-        schema: &Schema,
+        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 =
                 deployment.manifest.entities_with_causality_region.clone();
+
+            // If `GRAPH_HISTORY_BLOCKS_OVERRIDE` is set, override the history_blocks
+            // setting with the value of the environment variable.
+            let deployment =
+                if let Some(history_blocks_global_override) = ENV_VARS.history_blocks_override {
+                    deployment.with_history_blocks_override(history_blocks_global_override)
+                } else {
+                    deployment
+                };
+
             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: &Site,
+        site: Arc<Site>,
     ) -> Result<SubgraphDeploymentEntity, StoreError> {
-        let conn = self.get_conn()?;
-        Ok(detail::deployment_entity(&conn, site)
-            .with_context(|| format!("Deployment details not found for {}", site.deployment))?)
+        let mut conn = self.pool.get_permitted().await?;
+        let layout = self.layout(&mut conn, site.clone()).await?;
+        Ok(
+            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
+    }
+
+    pub(crate) async fn execute_sql(
+        &self,
+        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<_>>())
     }
 
-    fn check_interface_entity_uniqueness(
+    async fn check_intf_uniqueness(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
         layout: &Layout,
-        key: &EntityKey,
+        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 schema = self
-            .subgraph_info_with_conn(conn, &layout.site)?
-            .api
-            .get(&Default::default())
-            .expect("API schema should be present")
-            .clone();
-        let types_for_interface = schema.types_for_interface();
-        let entity_type = key.entity_type.to_string();
-        let types_with_shared_interface = Vec::from_iter(
-            schema
-                .interfaces_for_type(&key.entity_type)
-                .into_iter()
-                .flatten()
-                .flat_map(|interface| &types_for_interface[&EntityType::from(interface)])
-                .map(EntityType::from)
-                .filter(|type_name| type_name != &key.entity_type),
-        );
+        let types_with_shared_interface = group.entity_type.share_interfaces()?;
+        if types_with_shared_interface.is_empty() {
+            return Ok(());
+        }
 
-        if !types_with_shared_interface.is_empty() {
-            if let Some(conflicting_entity) =
-                layout.conflicting_entity(conn, &key.entity_id, types_with_shared_interface)?
-            {
-                return Err(StoreError::ConflictingId(
-                    entity_type,
-                    key.entity_id.to_string(),
-                    conflicting_entity,
-                ));
-            }
+        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(
+    async fn apply_entity_modifications<'a>(
         &self,
-        conn: &PgConnection,
+        conn: &mut AsyncPgConnection,
+        logger: &Logger,
         layout: &Layout,
-        mods: &[EntityModification],
-        ptr: &BlockPtr,
+        groups: impl Iterator<Item = &'a RowGroup>,
         stopwatch: &StopwatchMetrics,
     ) -> Result<i32, StoreError> {
-        use EntityModification::*;
         let mut count = 0;
 
-        // Group `Insert`s and `Overwrite`s by key, and accumulate `Remove`s.
-        let mut inserts = HashMap::new();
-        let mut overwrites = HashMap::new();
-        let mut removals = HashMap::new();
-        for modification in mods.iter() {
-            match modification {
-                Insert { key, data } => {
-                    inserts
-                        .entry(key.entity_type.clone())
-                        .or_insert_with(Vec::new)
-                        .push((key, Cow::from(data)));
-                }
-                Overwrite { key, data } => {
-                    overwrites
-                        .entry(key.entity_type.clone())
-                        .or_insert_with(Vec::new)
-                        .push((key, Cow::from(data)));
-                }
-                Remove { key } => {
-                    removals
-                        .entry(key.entity_type.clone())
-                        .or_insert_with(Vec::new)
-                        .push(key.entity_id.as_str());
-                }
-            }
-        }
-
-        // Apply modification groups.
-        // Inserts:
-        for (entity_type, mut entities) in inserts.into_iter() {
-            count +=
-                self.insert_entities(&entity_type, &mut entities, conn, layout, ptr, stopwatch)?
-                    as i32
-        }
-
-        // Overwrites:
-        for (entity_type, mut entities) in overwrites.into_iter() {
-            // we do not update the count since the number of entities remains the same
-            self.overwrite_entities(&entity_type, &mut entities, conn, layout, ptr, stopwatch)?;
-        }
-
-        // Removals
-        for (entity_type, entity_keys) in removals.into_iter() {
-            count -= self.remove_entities(
-                &entity_type,
-                entity_keys.as_slice(),
-                conn,
-                layout,
-                ptr,
-                stopwatch,
-            )? as i32;
-        }
-        Ok(count)
-    }
+        for group in groups {
+            count += group.entity_count_change();
 
-    fn insert_entities<'a>(
-        &'a self,
-        entity_type: &'a EntityType,
-        data: &'a mut [(&'a EntityKey, Cow<'a, Entity>)],
-        conn: &PgConnection,
-        layout: &'a Layout,
-        ptr: &BlockPtr,
-        stopwatch: &StopwatchMetrics,
-    ) -> Result<usize, StoreError> {
-        let section = stopwatch.start_section("check_interface_entity_uniqueness");
-        for (key, _) in data.iter() {
-            // WARNING: This will potentially execute 2 queries for each entity key.
-            self.check_interface_entity_uniqueness(conn, layout, key)?;
-        }
-        section.end();
+            // 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).await?;
+            section.end();
 
-        let _section = stopwatch.start_section("apply_entity_modifications_insert");
-        layout.insert(conn, entity_type, data, block_number(ptr), stopwatch)
-    }
+            let section = stopwatch.start_section("check_interface_entity_uniqueness");
+            self.check_intf_uniqueness(conn, layout, group).await?;
+            section.end();
 
-    fn overwrite_entities<'a>(
-        &'a self,
-        entity_type: &'a EntityType,
-        data: &'a mut [(&'a EntityKey, Cow<'a, Entity>)],
-        conn: &PgConnection,
-        layout: &'a Layout,
-        ptr: &BlockPtr,
-        stopwatch: &StopwatchMetrics,
-    ) -> Result<usize, StoreError> {
-        let section = stopwatch.start_section("check_interface_entity_uniqueness");
-        for (key, _) in data.iter() {
-            // WARNING: This will potentially execute 2 queries for each entity key.
-            self.check_interface_entity_uniqueness(conn, layout, key)?;
+            let section = stopwatch.start_section("apply_entity_modifications_insert");
+            layout.insert(logger, conn, group, stopwatch).await?;
+            section.end();
         }
-        section.end();
-
-        let _section = stopwatch.start_section("apply_entity_modifications_update");
-        layout.update(conn, entity_type, data, block_number(ptr), stopwatch)
-    }
-
-    fn remove_entities(
-        &self,
-        entity_type: &EntityType,
-        entity_keys: &[&str],
-        conn: &PgConnection,
-        layout: &Layout,
-        ptr: &BlockPtr,
-        stopwatch: &StopwatchMetrics,
-    ) -> Result<usize, StoreError> {
-        let _section = stopwatch.start_section("apply_entity_modifications_delete");
-        layout.delete(conn, entity_type, entity_keys, block_number(ptr), stopwatch)
-    }
-
-    /// 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()
+        Ok(count)
     }
 
     /// 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<tokio::sync::OwnedSemaphorePermit, 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],
@@ -511,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(),
@@ -524,42 +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 (input_schema, description, repository, spec_version) =
-            deployment::manifest_info(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
@@ -567,14 +442,12 @@ impl DeploymentStore {
 
         for version in VERSIONS.iter() {
             let api_version = ApiVersion::from_version(version).expect("Invalid API version");
-            let mut schema = input_schema.clone();
-            schema.document =
-                api_schema(&schema.document).map_err(|e| StoreError::Unknown(e.into()))?;
-            schema.add_subgraph_id_directives(site.deployment.clone());
-            api.insert(api_version, Arc::new(ApiSchema::from_api_schema(schema)?));
+            let schema = layout.input_schema.api_schema()?;
+            api.insert(api_version, Arc::new(schema));
         }
 
-        let spec_version = Version::from_str(&spec_version).map_err(anyhow::Error::from)?;
+        let spec_version =
+            Version::from_str(&manifest_info.spec_version).map_err(anyhow::Error::from)?;
         let poi_version = if spec_version.ge(&SPEC_VERSION_0_0_6) {
             ProofOfIndexingVersion::Fast
         } else {
@@ -582,102 +455,119 @@ impl DeploymentStore {
         };
 
         let info = SubgraphInfo {
-            input: Arc::new(input_schema),
             api,
             graft_block,
             debug_fork,
-            description,
-            repository,
+            description: manifest_info.description,
+            repository: manifest_info.repository,
             poi_version,
+            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;
@@ -686,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))
@@ -742,27 +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(table, &columns)?;
-                catalog::set_stats_target(&conn, &site.namespace, &table.name, &columns, target)?;
+                let (columns, _) = resolve_column_names_and_index_exprs(table, &columns)?;
+
+                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.
@@ -774,40 +671,30 @@ impl DeploymentStore {
         entity_name: &str,
         field_names: Vec<String>,
         index_method: Method,
+        after: Option<BlockNumber>,
     ) -> 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 = resolve_column_names(table, &field_names)?;
-            let column_names_sep_by_underscores = column_names.join("_");
-            let column_names_sep_by_commas = column_names.join(", ");
-            let table_name = &table.name;
-            let index_name = format!("manual_{table_name}_{column_names_sep_by_underscores}");
-            let sql = format!(
-                "create index concurrently if not exists {index_name} \
-                 on {schema_name}.{table_name} using {index_method} \
-                 ({column_names_sep_by_commas})"
-            );
-            // 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.
@@ -818,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.
@@ -838,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(
@@ -853,109 +786,178 @@ 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) async fn set_history_blocks(
+        &self,
+        site: &Site,
+        history_blocks: BlockNumber,
+        reorg_threshold: BlockNumber,
+    ) -> Result<(), StoreError> {
+        if history_blocks <= reorg_threshold {
+            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}",
+                site.id
+            ));
+        }
+
+        // Invalidate the layout cache for this site so that the next access
+        // will use the updated value
+        self.layout_cache.remove(site);
+
+        let mut conn = self.pool.get_permitted().await?;
+        deployment::set_history_blocks(&mut conn, site, history_blocks).await
     }
 
     pub(crate) async fn prune(
         self: &Arc<Self>,
-        mut reporter: Box<dyn PruneReporter>,
+        reporter: Box<dyn PruneReporter>,
         site: Arc<Site>,
-        earliest_block: BlockNumber,
-        reorg_threshold: BlockNumber,
-        prune_ratio: f64,
+        req: PruneRequest,
     ) -> Result<Box<dyn PruneReporter>, StoreError> {
-        let store = self.clone();
-        self.with_conn(move |conn, cancel| {
-            let layout = store.layout(conn, site.clone())?;
-            cancel.check_cancel()?;
-            let state = deployment::state(conn, site.deployment.clone())?;
-
-            if state.latest_block.number <= reorg_threshold {
+        async fn do_prune(
+            store: Arc<DeploymentStore>,
+            conn: &mut AsyncPgConnection,
+            site: Arc<Site>,
+            req: PruneRequest,
+            mut reporter: Box<dyn PruneReporter>,
+        ) -> 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
                 return Ok(reporter);
             }
 
-            if state.earliest_block_number > earliest_block {
-                return Err(constraint_violation!("earliest block can not move back from {} to {}", state.earliest_block_number, earliest_block).into());
+            if state.earliest_block_number > req.earliest_block {
+                // We already have less history than we need (e.g., because
+                // of a manual onetime prune), nothing to prune
+                return Ok(reporter);
             }
 
-            let final_block = state.latest_block.number - reorg_threshold;
-            if final_block <= earliest_block {
-                return Err(constraint_violation!("the earliest block {} must be at least {} blocks before the current latest block {}", earliest_block, reorg_threshold, state.latest_block.number).into());
-            }
+            conn.transaction(async |conn| {
+                deployment::set_earliest_block(conn, site.as_ref(), req.earliest_block).await
+            })
+            .await?;
 
-            if let Some((_, graft)) = deployment::graft_point(conn, &site.deployment)? {
-                if graft.block_number() >= earliest_block {
-                    return Err(constraint_violation!("the earliest block {} must be after the graft point {}", earliest_block, graft.block_number()).into());
-                }
-            }
+            layout
+                .prune(&store.logger, reporter.as_mut(), conn, &req)
+                .await?;
+            Ok(reporter)
+        }
 
-            cancel.check_cancel()?;
+        let store = self.clone();
+        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)
+        }
+    }
 
-            conn.transaction(|| {
-                deployment::set_earliest_block(conn, site.as_ref(), earliest_block)
-            })?;
+    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?;
 
-            cancel.check_cancel()?;
+        Ok(relational::prune::Viewer::new(self.pool.clone(), layout))
+    }
 
-            layout.prune_by_copying(
-                &store.logger,
-                reporter.as_mut(),
-                conn,
-                earliest_block,
-                final_block,
-                prune_ratio,
-                cancel,
-            )?;
-            Ok(reporter)
-        })
-        .await
+    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) async fn supports_proof_of_indexing<'a>(
+    pub(crate) async fn block_time(
         &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)
+    ) -> Result<Option<BlockTime>, StoreError> {
+        let store = self.cheap_clone();
+
+        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(
@@ -965,63 +967,61 @@ impl DeploymentStore {
         block: BlockPtr,
     ) -> Result<Option<[u8; 32]>, StoreError> {
         let indexer = *indexer;
-        let site3 = site.cheap_clone();
-        let site4 = site.cheap_clone();
-        let site5 = site.cheap_clone();
+        let site2 = site.cheap_clone();
         let store = self.cheap_clone();
-        let block2 = block.cheap_clone();
+        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 = self
-            .with_conn(move |conn, cancel| {
-                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, site4.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 latest_block_ptr =
-                        match Self::block_ptr_with_conn(conn, site4.cheap_clone())? {
-                            Some(inner) => inner,
-                            None => return Ok(None),
-                        };
-
-                    cancel.check_cancel()?;
-
-                    // 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 {
-                        return Ok(None);
-                    }
+            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),
+                };
 
-                    let query = EntityQuery::new(
-                        site4.deployment.cheap_clone(),
-                        block.number,
-                        EntityCollection::All(vec![(
-                            POI_OBJECT.cheap_clone(),
-                            AttributeNames::All,
-                        )]),
-                    );
-                    let entities = store
-                        .execute_query::<Entity>(conn, site4, query)
-                        .map(|(entities, _)| entities)
-                        .map_err(anyhow::Error::from)?;
-
-                    Ok(Some(entities))
-                })
-                .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 entities = if let Some(entities) = entities {
-            entities
+            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 {
             return Ok(None);
         };
@@ -1029,8 +1029,8 @@ impl DeploymentStore {
         let mut by_causality_region = entities
             .into_iter()
             .map(|e| {
-                let causality_region = e.id()?;
-                let digest = match e.get("digest") {
+                let causality_region = e.id();
+                let digest = match e.get(poi_digest.as_str()) {
                     Some(Value::Bytes(b)) => Ok(b.clone()),
                     other => Err(anyhow::anyhow!(
                         "Entity has non-bytes digest attribute: {:?}",
@@ -1042,10 +1042,8 @@ impl DeploymentStore {
             })
             .collect::<Result<HashMap<_, _>, anyhow::Error>>()?;
 
-        let info = self.subgraph_info(&site5).map_err(anyhow::Error::from)?;
-
         let mut finisher =
-            ProofOfIndexingFinisher::new(&block2, &site3.deployment, &indexer, info.poi_version);
+            ProofOfIndexingFinisher::new(&block_ptr, &site2.deployment, &indexer, info.poi_version);
         for (name, region) in by_causality_region.drain() {
             finisher.add_causality_region(&name, &region);
         }
@@ -1055,239 +1053,430 @@ 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), Vec<String>>,
+        ids_for_type: &BTreeMap<(EntityType, CausalityRegion), IdList>,
         block: BlockNumber,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         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(&conn, ids_for_type, block)
+        layout.find_many(&mut conn, ids_for_type, block).await
     }
 
-    pub(crate) fn get_changes(
+    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) async fn get_derived(
+        &self,
+        site: Arc<Site>,
+        derived_query: &DerivedEntityQuery,
+        block: BlockNumber,
+        excluded_keys: &[EntityKey],
+    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
+        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) 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(
-        &self,
+    pub(crate) async fn transact_block_operations(
+        self: &Arc<Self>,
+        logger: &Logger,
         site: Arc<Site>,
-        block_ptr_to: &BlockPtr,
-        firehose_cursor: &FirehoseCursor,
-        mods: &[EntityModification],
+        batch: &Batch,
+        last_rollup: Option<BlockTime>,
         stopwatch: &StopwatchMetrics,
-        data_sources: &[StoredDynamicDataSource],
-        deterministic_errors: &[SubgraphError],
         manifest_idx_and_name: &[(u32, String)],
-        processed_data_sources: &[StoredDynamicDataSource],
-    ) -> 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?
         };
 
-        let event = deployment::with_lock(&conn, &site, || {
-            conn.transaction(|| -> Result<_, StoreError> {
-                // 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 = StoreEvent::from_mods(&site.deployment, mods);
-
+        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(),
-                    mods,
-                    block_ptr_to,
-                    stopwatch,
-                )?;
+                let count = self
+                    .apply_entity_modifications(
+                        conn,
+                        logger,
+                        layout.as_ref(),
+                        batch.groups(),
+                        stopwatch,
+                    )
+                    .await?;
                 section.end();
 
-                dynds::insert(
-                    &conn,
-                    &site,
-                    data_sources,
-                    block_ptr_to,
-                    manifest_idx_and_name,
-                )?;
+                layout.rollup(conn, last_rollup, &batch.block_times).await?;
+
+                dynds::insert(conn, &site, &batch.data_sources, manifest_idx_and_name).await?;
 
-                dynds::update_offchain_status(&conn, &site, processed_data_sources)?;
+                dynds::update_offchain_status(conn, &site, &batch.offchain_to_remove).await?;
 
-                if !deterministic_errors.is_empty() {
+                if !batch.deterministic_errors.is_empty() {
                     deployment::insert_subgraph_errors(
-                        &conn,
+                        &self.logger,
+                        conn,
                         &site.deployment,
-                        deterministic_errors,
-                        block_ptr_to.block_number(),
-                    )?;
+                        &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,
+                            &site.deployment,
+                            deployment::SubgraphHealth::Unhealthy,
+                            Some(&batch.deterministic_errors),
+                        )
+                        .await?;
+                    }
                 }
 
-                deployment::transact_block(
-                    &conn,
+                let earliest_block = deployment::transact_block(
+                    conn,
                     &site,
-                    block_ptr_to,
-                    firehose_cursor,
-                    layout.count_query.as_str(),
+                    &batch.block_ptr,
+                    &batch.firehose_cursor,
                     count,
-                )?;
+                )
+                .await?;
 
-                Ok(event)
+                Ok((layout, earliest_block))
             })
-        })?;
+            .await
+        })
+        .await?;
+
+        if batch.block_ptr.number as f64
+            > earliest_block as f64
+                + layout.history_blocks as f64 * ENV_VARS.store.history_slack_factor
+        {
+            // This only measures how long it takes to spawn pruning, not
+            // how long pruning itself takes
+            let _section = stopwatch.start_section("transact_blocks_prune");
+
+            if let Err(res) = self.spawn_prune(
+                logger,
+                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 rewind_with_conn(
-        &self,
-        conn: &PgConnection,
+    fn spawn_prune(
+        self: &Arc<Self>,
+        logger: &Logger,
         site: Arc<Site>,
-        block_ptr_to: BlockPtr,
-        firehose_cursor: &FirehoseCursor,
-    ) -> Result<StoreEvent, StoreError> {
-        let event = deployment::with_lock(conn, &site, || {
-            conn.transaction(|| -> Result<_, StoreError> {
-                // 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(anyhow!(
-                            "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
-                        )
-                        .into());
+        history_blocks: BlockNumber,
+        earliest_block: BlockNumber,
+        latest_block: BlockNumber,
+    ) -> Result<(), StoreError> {
+        fn prune_in_progress(store: &DeploymentStore, site: &Site) -> Result<bool, StoreError> {
+            let finished = store
+                .prune_handles
+                .lock()
+                .unwrap()
+                .get(&site.id)
+                .map(|handle| handle.is_finished());
+            match finished {
+                Some(true) => {
+                    // A previous prune has finished
+                    let handle = store
+                        .prune_handles
+                        .lock()
+                        .unwrap()
+                        .remove(&site.id)
+                        .unwrap();
+                    match FutureExt::now_or_never(handle) {
+                        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(internal_error!("prune handle is finished but not ready")),
                     }
                 }
+                Some(false) => {
+                    // A previous prune is still in progress
+                    Ok(true)
+                }
+                None => {
+                    // There is no prune in progress
+                    Ok(false)
+                }
+            }
+        }
+
+        async fn run(
+            logger: Logger,
+            store: Arc<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(&logger2, "prune", move || {
+                let store = store.cheap_clone();
+                let reporter = OngoingPruneReporter::new(logger.cheap_clone());
+                let site = site.cheap_clone();
+                async move { store.prune(reporter, site, req).await.map(|_| ()) }
+            })
+            .await
+        }
+
+        if !prune_in_progress(self, &site)? {
+            let req = PruneRequest::new(
+                &site.as_ref().into(),
+                history_blocks,
+                ENV_VARS.reorg_threshold(),
+                earliest_block,
+                latest_block,
+            )?;
 
+            let deployment_id = site.id;
+            let logger = Logger::new(logger, o!("component" => "Prune"));
+            let handle = graph::spawn(run(logger, self.clone(), site, req));
+            self.prune_handles
+                .lock()
+                .unwrap()
+                .insert(deployment_id, handle);
+        }
+        Ok(())
+    }
+
+    async fn rewind_or_truncate_with_conn(
+        &self,
+        conn: &mut AsyncPgConnection,
+        site: Arc<Site>,
+        block_ptr_to: BlockPtr,
+        firehose_cursor: &FirehoseCursor,
+        truncate: bool,
+    ) -> 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, count) = layout.revert_block(conn, block)?;
+                if truncate {
+                    layout.truncate_tables(conn).await?;
+                    deployment::clear_entity_count(conn, site.as_ref()).await?;
+                } else {
+                    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?;
 
-                deployment::update_entity_count(
-                    conn,
-                    site.as_ref(),
-                    layout.count_query.as_str(),
-                    count,
-                )?;
-                Ok(event)
+                Ok(())
             })
-        })?;
+            .await
+        })
+        .await
+    }
+
+    pub(crate) async fn truncate(
+        &self,
+        site: Arc<Site>,
+        block_ptr_to: BlockPtr,
+    ) -> Result<(), StoreError> {
+        let mut conn = self.pool.get_permitted().await?;
+
+        let block_ptr_from = Self::block_ptr_with_conn(&mut conn, site.cheap_clone()).await?;
+
+        // Sanity check on block numbers
+        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 {}",
+                from_number.unwrap_or(0),
+                block_ptr_to.number
+            );
+        }
 
-        Ok(event)
+        // 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(
+            &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_with_conn(&conn, site, block_ptr_to, &FirehoseCursor::None)
+        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
+            );
         }
 
-        self.rewind_with_conn(&conn, site, block_ptr_to, firehose_cursor)
+        // Don't revert past a graft point
+        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
+            ));
+        }
+
+        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(
@@ -1295,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)
@@ -1331,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
@@ -1374,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 {}",
@@ -1393,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)?
+                .load_deployment(dst.site.clone())
+                .await?
                 .manifest
                 .template_idx_and_name()?;
 
@@ -1404,84 +1576,265 @@ 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_earliest_block(
-                    &conn,
+                deployment::set_history_blocks(
+                    conn,
                     &dst.site,
-                    src_deployment.earliest_block_number,
-                )?;
-
-                // 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)?;
-                }
+                    src_deployment.manifest.history_blocks,
+                )
+                .await?;
+
+                // The `earliest_block` for `src` might have changed while
+                // we did the copy if `src` was pruned while we copied;
+                // adjusting it very late in the copy process ensures that
+                // we truly do have all the data starting at
+                // `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).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.
     //
@@ -1492,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),
@@ -1517,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
@@ -1543,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)?;
+                    deployment::update_deployment_status(conn, deployment_id, prev_health, None,None).await?;
 
                     Ok(UnfailOutcome::Unfailed)
                 }
@@ -1576,7 +1929,7 @@ impl DeploymentStore {
                     Ok(UnfailOutcome::Noop)
                 }
             }
-        })
+        }).await
     }
 
     // If a non-deterministic error happens and the deployment head advances,
@@ -1589,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),
@@ -1629,14 +1982,16 @@ impl DeploymentStore {
                             deployment_id,
                             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,
@@ -1648,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) {
@@ -1668,24 +2023,63 @@ impl DeploymentStore {
         });
     }
 
+    pub(crate) async fn refresh_materialized_views(&self, logger: &Logger) {
+        async fn run(store: &DeploymentStore) -> Result<(), StoreError> {
+            // 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; 4] = [
+                "info.table_sizes",
+                "info.subgraph_sizes",
+                "info.chain_sizes",
+                "info.entity_version_stats",
+            ];
+            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| {
+            warn!(logger, "Refreshing materialized views failed. We will try again in a few hours";
+                  "error" => e.to_string(),
+                  "shard" => self.pool.shard.as_str())
+        });
+    }
+
     pub(crate) async fn health(
         &self,
         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
     }
 
-    pub(crate) async fn set_manifest_raw_yaml(
+    async fn is_source(&self, site: &Site) -> Result<bool, StoreError> {
+        self.primary.is_source(site).await
+    }
+
+    /// 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
     }
 }
 
@@ -1695,7 +2089,10 @@ impl DeploymentStore {
 /// search using the latter if the search for the former fails.
 fn resolve_table_name<'a>(layout: &'a Layout, name: &'_ str) -> Result<&'a Table, StoreError> {
     layout
-        .table_for_entity(&EntityType::new(name.to_owned()))
+        .input_schema
+        .entity_type(name)
+        .map_err(StoreError::from)
+        .and_then(|et| layout.table_for_entity(&et))
         .map(Deref::deref)
         .or_else(|_error| {
             let sql_name = SqlName::from(name);
@@ -1705,34 +2102,166 @@ 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
 /// for the block range column for that table.
-fn resolve_column_names<'a, T: AsRef<str>>(
+fn resolve_column_names_and_index_exprs<'a, T: AsRef<str>>(
     table: &'a Table,
     field_names: &[T],
-) -> Result<Vec<&'a SqlName>, StoreError> {
-    fn lookup<'a>(table: &'a Table, field: &str) -> Result<&'a SqlName, StoreError> {
-        table
-            .column_for_field(field)
-            .or_else(|_error| {
-                let sql_name = SqlName::from(field);
-                table
-                    .column(&sql_name)
-                    .ok_or_else(|| StoreError::UnknownField(field.to_string()))
-            })
-            .map(|column| &column.name)
+) -> Result<(Vec<&'a SqlName>, Vec<String>), StoreError> {
+    let mut column_names = Vec::new();
+    let mut index_exprs = Vec::new();
+
+    for field in field_names {
+        let (column_name, index_expr) =
+            if field.as_ref() == BLOCK_RANGE_COLUMN || field.as_ref() == BLOCK_COLUMN {
+                let name = table.block_column();
+                (name, name.to_string())
+            } else {
+                resolve_column(table, field.as_ref())?
+            };
+
+        column_names.push(column_name);
+        index_exprs.push(index_expr);
     }
 
-    field_names
-        .iter()
-        .map(|f| {
-            if f.as_ref() == BLOCK_RANGE_COLUMN || f.as_ref() == BLOCK_COLUMN {
-                Ok(table.block_column())
-            } else {
-                lookup(table, f.as_ref())
-            }
+    Ok((column_names, index_exprs))
+}
+
+/// Resolves a column name against the `table`. The `field` can be
+/// either GraphQL attribute or the SQL name of a column.
+fn resolve_column<'a>(table: &'a Table, field: &str) -> Result<(&'a SqlName, String), StoreError> {
+    table
+        .column_for_field(field)
+        .or_else(|_| {
+            let sql_name = SqlName::from(field);
+            table
+                .column(&sql_name)
+                .ok_or_else(|| StoreError::UnknownField(table.name.to_string(), field.to_string()))
+        })
+        .map(|column| {
+            let index_expr = Table::calculate_index_method_and_expression(column).1;
+            (&column.name, index_expr)
+        })
+}
+
+/// A helper to log progress during pruning that is kicked off from
+/// `transact_block_operations`
+struct OngoingPruneReporter {
+    logger: Logger,
+    start: Instant,
+    analyze_start: Instant,
+    analyze_duration: Duration,
+    rows_copied: usize,
+    rows_deleted: usize,
+    tables: Vec<String>,
+}
+
+impl OngoingPruneReporter {
+    fn new(logger: Logger) -> Box<Self> {
+        Box::new(Self {
+            logger,
+            start: Instant::now(),
+            analyze_start: Instant::now(),
+            analyze_duration: Duration::from_secs(0),
+            rows_copied: 0,
+            rows_deleted: 0,
+            tables: Vec::new(),
         })
-        .collect()
+    }
+}
+
+impl OngoingPruneReporter {
+    fn tables_as_string(&self) -> String {
+        if self.tables.is_empty() {
+            "ø".to_string()
+        } else {
+            format!("[{}]", self.tables.iter().join(","))
+        }
+    }
+}
+
+impl PruneReporter for OngoingPruneReporter {
+    fn start(&mut self, req: &PruneRequest) {
+        self.start = Instant::now();
+        info!(&self.logger, "Start pruning historical entities";
+              "history_blocks" => req.history_blocks,
+              "earliest_block" => req.earliest_block,
+              "latest_block" => req.latest_block);
+    }
+
+    fn start_analyze(&mut self) {
+        self.analyze_start = Instant::now()
+    }
+
+    fn finish_analyze(&mut self, _stats: &[VersionStats], analyzed: &[&str]) {
+        self.analyze_duration += self.analyze_start.elapsed();
+        debug!(&self.logger, "Analyzed {} tables", analyzed.len(); "time_s" => self.analyze_start.elapsed().as_secs());
+    }
+
+    fn start_table(&mut self, table: &str) {
+        self.tables.push(table.to_string());
+    }
+
+    fn prune_batch(&mut self, _table: &str, rows: usize, phase: PrunePhase, _finished: bool) {
+        match phase.strategy() {
+            PruningStrategy::Rebuild => self.rows_copied += rows,
+            PruningStrategy::Delete => self.rows_deleted += rows,
+        }
+    }
+    fn finish(&mut self) {
+        info!(
+            &self.logger,
+            "Finished pruning entities";
+            "tables" => self.tables_as_string(),
+            "rows_deleted" => self.rows_deleted,
+            "rows_copied" => self.rows_copied,
+            "time_s" => self.start.elapsed().as_secs(),
+            "analyze_time_s" => self.analyze_duration.as_secs()
+        )
+    }
 }
diff --git a/store/postgres/src/detail.rs b/store/postgres/src/detail.rs
index 003422399b2..b59a53cdca4 100644
--- a/store/postgres/src/detail.rs
+++ b/store/postgres/src/detail.rs
@@ -2,28 +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::components::store::EntityType;
+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::{constraint_violation, data::subgraph::status, prelude::web3::types::H256};
+use graph::schema::InputSchema;
+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};
 
@@ -37,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, QueryableByName)]
-#[table_name = "subgraph_error"]
+#[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, 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,
@@ -86,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)
     }
@@ -108,7 +180,6 @@ impl TryFrom<ErrorDetail> for SubgraphError {
 
     fn try_from(value: ErrorDetail) -> Result<Self, Self::Error> {
         let ErrorDetail {
-            vid: _,
             id: _,
             subgraph_id,
             message,
@@ -121,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
@@ -131,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,
@@ -147,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 `{:?}`",
@@ -182,39 +243,38 @@ pub(crate) fn info_from_details(
     fatal: Option<ErrorDetail>,
     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(),
@@ -223,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()?;
@@ -237,41 +297,79 @@ 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,
         non_fatal_errors,
         chains: vec![chain],
         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.
     // Subsequently, we fetch non-fatal errors and we group them by deployment
@@ -280,53 +378,159 @@ 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()
     };
 
+    let mut history_blocks_map: HashMap<_, _> = {
+        if sites.is_empty() {
+            sm::table
+                .select((sm::id, sm::history_blocks))
+                .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)
+                .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();
-            info_from_details(detail, fatal, non_fatal, sites)
+            let subgraph_history_blocks = history_blocks_map.remove(&detail.id).unwrap_or_default();
+            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,
@@ -335,54 +539,60 @@ 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<EntityType>,
-    on_sync: Option<String>,
+    entities_with_causality_region: Vec<String>,
+    history_blocks: i32,
 }
 
-impl From<StoredSubgraphManifest> for SubgraphManifestEntity {
-    fn from(value: StoredSubgraphManifest) -> Self {
+impl StoredSubgraphManifest {
+    fn into_manifest_entity(self, schema: &InputSchema) -> SubgraphManifestEntity {
+        let e: Vec<_> = self
+            .entities_with_causality_region
+            .into_iter()
+            .map(|s| schema.entity_type(&s).unwrap())
+            .collect();
         SubgraphManifestEntity {
-            spec_version: value.spec_version,
-            description: value.description,
-            repository: value.repository,
-            features: value.features,
-            schema: value.schema,
-            raw_yaml: value.raw_yaml,
-            entities_with_causality_region: value.entities_with_causality_region,
+            spec_version: self.spec_version,
+            description: self.description,
+            repository: self.repository,
+            features: self.features,
+            schema: self.schema,
+            raw_yaml: self.raw_yaml,
+            entities_with_causality_region: e,
+            history_blocks: self.history_blocks,
         }
     }
 }
 
 struct StoredDeploymentEntity(crate::detail::DeploymentDetail, StoredSubgraphManifest);
 
-impl TryFrom<StoredDeploymentEntity> for SubgraphDeploymentEntity {
-    type Error = StoreError;
-
-    fn try_from(ent: StoredDeploymentEntity) -> Result<Self, Self::Error> {
-        let (detail, manifest) = (ent.0, ent.1);
+impl StoredDeploymentEntity {
+    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,
@@ -393,19 +603,19 @@ impl TryFrom<StoredDeploymentEntity> for SubgraphDeploymentEntity {
             .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.into(),
+            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,
@@ -421,26 +631,46 @@ impl TryFrom<StoredDeploymentEntity> for SubgraphDeploymentEntity {
     }
 }
 
-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)
+}
 
-    SubgraphDeploymentEntity::try_from(StoredDeploymentEntity(detail, manifest))
+/// 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;
+
+    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,
@@ -452,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;
@@ -480,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
@@ -491,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 5f6dd273964..e53474ae280 100644
--- a/store/postgres/src/dynds/mod.rs
+++ b/store/postgres/src/dynds/mod.rs
@@ -3,66 +3,65 @@ pub(crate) mod shared;
 
 pub(crate) use private::DataSourcesTable;
 
-use crate::primary::Site;
-use diesel::PgConnection;
+use crate::{AsyncPgConnection, primary::Site};
 use graph::{
-    blockchain::BlockPtr,
-    components::store::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: &[StoredDynamicDataSource],
-    block_ptr: &BlockPtr,
+    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,
-            block_ptr.number,
-        ),
-        false => shared::insert(
-            conn,
-            &site.deployment,
-            data_sources,
-            block_ptr,
-            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: &[StoredDynamicDataSource],
+    data_sources: &write::DataSources,
 ) -> Result<(), StoreError> {
     if data_sources.is_empty() {
         return Ok(());
@@ -70,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 98568dc8c5f..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::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,94 +149,105 @@ impl DataSourcesTable {
         Ok(dses)
     }
 
-    pub(crate) fn insert(
+    pub(crate) async fn insert(
         &self,
-        conn: &PgConnection,
-        data_sources: &[StoredDynamicDataSource],
-        block: BlockNumber,
+        conn: &mut AsyncPgConnection,
+        data_sources: &write::DataSources,
     ) -> Result<usize, StoreError> {
         let mut inserted_total = 0;
 
-        for ds in data_sources {
-            let StoredDynamicDataSource {
-                manifest_idx,
-                param,
-                context,
-                creation_block,
-                done_at,
-                causality_region,
-            } = ds;
-
-            if creation_block != &Some(block) {
-                return Err(constraint_violation!(
-                    "mismatching creation blocks `{:?}` and `{}`",
+        for (block_ptr, dss) in &data_sources.entries {
+            let block = block_ptr.number;
+            for ds in dss {
+                let StoredDynamicDataSource {
+                    manifest_idx,
+                    param,
+                    context,
                     creation_block,
-                    block
-                ));
-            }
-
-            // 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) \
+                    done_at,
+                    causality_region,
+                } = ds;
+
+                // 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(internal_error!(
+                        "mismatching creation blocks `{:?}` and `{}`",
+                        creation_block,
+                        block
+                    ));
+                }
+
+                // 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) \
                             values (int4range($1, null), $2, $3, $4, $5, $6)",
-                self.qname
-            );
-
-            let query = sql_query(query)
-                .bind::<Nullable<Integer>, _>(creation_block)
-                .bind::<Integer, _>(*manifest_idx as i32)
-                .bind::<Nullable<Binary>, _>(param.as_ref().map(|p| &**p))
-                .bind::<Nullable<Jsonb>, _>(context)
-                .bind::<Integer, _>(causality_region)
-                .bind::<Nullable<Integer>, _>(done_at);
-
-            inserted_total += query.execute(conn)?;
+                    self.qname
+                );
+
+                let query = sql_query(query)
+                    .bind::<Nullable<Integer>, _>(creation_block)
+                    .bind::<Integer, _>(*manifest_idx as i32)
+                    .bind::<Nullable<Binary>, _>(param.as_ref().map(|p| &**p))
+                    .bind::<Nullable<Jsonb>, _>(context)
+                    .bind::<Integer, _>(causality_region)
+                    .bind::<Nullable<Integer>, _>(done_at);
+
+                inserted_total += query.execute(conn).await?;
+            }
         }
-
         Ok(inserted_total)
     }
 
-    pub(crate) fn revert(&self, conn: &PgConnection, block: BlockNumber) -> Result<(), StoreError> {
-        // Use `@>` to leverage the gist index.
-        // This assumes all ranges are of the form [x, +inf).
+    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.
+        //
+        // This assumes all ranges are of the form [x, +inf), and thefore no range needs to be
+        // unclamped.
         let query = format!(
-            "delete from {} where block_range @> $1 and lower(block_range) = $1",
+            "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,
@@ -238,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())
             );
         }
 
@@ -291,28 +291,31 @@ 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,
-        data_sources: &[StoredDynamicDataSource],
+        conn: &mut AsyncPgConnection,
+        data_sources: &write::DataSources,
     ) -> Result<(), StoreError> {
-        for ds in data_sources {
-            let query = format!(
-                "update {} set done_at = $1 where causality_region = $2",
-                self.qname
-            );
-
-            let count = sql_query(query)
-                .bind::<Nullable<Integer>, _>(ds.done_at)
-                .bind::<Integer, _>(ds.causality_region)
-                .execute(conn)?;
-
-            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
-                ));
+        for (_, dss) in &data_sources.entries {
+            for ds in dss {
+                let query = format!(
+                    "update {} set done_at = $1 where causality_region = $2",
+                    self.qname
+                );
+
+                let count = sql_query(query)
+                    .bind::<Nullable<Integer>, _>(ds.done_at)
+                    .bind::<Integer, _>(ds.causality_region)
+                    .execute(conn)
+                    .await?;
+
+                if count > 1 {
+                    return Err(internal_error!(
+                        "expected to remove at most one offchain data source but would remove {}, causality region: {}",
+                        count,
+                        ds.causality_region
+                    ));
+                }
             }
         }
 
@@ -321,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
@@ -332,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 ee9f73dfb9d..d5e86332115 100644
--- a/store/postgres/src/dynds/shared.rs
+++ b/store/postgres/src/dynds/shared.rs
@@ -1,25 +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::StoredDynamicDataSource,
-    constraint_violation,
+    components::store::{StoredDynamicDataSource, write},
+    data::store::scalar::ToPrimitive,
     data_source::CausalityRegion,
-    prelude::{
-        bigdecimal::ToPrimitive, serde_json, BigDecimal, BlockNumber, BlockPtr, 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! {
@@ -37,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)>,
@@ -59,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 {
@@ -90,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(),
             ));
         }
@@ -100,11 +102,10 @@ 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: &[StoredDynamicDataSource],
-    block_ptr: &BlockPtr,
+    data_sources: &write::DataSources,
     manifest_idx_and_name: &[(u32, String)],
 ) -> Result<usize, StoreError> {
     use dynamic_ethereum_contract_data_source as decds;
@@ -115,62 +116,64 @@ pub(super) fn insert(
     }
 
     let dds: Vec<_> = data_sources
+        .entries
         .iter()
-        .map(|ds| {
-            let StoredDynamicDataSource {
-                manifest_idx: _,
-                param,
-                context,
-                creation_block: _,
-                done_at: _,
-                causality_region,
-            } = ds;
-
-            if causality_region != &CausalityRegion::ONCHAIN {
-                return Err(constraint_violation!(
-                    "using shared data source schema with file data sources"
-                ));
-            }
-
-            let address = match param {
-                Some(param) => param,
-                None => {
-                    return Err(constraint_violation!(
-                        "dynamic data sources must have an addres",
+        .flat_map(|(block_ptr, dds)| {
+            dds.iter().map(|ds| {
+                let StoredDynamicDataSource {
+                    manifest_idx: _,
+                    param,
+                    context,
+                    creation_block: _,
+                    done_at: _,
+                    causality_region,
+                } = ds;
+
+                if causality_region != &CausalityRegion::ONCHAIN {
+                    return Err(internal_error!(
+                        "using shared data source schema with file data sources"
                     ));
                 }
-            };
-            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))?
-                .1
-                .clone();
-            Ok((
-                decds::deployment.eq(deployment.as_str()),
-                decds::name.eq(name),
-                decds::context.eq(context
-                    .as_ref()
-                    .map(|ctx| serde_json::to_string(ctx).unwrap())),
-                decds::address.eq(&**address),
-                decds::abi.eq(""),
-                decds::start_block.eq(0),
-                decds::ethereum_block_number.eq(sql(&format!("{}::numeric", block_ptr.number))),
-                decds::ethereum_block_hash.eq(block_ptr.hash_slice()),
-            ))
+
+                let address = match param {
+                    Some(param) => param,
+                    None => {
+                        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(|| internal_error!("manifest idx {} not found", ds.manifest_idx))?
+                    .1
+                    .clone();
+                Ok((
+                    decds::deployment.eq(deployment.as_str()),
+                    decds::name.eq(name),
+                    decds::context.eq(context
+                        .as_ref()
+                        .map(|ctx| serde_json::to_string(ctx).unwrap())),
+                    decds::address.eq(&**address),
+                    decds::abi.eq(""),
+                    decds::start_block.eq(0),
+                    decds::ethereum_block_number.eq(sql(&format!("{}::numeric", block_ptr.number))),
+                    decds::ethereum_block_hash.eq(block_ptr.hash_slice()),
+                ))
+            })
         })
         .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,
@@ -183,18 +186,15 @@ pub(crate) fn copy(
         return Ok(0);
     }
 
-    let src_nsp = if src.shard == dst.shard {
-        "subgraphs".to_string()
-    } else {
-        ForeignServer::metadata_schema(&src.shard)
-    };
+    let src_nsp = ForeignServer::metadata_schema_in(&src.shard, &dst.shard);
 
     // Check whether there are any dynamic data sources for dst which
     // indicates we already did 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 9bc34814220..07241577a53 100644
--- a/store/postgres/src/fork.rs
+++ b/store/postgres/src/fork.rs
@@ -1,23 +1,21 @@
 use std::{
     collections::{HashMap, HashSet},
     str::FromStr,
-    sync::{Arc, Mutex},
+    sync::Mutex,
 };
 
+use async_trait::async_trait;
 use graph::{
-    block_on,
     components::store::SubgraphFork as SubgraphForkTrait,
-    data::graphql::ext::DirectiveFinder,
+    internal_error,
     prelude::{
-        info,
-        r::Value as RValue,
-        reqwest,
-        s::{Definition, Field, ObjectType, TypeDefinition},
-        serde_json, Attribute, DeploymentHash, Entity, Logger, Schema, Serialize, StoreError,
-        Value, ValueType,
+        DeploymentHash, Entity, Logger, Serialize, StoreError, Value, ValueType, anyhow, info,
+        r::Value as RValue, reqwest, serde_json,
     },
+    schema::Field,
     url::Url,
 };
+use graph::{data::value::Word, schema::InputSchema};
 use inflector::Inflector;
 
 #[derive(Serialize, Debug, PartialEq)]
@@ -41,13 +39,18 @@ struct Variables {
 pub(crate) struct SubgraphFork {
     client: reqwest::Client,
     endpoint: Url,
-    schema: Arc<Schema>,
+    schema: InputSchema,
     fetched_ids: Mutex<HashSet<String>>,
     logger: Logger,
 }
 
+#[async_trait]
 impl SubgraphForkTrait for SubgraphFork {
-    fn fetch(&self, entity_type: 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!(
@@ -56,25 +59,29 @@ impl SubgraphForkTrait for SubgraphFork {
                 ))
             })?;
             if fids.contains(&id) {
-                info!(self.logger, "Already fetched entity! Abort!"; "entity_type" => entity_type, "id" => id);
+                info!(self.logger, "Already fetched entity! Abort!"; "entity_type" => entity_type_name, "id" => id);
                 return Ok(None);
             }
             fids.insert(id.clone());
         }
 
-        info!(self.logger, "Fetching entity from {}", &self.endpoint; "entity_type" => &entity_type, "id" => &id);
+        info!(self.logger, "Fetching entity from {}", &self.endpoint; "entity_type" => &entity_type_name, "id" => &id);
 
         // NOTE: Subgraph fork compatibility checking (similar to the grafting compatibility checks)
         // will be added in the future (in a separate PR).
         // Currently, forking incompatible subgraphs is allowed, but, for example, storing the
         // incompatible fetched entities in the local store results in an error.
+        let entity_type = self.schema.entity_type(&entity_type_name)?;
+        let fields = &entity_type
+            .object_type()
+            .map_err(|_| internal_error!("no object type called `{}` found", entity_type_name))?
+            .fields;
 
-        let fields = self.get_fields_of(&entity_type)?;
         let query = Query {
-            query: self.query_string(&entity_type, fields)?,
+            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 \"{}\"",
@@ -82,7 +89,8 @@ impl SubgraphForkTrait for SubgraphFork {
             )));
         }
 
-        let entity = SubgraphFork::extract_entity(&raw_json, &entity_type, fields)?;
+        let entity =
+            SubgraphFork::extract_entity(&self.schema, &raw_json, &entity_type_name, fields)?;
         Ok(entity)
     }
 }
@@ -91,7 +99,7 @@ impl SubgraphFork {
     pub(crate) fn new(
         base: Url,
         id: DeploymentHash,
-        schema: Arc<Schema>,
+        schema: InputSchema,
         logger: Logger,
     ) -> Result<Self, StoreError> {
         Ok(Self {
@@ -129,31 +137,6 @@ impl SubgraphFork {
         Ok(res)
     }
 
-    fn get_fields_of(&self, entity_type: &str) -> Result<&Vec<Field>, StoreError> {
-        let entity: Option<&ObjectType> =
-            self.schema
-                .document
-                .definitions
-                .iter()
-                .find_map(|def| match def {
-                    Definition::TypeDefinition(TypeDefinition::Object(o))
-                        if o.name == entity_type =>
-                    {
-                        Some(o)
-                    }
-                    _ => None,
-                });
-
-        if entity.is_none() {
-            return Err(StoreError::ForkFailure(format!(
-                "No object type definition with entity type `{}` found in the GraphQL schema supplied by the user.",
-                entity_type
-            )));
-        }
-
-        Ok(&entity.unwrap().fields)
-    }
-
     fn query_string(&self, entity_type: &str, fields: &[Field]) -> Result<String, StoreError> {
         let names = fields
             .iter()
@@ -182,6 +165,7 @@ query Query ($id: String) {{
     }
 
     fn extract_entity(
+        schema: &InputSchema,
         raw_json: &str,
         entity_type: &str,
         fields: &[Field],
@@ -193,7 +177,7 @@ query Query ($id: String) {{
             return Ok(None);
         }
 
-        let map: HashMap<Attribute, Value> = {
+        let map: HashMap<Word, Value> = {
             let mut map = HashMap::new();
             for f in fields {
                 if f.is_derived() {
@@ -201,7 +185,7 @@ query Query ($id: String) {{
                     continue;
                 }
 
-                let value = entity.get(&f.name).unwrap().clone();
+                let value = entity.get(f.name.as_str()).unwrap().clone();
                 let value = if let Some(id) = value.get("id") {
                     RValue::String(id.as_str().unwrap().to_string())
                 } else if let Some(list) = value.as_array() {
@@ -230,22 +214,23 @@ query Query ($id: String) {{
             map
         };
 
-        Ok(Some(Entity::from(map)))
+        Ok(Some(schema.make_entity(map).map_err(|e| {
+            StoreError::Unknown(anyhow!("entity validation failed: {e}"))
+        })?))
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use std::{iter::FromIterator, str::FromStr};
+    use std::str::FromStr;
 
     use super::*;
 
     use graph::{
         data::store::scalar,
-        prelude::{s::Type, DeploymentHash},
+        prelude::{DeploymentHash, s::Type},
         slog::{self, o},
     };
-    use graphql_parser::parse_schema;
 
     fn test_base() -> Url {
         Url::parse("https://api.thegraph.com/subgraph/id/").unwrap()
@@ -255,74 +240,45 @@ mod tests {
         DeploymentHash::new("test").unwrap()
     }
 
-    fn test_schema() -> Arc<Schema> {
-        let schema = Schema::new(
-            DeploymentHash::new("test").unwrap(),
-            parse_schema::<String>(
-                r#"type Gravatar @entity {
+    fn test_schema() -> InputSchema {
+        InputSchema::parse_latest(
+            r#"type Gravatar @entity {
   id: ID!
   owner: Bytes!
   displayName: String!
   imageUrl: String!
 }"#,
-            )
-            .unwrap(),
+            DeploymentHash::new("test").unwrap(),
         )
-        .unwrap();
-        Arc::new(schema)
+        .unwrap()
     }
 
     fn test_logger() -> Logger {
         Logger::root(slog::Discard, o!())
     }
 
-    fn test_fields() -> Vec<Field> {
+    fn test_fields(schema: &InputSchema) -> Vec<Field> {
+        fn non_null_type(name: &str) -> Type {
+            Type::NonNullType(Box::new(Type::NamedType(name.to_string())))
+        }
+
+        let schema = schema.schema();
         vec![
-            Field {
-                position: graphql_parser::Pos { line: 2, column: 3 },
-                description: None,
-                name: "id".to_string(),
-                arguments: vec![],
-                field_type: Type::NonNullType(Box::new(Type::NamedType("ID".to_string()))),
-                directives: vec![],
-            },
-            Field {
-                position: graphql_parser::Pos { line: 3, column: 3 },
-                description: None,
-                name: "owner".to_string(),
-                arguments: vec![],
-                field_type: Type::NonNullType(Box::new(Type::NamedType("Bytes".to_string()))),
-                directives: vec![],
-            },
-            Field {
-                position: graphql_parser::Pos { line: 4, column: 3 },
-                description: None,
-                name: "displayName".to_string(),
-                arguments: vec![],
-                field_type: Type::NonNullType(Box::new(Type::NamedType("String".to_string()))),
-                directives: vec![],
-            },
-            Field {
-                position: graphql_parser::Pos { line: 5, column: 3 },
-                description: None,
-                name: "imageUrl".to_string(),
-                arguments: vec![],
-                field_type: Type::NonNullType(Box::new(Type::NamedType("String".to_string()))),
-                directives: vec![],
-            },
+            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),
         ]
     }
 
     #[test]
     fn test_get_fields_of() {
-        let base = test_base();
-        let id = test_id();
         let schema = test_schema();
-        let logger = test_logger();
 
-        let fork = SubgraphFork::new(base, id, schema, logger).unwrap();
+        let entity_type = schema.entity_type("Gravatar").unwrap();
+        let fields = &entity_type.object_type().unwrap().fields;
 
-        assert_eq!(fork.get_fields_of("Gravatar").unwrap(), &test_fields());
+        assert_eq!(fields, &test_fields(&schema).into_boxed_slice());
     }
 
     #[test]
@@ -332,10 +288,12 @@ mod tests {
         let schema = test_schema();
         let logger = test_logger();
 
-        let fork = SubgraphFork::new(base, id, schema, logger).unwrap();
+        let fork = SubgraphFork::new(base, id, schema.clone(), logger).unwrap();
 
         let query = Query {
-            query: fork.query_string("Gravatar", &test_fields()).unwrap(),
+            query: fork
+                .query_string("Gravatar", &test_fields(&schema))
+                .unwrap(),
             variables: Variables {
                 id: "0x00".to_string(),
             },
@@ -358,7 +316,9 @@ mod tests {
 
     #[test]
     fn test_extract_entity() {
+        let schema = test_schema();
         let entity = SubgraphFork::extract_entity(
+            &schema,
             r#"{
     "data": {
         "gravatar": {
@@ -370,27 +330,26 @@ mod tests {
     }
 }"#,
             "Gravatar",
-            &test_fields(),
+            &test_fields(&schema),
         )
         .unwrap();
 
         assert_eq!(
             entity.unwrap(),
-            Entity::from(HashMap::from_iter(
-                vec![
-                    ("id".to_string(), Value::String("0x00".to_string())),
+            schema
+                .make_entity(vec![
+                    ("id".into(), Value::String("0x00".to_string())),
                     (
-                        "owner".to_string(),
+                        "owner".into(),
                         Value::Bytes(scalar::Bytes::from_str("0x01").unwrap())
                     ),
-                    ("displayName".to_string(), Value::String("test".to_string())),
+                    ("displayName".into(), Value::String("test".to_string())),
                     (
-                        "imageUrl".to_string(),
+                        "imageUrl".into(),
                         Value::String("http://example.com/image.png".to_string())
                     ),
-                ]
-                .into_iter()
-            ))
+                ])
+                .unwrap()
         );
     }
 }
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 a0d89a20b26..7a90fcdd811 100644
--- a/store/postgres/src/jobs.rs
+++ b/store/postgres/src/jobs.rs
@@ -4,47 +4,64 @@ 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,
     store: Arc<Store>,
     primary_pool: ConnectionPool,
-    registry: Arc<dyn MetricsRegistry>,
+    registry: Arc<MetricsRegistry>,
 ) {
+    const ONE_MINUTE: Duration = Duration::from_secs(60);
+    const ONE_HOUR: Duration = Duration::from_secs(60 * 60);
+
     runner.register(
         Arc::new(VacuumDeploymentsJob::new(store.subgraph_store())),
-        Duration::from_secs(60),
+        ONE_MINUTE,
     );
 
     runner.register(
         Arc::new(NotificationQueueUsage::new(primary_pool, registry)),
-        Duration::from_secs(60),
+        ONE_MINUTE,
     );
 
     runner.register(
         Arc::new(MirrorPrimary::new(store.subgraph_store())),
-        Duration::from_secs(15 * 60),
+        15 * ONE_MINUTE,
     );
 
     // Remove unused deployments every 2 hours
     runner.register(
         Arc::new(UnusedJob::new(store.subgraph_store())),
-        Duration::from_secs(2 * 60 * 60),
-    )
+        2 * ONE_HOUR,
+    );
+
+    runner.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>,
 }
@@ -58,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);
             }
         }
     }
@@ -79,7 +93,7 @@ struct NotificationQueueUsage {
 }
 
 impl NotificationQueueUsage {
-    fn new(primary: ConnectionPool, registry: Arc<dyn MetricsRegistry>) -> Self {
+    fn new(primary: ConnectionPool, registry: Arc<MetricsRegistry>) -> Self {
         let usage_gauge = registry
             .new_gauge(
                 "notification_queue_usage",
@@ -96,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(())
     }
 }
 
@@ -148,6 +160,27 @@ impl Job for MirrorPrimary {
     }
 }
 
+struct RefreshMaterializedView {
+    store: Arc<SubgraphStore>,
+}
+
+impl RefreshMaterializedView {
+    fn new(store: Arc<SubgraphStore>) -> Self {
+        Self { store }
+    }
+}
+
+#[async_trait]
+impl Job for RefreshMaterializedView {
+    fn name(&self) -> &str {
+        "Refresh materialized views"
+    }
+
+    async fn run(&self, logger: &Logger) {
+        self.store.refresh_materialized_views(logger).await;
+    }
+}
+
 struct UnusedJob {
     store: Arc<SubgraphStore>,
 }
@@ -172,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;
         }
@@ -181,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());
@@ -190,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";
@@ -207,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 a54ec4060f3..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 sql_value;
+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;
+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;
+        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 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 79530c47bd8..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"))?,
         }
     }
@@ -396,7 +390,7 @@ pub struct NotificationSender {
 }
 
 impl NotificationSender {
-    pub fn new(registry: Arc<dyn MetricsRegistry>) -> Self {
+    pub fn new(registry: Arc<MetricsRegistry>) -> Self {
         let sent_counter = registry
             .global_counter_vec(
                 "notification_queue_sent",
@@ -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 09b9e809b4f..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,
+    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)]
@@ -78,6 +74,22 @@ table! {
     }
 }
 
+table! {
+    subgraphs.subgraph_features (id) {
+        id -> Text,
+        spec_version -> Text,
+        api_version -> Nullable<Text>,
+        features -> Array<Text>,
+        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>
+    }
+}
+
 table! {
     subgraphs.subgraph_version (vid) {
         vid -> BigInt,
@@ -93,6 +105,8 @@ table! {
     subgraphs.subgraph_deployment_assignment {
         id -> Integer,
         node_id -> Text,
+        paused_at -> Nullable<Timestamptz>,
+        assigned_at -> Nullable<Timestamptz>,
     }
 }
 
@@ -158,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>,
     }
 }
 
@@ -181,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)]
@@ -195,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,
@@ -211,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);
 
@@ -243,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
     }
@@ -255,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)
     }
 }
@@ -273,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 {
@@ -304,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)
     }
 }
@@ -347,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
@@ -403,22 +432,24 @@ pub fn make_dummy_site(deployment: DeploymentHash, namespace: Namespace, network
 /// mirrored through `Mirror::refresh_tables` and must be queries, i.e.,
 /// read-only
 mod queries {
-    use diesel::dsl::{any, exists, sql};
-    use diesel::pg::PgConnection;
+    use diesel::data_types::PgTimestamp;
+    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};
 
@@ -430,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
@@ -469,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
@@ -488,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> {
@@ -507,6 +542,7 @@ mod queries {
                 .filter(s::name.eq(&name))
                 .filter(ds::active)
                 .first::<Schema>(conn)
+                .await
         } else {
             ds::table
                 .select(ds::all_columns)
@@ -515,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()
@@ -550,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> {
@@ -570,51 +612,73 @@ 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>, _>>()
     }
 
-    pub(super) fn fill_assignments(
-        conn: &PgConnection,
-        infos: &mut [status::Info],
-    ) -> Result<(), StoreError> {
-        let ids: Vec<_> = infos.iter().map(|info| &info.subgraph).collect();
+    // All assignments for a node that are currently not paused
+    pub(super) async fn active_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()))
+            .filter(a::paused_at.is_null())
+            .select(ds::all_columns)
+            .load::<Schema>(conn)
+            .await?
+            .into_iter()
+            .map(Site::try_from)
+            .collect::<Result<Vec<Site>, _>>()
+    }
+
+    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))
-            .load::<(String, String)>(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(|(id, node, paused)| (id, (node, paused)))
             .collect();
-        for mut info in infos {
-            info.node = nodes.get(&info.subgraph).cloned()
-        }
-        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
@@ -624,32 +688,65 @@ mod queries {
             .transpose()
     }
 
-    pub(super) fn version_info(
-        conn: &PgConnection,
+    /// 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(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(|node| {
+                    internal_error!(
+                        "invalid node id `{}` in assignment for `{}`",
+                        node,
+                        site.deployment
+                    )
+                })?;
+
+                match ts {
+                    Some(_) => Ok((node_id, true)),
+                    None => Ok((node_id, false)),
+                }
+            })
+            .transpose()
+    }
+
+    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
@@ -670,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
@@ -728,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
                         ))
@@ -766,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
@@ -778,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 {
@@ -787,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
@@ -795,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)
     }
@@ -803,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)
@@ -822,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)
@@ -863,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 {
@@ -912,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
@@ -939,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
@@ -969,31 +1123,89 @@ 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 reassign_subgraph(
-        &self,
+    pub async fn pause_subgraph(
+        &mut self,
+        site: &Site,
+    ) -> Result<Vec<AssignmentChange>, StoreError> {
+        use subgraph_deployment_assignment as a;
+
+        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)
+            .await?;
+        match updates {
+            0 => Err(StoreError::DeploymentNotFound(site.deployment.to_string())),
+            1 => {
+                let change = AssignmentChange::removed(site.into());
+                Ok(vec![change])
+            }
+            _ => {
+                // `id` is the primary key of the subgraph_deployment_assignment table,
+                // and we can therefore only update no or one entry
+                unreachable!()
+            }
+        }
+    }
+
+    pub async fn resume_subgraph(
+        &mut self,
+        site: &Site,
+    ) -> Result<Vec<AssignmentChange>, StoreError> {
+        use subgraph_deployment_assignment as a;
+
+        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)
+            .await?;
+        match updates {
+            0 => Err(StoreError::DeploymentNotFound(site.deployment.to_string())),
+            1 => {
+                let change = AssignmentChange::set(site.into());
+                Ok(vec![change])
+            }
+            _ => {
+                // `id` is the primary key of the subgraph_deployment_assignment table,
+                // and we can therefore only update no or one entry
+                unreachable!()
+            }
+        }
+    }
+
+    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])
             }
             _ => {
@@ -1004,35 +1216,154 @@ impl<'a> Connection<'a> {
         }
     }
 
-    pub fn assign_subgraph(
-        &self,
+    pub async fn get_subgraph_features(
+        &mut self,
+        id: String,
+    ) -> Result<Option<DeploymentFeatures>, StoreError> {
+        use subgraph_features as f;
+
+        let conn = &mut self.conn;
+        let features = f::table
+            .filter(f::id.eq(id))
+            .select((
+                f::id,
+                f::spec_version,
+                f::api_version,
+                f::features,
+                f::data_sources,
+                f::handlers,
+                f::network,
+                f::has_declared_calls,
+                f::has_bytes_as_ids,
+                f::has_aggregations,
+                f::immutable_entities,
+            ))
+            .first::<(
+                String,
+                String,
+                Option<String>,
+                Vec<String>,
+                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,
+                has_declared_calls,
+                has_bytes_as_ids,
+                has_aggregations,
+                immutable_entities,
+            )| {
+                DeploymentFeatures {
+                    id,
+                    spec_version,
+                    api_version,
+                    features,
+                    data_source_kinds: data_sources,
+                    handler_kinds: handlers,
+                    network,
+                    has_declared_calls,
+                    has_bytes_as_ids,
+                    has_aggregations,
+                    immutable_entities,
+                }
+            },
+        );
+
+        Ok(features)
+    }
+
+    pub async fn create_subgraph_features(
+        &mut self,
+        features: DeploymentFeatures,
+    ) -> Result<(), StoreError> {
+        use subgraph_features as f;
+
+        let DeploymentFeatures {
+            id,
+            spec_version,
+            api_version,
+            features,
+            data_source_kinds,
+            handler_kinds,
+            network,
+            has_declared_calls,
+            has_bytes_as_ids,
+            immutable_entities,
+            has_aggregations,
+        } = features;
+
+        let conn = &mut self.conn;
+        let changes = (
+            f::id.eq(id),
+            f::spec_version.eq(spec_version),
+            f::api_version.eq(api_version),
+            f::features.eq(features),
+            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)
+            .await?;
+        Ok(())
+    }
+
+    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])
             }
             _ => {
@@ -1047,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,
@@ -1057,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((
@@ -1068,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 {
@@ -1083,37 +1416,72 @@ impl<'a> Connection<'a> {
             shard,
             namespace,
             network,
-            active: true,
+            active,
             schema_version,
             _creation_disallowed: (),
         })
     }
 
     /// Create a site for a brand new deployment.
-    pub fn allocate_site(
-        &self,
+    /// 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 async fn allocate_site(
+        &mut self,
         shard: Shard,
         subgraph: &DeploymentHash,
         network: String,
-        schema_version: DeploymentSchemaVersion,
-    ) -> Result<Site, StoreError> {
-        if let Some(site) = queries::find_active_site(self.conn.as_ref(), subgraph)? {
-            return Ok(site);
+        graft_base: Option<&DeploymentHash>,
+    ) -> Result<(Site, bool), StoreError> {
+        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(conn, graft_base).await?;
+                site.map(|site| site.schema_version).ok_or_else(|| {
+                    StoreError::DeploymentNotFound("graft_base not found".to_string())
+                })
+            }
+            None => Ok(DeploymentSchemaVersion::LATEST),
+        }?;
+
         self.create_site(shard, subgraph.clone(), network, schema_version, true)
+            .await
+            .map(|site| (site, site_was_created))
+    }
+
+    pub async fn find_active_site(
+        &mut self,
+        subgraph: &DeploymentHash,
+    ) -> Result<Option<Site>, StoreError> {
+        queries::find_active_site(&mut self.conn, subgraph).await
     }
 
-    pub fn assigned_node(&self, site: &Site) -> Result<Option<NodeId>, StoreError> {
-        queries::assigned_node(self.conn.as_ref(), site)
+    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 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);
         }
@@ -1125,86 +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 and the entry in `deployment_schemas` for
-    /// subgraph `id` in a transaction
-    pub fn drop_site(&self, site: &Site) -> Result<(), StoreError> {
+    /// Remove all subgraph versions, the entry in `deployment_schemas` and the entry in
+    /// `subgraph_features` for subgraph `id` in a transaction
+    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)
+                    .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> {
@@ -1219,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
@@ -1247,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)
             })
     }
 
@@ -1262,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
@@ -1288,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;
@@ -1301,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;
@@ -1328,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
@@ -1381,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;
@@ -1404,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)))
@@ -1420,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(())
     }
@@ -1430,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)
@@ -1521,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)
 }
 
@@ -1550,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)
@@ -1567,27 +2127,39 @@ impl Mirror {
                 pools.push(pool.clone());
                 pools
             });
+        let pools = Arc::new(pools);
         Mirror { pools }
     }
 
-    /// Execute the function `f` with connections from each of our pools in
+    /// Create a mirror that only uses the primary. Such a mirror will not
+    /// be able to do anything if the primary is down, and should only be
+    /// used for non-critical uses like command line tools
+    pub fn primary_only(primary: ConnectionPool) -> Mirror {
+        Mirror {
+            pools: Arc::new(vec![primary]),
+        }
+    }
+
+    /// 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),
@@ -1598,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,
@@ -1633,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
@@ -1682,7 +2233,8 @@ impl Mirror {
                      select * from {src_nsp}.subgraph
                      where current_version is not null;"
             ),
-        )?;
+        )
+        .await?;
         run_query(
             conn,
             format!(
@@ -1690,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(())
     }
@@ -1704,85 +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 async fn active_assignments(&self, node: &NodeId) -> Result<Vec<Site>, StoreError> {
+        self.read_async(async |conn| queries::active_assignments(conn, node).await)
+            .await
+    }
+
+    pub async fn assigned_node(&self, site: &Site) -> Result<Option<NodeId>, StoreError> {
+        self.read_async(async |conn| queries::assigned_node(conn, site).await)
+            .await
     }
 
-    pub fn assigned_node(&self, site: &Site) -> Result<Option<NodeId>, StoreError> {
-        self.read(|conn| queries::assigned_node(conn, site))
+    /// 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 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 ccc5142d77d..f36ac542799 100644
--- a/store/postgres/src/query_store.rs
+++ b/store/postgres/src/query_store.rs
@@ -1,10 +1,14 @@
-use std::collections::BTreeMap;
+use std::collections::HashMap;
+use std::time::Instant;
 
 use crate::deployment_store::{DeploymentStore, ReplicaId};
-use graph::components::store::QueryStore as QueryStoreTrait;
+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::value::Word;
+use graph::data::store::{QueryObject, SqlQueryObject};
 use graph::prelude::*;
+use graph::schema::{ApiSchema, InputSchema};
 
 use crate::primary::Site;
 
@@ -14,38 +18,81 @@ 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<BTreeMap<Word, r::Value>>, Trace), graph::prelude::QueryExecutionError> {
+    ) -> Result<(Vec<QueryObject>, Trace), graph::prelude::QueryExecutionError> {
         assert_eq!(&self.site.deployment, &query.subgraph_id);
-        let conn = self
+        let start = Instant::now();
+        let mut conn = self
             .store
             .get_replica_conn(self.replica_id)
+            .await
             .map_err(|e| QueryExecutionError::StoreError(e.into()))?;
-        self.store.execute_query(&conn, self.site.clone(), query)
+        let wait = start.elapsed();
+        self.store
+            .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,
@@ -60,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
@@ -74,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 {}",
@@ -91,41 +138,49 @@ 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())
     }
 
+    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<tokio::sync::OwnedSemaphorePermit, StoreError> {
+    async fn query_permit(&self) -> QueryPermit {
         self.store.query_permit(self.replica_id).await
     }
+
+    fn shard(&self) -> &str {
+        self.site.shard.as_str()
+    }
+
+    fn deployment_id(&self) -> DeploymentId {
+        self.site.id.into()
+    }
 }
diff --git a/store/postgres/src/relational.rs b/store/postgres/src/relational.rs
index 2c9211a583f..4059e736635 100644
--- a/store/postgres/src/relational.rs
+++ b/store/postgres/src/relational.rs
@@ -14,51 +14,74 @@ mod ddl_tests;
 #[cfg(test)]
 mod query_tests;
 
+pub(crate) mod dsl;
+pub(crate) mod dump;
 pub(crate) mod index;
-mod prune;
-
-use diesel::{connection::SimpleConnection, Connection};
-use diesel::{debug_query, OptionalExtension, PgConnection, RunQueryDsl};
+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, ToSql};
+use diesel::sql_types::Text;
+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::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, s, EntityQuery, StopwatchMetrics, ENV_VARS};
-use graph::slog::warn;
+use graph::internal_error;
+use graph::prelude::{ENV_VARS, EntityQuery, StopwatchMetrics, q};
+use graph::schema::{
+    AggregationInterval, EntityKey, EntityType, Field, FulltextConfig, FulltextDefinition,
+    InputSchema,
+};
+use graph::slog::{debug, warn};
 use inflector::Inflector;
+use itertools::Itertools;
 use lazy_static::lazy_static;
-use std::borrow::{Borrow, Cow};
+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, 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::{EntityKey, EntityType};
-use graph::data::graphql::ext::{DirectiveFinder, DocumentExt, ObjectTypeExt};
-use graph::data::schema::{FulltextConfig, FulltextDefinition, Schema, SCHEMA_TYPE_NAME};
-use graph::data::store::BYTES_SCALAR;
-use graph::data::subgraph::schema::{POI_OBJECT, POI_TABLE};
+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;
 
 const DELETE_OPERATION_CHUNK_SIZE: usize = 1_000;
 
@@ -72,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()));
@@ -156,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)
@@ -168,56 +197,32 @@ impl Borrow<str> for &SqlName {
     }
 }
 
-/// The SQL type to use for GraphQL ID properties. We support
-/// strings and byte arrays
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub(crate) enum IdType {
-    String,
-    Bytes,
+impl PartialEq<str> for SqlName {
+    fn eq(&self, other: &str) -> bool {
+        self.0 == other
+    }
 }
 
-impl IdType {
-    pub fn sql_type(&self) -> &str {
-        match self {
-            IdType::String => "text",
-            IdType::Bytes => "bytea",
-        }
+impl FromSql<Text, Pg> for SqlName {
+    fn from_sql(bytes: diesel::pg::PgValue) -> diesel::deserialize::Result<Self> {
+        <String as FromSql<Text, Pg>>::from_sql(bytes).map(SqlName::verbatim)
     }
 }
 
-impl TryFrom<&s::ObjectType> for IdType {
-    type Error = StoreError;
-
-    fn try_from(obj_type: &s::ObjectType) -> Result<Self, Self::Error> {
-        let pk = obj_type
-            .field(PRIMARY_KEY_COLUMN)
-            .expect("Each ObjectType has an `id` field");
-        Self::try_from(&pk.field_type)
+impl ToSql<Text, Pg> for SqlName {
+    fn to_sql<'b>(&'b self, out: &mut Output<'b, '_, Pg>) -> diesel::serialize::Result {
+        <String as ToSql<Text, Pg>>::to_sql(&self.0, out)
     }
 }
 
-impl TryFrom<&s::Type> for IdType {
-    type Error = StoreError;
-
-    fn try_from(field_type: &s::Type) -> Result<Self, Self::Error> {
-        let name = named_type(field_type);
+impl std::ops::Deref for SqlName {
+    type Target = str;
 
-        match ValueType::from_str(name)? {
-            ValueType::String => Ok(IdType::String),
-            ValueType::Bytes => Ok(IdType::Bytes),
-            _ => Err(anyhow!(
-                "The `id` field has type `{}` but only `String`, `Bytes`, and `ID` are allowed",
-                &name
-            )
-            .into()),
-        }
+    fn deref(&self) -> &Self::Target {
+        self.as_str()
     }
 }
 
-type IdTypeMap = HashMap<EntityType, IdType>;
-
-type EnumMap = BTreeMap<String, Arc<BTreeSet<String>>>;
-
 #[derive(Debug, Clone)]
 pub struct Layout {
     /// Details of where the subgraph is stored
@@ -226,197 +231,164 @@ pub struct Layout {
     pub tables: HashMap<EntityType, Arc<Table>>,
     /// The database schema for this subgraph
     pub catalog: Catalog,
-    /// Enums defined in the schema and their possible values. The names
-    /// are the original GraphQL names
-    pub enums: EnumMap,
-    /// 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
+    pub(crate) rollups: Vec<Rollup>,
 }
 
 impl Layout {
     /// Generate a layout for a relational schema for entities in the
     /// GraphQL schema `schema`. The name of the database schema in which
     /// the subgraph's tables live is in `site`.
-    pub fn new(site: Arc<Site>, schema: &Schema, catalog: Catalog) -> Result<Self, StoreError> {
-        // Extract enum types
-        let enums: EnumMap = schema
-            .document
-            .get_enum_definitions()
-            .iter()
-            .map(
-                |enum_type| -> Result<(String, Arc<BTreeSet<String>>), StoreError> {
-                    SqlName::check_valid_identifier(&enum_type.name, "enum")?;
-                    Ok((
-                        enum_type.name.clone(),
-                        Arc::new(
-                            enum_type
-                                .values
-                                .iter()
-                                .map(|value| value.name.clone())
-                                .collect::<BTreeSet<_>>(),
-                        ),
-                    ))
-                },
-            )
-            .collect::<Result<_, _>>()?;
-
-        // List of all object types that are not __SCHEMA__
-        let object_types = schema
-            .document
-            .get_object_type_definitions()
-            .into_iter()
-            .filter(|obj_type| obj_type.name != SCHEMA_TYPE_NAME)
-            .collect::<Vec<_>>();
-
-        // For interfaces, check that all implementors use the same IdType
-        // and build a list of name/IdType pairs
-        let id_types_for_interface = schema.types_for_interface.iter().map(|(interface, types)| {
-            types
-                .iter()
-                .map(IdType::try_from)
-                .collect::<Result<HashSet<_>, _>>()
-                .and_then(move |types| {
-                    if types.len() > 1 {
-                        Err(anyhow!(
-                            "The implementations of interface \
-                            `{}` use different types for the `id` field",
-                            interface
-                        )
-                        .into())
-                    } else {
-                        // For interfaces that are not implemented at all, pretend
-                        // they have a String `id` field
-                        // see also: id-type-for-unimplemented-interfaces
-                        let id_type = types.iter().next().cloned().unwrap_or(IdType::String);
-                        Ok((interface.clone(), id_type))
-                    }
-                })
-        });
+    pub fn new(
+        site: Arc<Site>,
+        schema: &InputSchema,
+        catalog: Catalog,
+    ) -> Result<Self, StoreError> {
+        // Check that enum type names are valid for SQL
+        for name in schema.enum_types() {
+            SqlName::check_valid_identifier(name, "enum")?;
+        }
 
-        // Map of type name to the type of the ID column for the object_types
-        // and interfaces in the schema
-        let id_types = object_types
-            .iter()
-            .map(|obj_type| IdType::try_from(*obj_type).map(|t| (EntityType::from(*obj_type), t)))
-            .chain(id_types_for_interface)
-            .collect::<Result<IdTypeMap, _>>()?;
+        // Construct a Table struct for each entity type, except for PoI
+        // since we handle that specially
+        let entity_tables = schema.entity_types();
+        let ts_tables = schema.ts_entity_types();
+        let has_ts_tables = !ts_tables.is_empty();
 
-        // Construct a Table struct for each ObjectType
-        let mut tables = object_types
+        let mut tables = entity_tables
             .iter()
+            .chain(ts_tables.iter())
             .enumerate()
-            .map(|(i, obj_type)| {
+            .map(|(i, entity_type)| {
                 Table::new(
-                    obj_type,
+                    schema,
+                    entity_type,
                     &catalog,
-                    Schema::entity_fulltext_definitions(&obj_type.name, &schema.document)
+                    schema
+                        .entity_fulltext_definitions(entity_type.as_str())
                         .map_err(|_| StoreError::FulltextSearchNonDeterministic)?,
-                    &enums,
-                    &id_types,
                     i as u32,
-                    catalog
-                        .entities_with_causality_region
-                        .contains(&EntityType::from(*obj_type)),
+                    catalog.entities_with_causality_region.contains(entity_type),
                 )
             })
             .collect::<Result<Vec<_>, _>>()?;
+        // Construct tables for timeseries
+
         if catalog.use_poi {
-            tables.push(Self::make_poi_table(&catalog, tables.len()))
+            tables.push(Self::make_poi_table(
+                schema,
+                &catalog,
+                has_ts_tables,
+                tables.len(),
+            ))
         }
 
-        let tables: Vec<_> = tables.into_iter().map(Arc::new).collect();
-
-        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| {
-                tables.insert(table.object.clone(), table);
+                tables.insert(table.object.clone(), Arc::new(table));
                 tables
             });
 
+        let rollups = Self::rollups(&tables, schema)?;
+
         Ok(Layout {
             site,
             catalog,
             tables,
-            enums,
-            count_query,
+            history_blocks: i32::MAX,
+            input_schema: schema.cheap_clone(),
+            rollups,
         })
     }
 
-    fn make_poi_table(catalog: &Catalog, position: usize) -> Table {
+    fn make_poi_table(
+        schema: &InputSchema,
+        catalog: &Catalog,
+        has_ts_tables: bool,
+        position: usize,
+    ) -> Table {
+        let poi_type = schema.poi_type();
+        let poi_digest = schema.poi_digest();
+        let poi_block_time = schema.poi_block_time();
+
+        let mut columns = vec![
+            Column {
+                name: SqlName::from(poi_digest.as_str()),
+                field: poi_digest,
+                field_type: q::Type::NonNullType(Box::new(q::Type::NamedType(
+                    BYTES_SCALAR.to_owned(),
+                ))),
+                column_type: ColumnType::Bytes,
+                fulltext_fields: None,
+                is_reference: false,
+                use_prefix_comparison: false,
+            },
+            Column {
+                name: SqlName::from(PRIMARY_KEY_COLUMN),
+                field: Word::from(PRIMARY_KEY_COLUMN),
+                field_type: q::Type::NonNullType(Box::new(q::Type::NamedType("String".to_owned()))),
+                column_type: ColumnType::String,
+                fulltext_fields: None,
+                is_reference: false,
+                use_prefix_comparison: false,
+            },
+        ];
+
+        // If the subgraph uses timeseries, store the block time in the PoI
+        // table
+        if has_ts_tables {
+            // FIXME: Use `Timestamp` as the field type when that's
+            // available
+            let ts_column = Column {
+                name: SqlName::from(poi_block_time.as_str()),
+                field: poi_block_time,
+                field_type: q::Type::NonNullType(Box::new(q::Type::NamedType("Int8".to_owned()))),
+                column_type: ColumnType::Int8,
+                fulltext_fields: None,
+                is_reference: false,
+                use_prefix_comparison: false,
+            };
+            columns.push(ts_column);
+        }
+
         let table_name = SqlName::verbatim(POI_TABLE.to_owned());
+        let nsp = catalog.site.namespace.clone();
         Table {
-            object: POI_OBJECT.to_owned(),
+            object: poi_type.to_owned(),
             qualified_name: SqlName::qualified_name(&catalog.site.namespace, &table_name),
+            nsp,
             name: table_name,
-            columns: vec![
-                Column {
-                    name: SqlName::from("digest"),
-                    field: "digest".to_owned(),
-                    field_type: q::Type::NonNullType(Box::new(q::Type::NamedType(
-                        BYTES_SCALAR.to_owned(),
-                    ))),
-                    column_type: ColumnType::Bytes,
-                    fulltext_fields: None,
-                    is_reference: false,
-                    use_prefix_comparison: false,
-                },
-                Column {
-                    name: SqlName::from(PRIMARY_KEY_COLUMN),
-                    field: PRIMARY_KEY_COLUMN.to_owned(),
-                    field_type: q::Type::NonNullType(Box::new(q::Type::NamedType(
-                        "String".to_owned(),
-                    ))),
-                    column_type: ColumnType::String,
-                    fulltext_fields: None,
-                    is_reference: false,
-                    use_prefix_comparison: false,
-                },
-            ],
-            /// 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
+            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
             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(&*POI_OBJECT)
-    }
-
-    pub fn create_relational_schema(
-        conn: &PgConnection,
+    pub async fn create_relational_schema(
+        conn: &mut AsyncPgConnection,
         site: Arc<Site>,
-        schema: &Schema,
+        schema: &InputSchema,
         entities_with_causality_region: BTreeSet<EntityType>,
     ) -> Result<Layout, StoreError> {
-        let catalog = Catalog::for_creation(site.cheap_clone(), entities_with_causality_region);
+        let catalog =
+            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)
     }
 
@@ -439,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);
@@ -458,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 {}",
@@ -466,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())
     }
 
@@ -486,25 +459,34 @@ 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, true))
+            .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,
-        ids_for_type: &BTreeMap<(EntityType, CausalityRegion), Vec<String>>,
+        conn: &mut AsyncPgConnection,
+        ids_for_type: &BTreeMap<(EntityType, CausalityRegion), IdList>,
         block: BlockNumber,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
         if ids_for_type.is_empty() {
@@ -515,33 +497,196 @@ impl Layout {
         for (entity_type, cr) in ids_for_type.keys() {
             tables.push((self.table_for_entity(entity_type)?.as_ref(), *cr));
         }
-        let query = FindManyQuery {
-            _namespace: &self.catalog.site.namespace,
-            ids_for_type,
-            tables,
-            block,
-        };
+        let query = FindManyQuery::new(tables, ids_for_type, block);
         let mut entities: BTreeMap<EntityKey, Entity> = BTreeMap::new();
-        for data in query.load::<EntityData>(conn)? {
-            let entity_type = data.entity_type();
-            let entity_data: Entity = data.deserialize_with_layout(self, None, true)?;
+        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(internal_error!(
+                    "duplicate entity {}[{}] in result set, block = {}",
+                    key.entity_type,
+                    key.entity_id,
+                    block
+                ));
+            } else {
+                entities.insert(key, entity_data);
+            }
+        }
+        Ok(entities)
+    }
 
-            let key = EntityKey {
+    pub async fn find_range(
+        &self,
+        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_id: entity_data.id()?.into(),
-                causality_region: CausalityRegion::from_entity(&entity_data),
+                entity,
+                vid,
             };
-            let overwrite = entities.insert(key, entity_data).is_some();
-            if overwrite {
-                return Err(constraint_violation!("duplicate entity in result set"));
-            }
+            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: &[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).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));
+
+            entities.insert(key, entity_data);
         }
         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();
@@ -551,45 +696,37 @@ 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();
 
         for entity_data in inserts_or_updates.into_iter() {
-            let entity_type = entity_data.entity_type();
-            let data: Entity = entity_data.deserialize_with_layout(self, None, true)?;
-            let entity_id = Word::from(data.id().expect("Invalid ID for entity."));
+            let entity_type = entity_data.entity_type(&self.input_schema);
+            let data: Entity = entity_data.deserialize_with_layout(self, None)?;
+            let entity_id = data.id();
             processed_entities.insert((entity_type.clone(), entity_id.clone()));
 
             changes.push(EntityOperation::Set {
-                key: EntityKey {
-                    entity_type,
-                    entity_id,
-                    causality_region: CausalityRegion::from_entity(&data),
-                },
+                key: entity_type.key_in(entity_id, CausalityRegion::from_entity(&data)),
                 data,
             });
         }
 
         for del in &deletions {
-            let entity_type = del.entity_type();
-            let entity_id = Word::from(del.id());
+            let entity_type = del.entity_type(&self.input_schema);
 
             // See the doc comment of `FindPossibleDeletionsQuery` for details
             // about why this check is necessary.
+            let entity_id = entity_type.parse_id(del.id())?;
             if !processed_entities.contains(&(entity_type.clone(), entity_id.clone())) {
                 changes.push(EntityOperation::Remove {
-                    key: EntityKey {
-                        entity_type,
-                        entity_id,
-                        causality_region: del.causality_region(),
-                    },
+                    key: entity_type.key_in(entity_id, del.causality_region()),
                 });
             }
         }
@@ -597,46 +734,114 @@ impl Layout {
         Ok(changes)
     }
 
-    pub fn insert<'a>(
+    pub async fn insert<'a>(
         &'a self,
-        conn: &PgConnection,
-        entity_type: &'a EntityType,
-        entities: &'a mut [(&'a EntityKey, Cow<'a, Entity>)],
-        block: BlockNumber,
+        logger: &Logger,
+        conn: &mut AsyncPgConnection,
+        group: &'a RowGroup,
         stopwatch: &StopwatchMetrics,
-    ) -> Result<usize, StoreError> {
-        let table = self.table_for_entity(entity_type)?;
+    ) -> 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");
-        let mut count = 0;
 
         // 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);
-        for chunk in entities.chunks_mut(chunk_size) {
-            count += InsertQuery::new(table, chunk, block)?
-                .get_results(conn)
-                .map(|ids| ids.len())?
+        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() {
+                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;
+                        }
+                    }
+                }
+            }
         }
-        Ok(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: &str,
-        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(
@@ -693,17 +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::*;
@@ -720,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())
@@ -737,42 +945,48 @@ impl Layout {
             .into_iter()
             .map(|entity_data| {
                 entity_data
-                    .deserialize_with_layout(self, parent_type.as_ref(), false)
+                    .deserialize_with_layout(self, parent_type.as_ref())
                     .map_err(|e| e.into())
             })
             .collect::<Result<Vec<T>, _>>()
             .map(|values| (values, trace))
     }
 
-    pub fn update<'a>(
+    pub async fn update<'a>(
         &'a self,
-        conn: &PgConnection,
-        entity_type: &'a EntityType,
-        entities: &'a mut [(&'a EntityKey, Cow<'a, Entity>)],
-        block: BlockNumber,
+        conn: &mut AsyncPgConnection,
+        group: &'a RowGroup,
         stopwatch: &StopwatchMetrics,
     ) -> Result<usize, StoreError> {
-        let table = self.table_for_entity(entity_type)?;
-        if table.immutable {
-            let ids = entities
-                .iter_mut()
-                .map(|(key, _)| key.entity_id.as_str())
+        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 [{}]",
-                entity_type,
+                group.entity_type,
                 ids
             ));
         }
 
-        let entity_keys: Vec<&str> = entities
-            .iter()
-            .map(|(key, _)| key.entity_id.as_str())
-            .collect();
-
         let section = stopwatch.start_section("update_modification_clamp_range_query");
-        ClampRangeQuery::new(table, &entity_keys, block)?.execute(conn)?;
+        for (block, rows) in group.clamps_by_block() {
+            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.id_type()?,
+                entity_keys.into_iter().map(|id| id.to_owned()),
+            )?;
+            ClampRangeQuery::new(table, &entity_keys, block)?
+                .execute(conn)
+                .await?;
+        }
         section.end();
 
         let _section = stopwatch.start_section("update_modification_insert_query");
@@ -781,56 +995,106 @@ impl Layout {
         // 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);
-        for chunk in entities.chunks_mut(chunk_size) {
-            count += InsertQuery::new(table, chunk, block)?.execute(conn)?;
+        for chunk in group.write_chunks(chunk_size) {
+            count += InsertQuery::new(table, &chunk)?.execute(conn).await?;
         }
+
         Ok(count)
     }
 
-    pub fn delete(
+    pub async fn delete(
         &self,
-        conn: &PgConnection,
-        entity_type: &EntityType,
-        entity_ids: &[&str],
-        block: BlockNumber,
+        conn: &mut AsyncPgConnection,
+        group: &RowGroup,
         stopwatch: &StopwatchMetrics,
     ) -> Result<usize, StoreError> {
-        let table = self.table_for_entity(entity_type)?;
+        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);
+        }
+
+        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 [{}]",
-                entity_type, entity_ids.join(", ")
+                table.object,
+                group.ids().join(", ")
             ));
         }
 
         let _section = stopwatch.start_section("delete_modification_clamp_range_query");
         let mut count = 0;
-        for chunk in entity_ids.chunks(DELETE_OPERATION_CHUNK_SIZE) {
-            count += ClampRangeQuery::new(table, chunk, block)?.execute(conn)?
+        for (block, rows) in group.clamps_by_block() {
+            let ids: Vec<_> = rows.iter().map(|eref| eref.id()).collect();
+            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.id_type()?,
+                    chunk.iter().map(|id| (*id).to_owned()),
+                )?;
+                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 async fn truncate_tables(&self, conn: &mut AsyncPgConnection) -> Result<(), StoreError> {
+        for table in self.tables.values() {
+            sql_query(format!("TRUNCATE TABLE {}", table.qualified_name))
+                .execute(conn)
+                .await?;
+        }
+        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()
-                .map(|data| data.id)
-                .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`
@@ -838,9 +1102,9 @@ impl Layout {
                 HashSet::new()
             } else {
                 RevertClampQuery::new(table, block - 1)?
-                    .get_results(conn)?
+                    .get_results(conn)
+                    .await?
                     .into_iter()
-                    .map(|data| data.id)
                     .collect::<HashSet<_>>()
             };
             // Adjust the entity count; we can tell which operation was
@@ -851,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.clone(),
-                });
-            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.clone(),
-            });
-            changes.extend(set);
         }
-        Ok((StoreEvent::new(changes), count))
+        Ok(count)
     }
 
     /// Revert the metadata (dynamic data sources and related entities) for
@@ -875,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(())
     }
@@ -893,15 +1143,22 @@ impl Layout {
         true
     }
 
-    /// Update the layout with the latest information from the database; for
-    /// now, an update only changes the `is_account_like` flag for tables or
-    /// the layout's site. If no update is needed, just return `self`.
-    pub fn refresh(
+    /// Update the layout with the latest information from the database; an
+    /// update can only change the `is_account_like` flag for tables, the
+    /// layout's site, or the `history_blocks`. If no update is needed, just
+    /// return `self`.
+    ///
+    /// 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
+    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 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()) };
 
         let changed_tables: Vec<_> = self
@@ -909,9 +1166,10 @@ impl Layout {
             .values()
             .filter(|table| table.is_account_like != is_account_like(table.as_ref()))
             .collect();
-        if changed_tables.is_empty() && site == self.site {
+        if changed_tables.is_empty() && site == self.site && history_blocks == self.history_blocks {
             return Ok(self);
         }
+
         let mut layout = (*self).clone();
         for table in changed_tables.into_iter() {
             let mut table = (*table.as_ref()).clone();
@@ -919,8 +1177,160 @@ impl Layout {
             layout.tables.insert(table.object.clone(), Arc::new(table));
         }
         layout.site = site;
+        layout.history_blocks = history_blocks;
         Ok(Arc::new(layout))
     }
+
+    /// 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: &mut AsyncPgConnection,
+    ) -> Result<Option<BlockTime>, StoreError> {
+        Rollup::last_rollup(&self.rollups, conn).await
+    }
+
+    /// Construct `Rolllup` for each of the aggregation mappings
+    /// `schema.agg_mappings()` and return them in the same order as the
+    /// aggregation mappings
+    fn rollups(
+        tables: &HashMap<EntityType, Arc<Table>>,
+        schema: &InputSchema,
+    ) -> Result<Vec<Rollup>, StoreError> {
+        let mut rollups = Vec::new();
+        for mapping in schema.agg_mappings() {
+            let source_type = mapping.source_type(schema);
+            let source_table = tables
+                .get(&source_type)
+                .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(|| internal_error!("Table for {agg_type} is missing"))?;
+            let aggregation = mapping.aggregation(schema);
+            let rollup = Rollup::new(
+                mapping.interval,
+                aggregation,
+                source_table,
+                agg_table.cheap_clone(),
+            )?;
+            rollups.push(rollup);
+        }
+        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
+    /// buckets whose end time `end` is in `last_rollup < end <=
+    /// block_time`. The rollups happen stepwise, for each entry in
+    /// `block_times` so that the buckets are associated with the block
+    /// number for those block times.
+    ///
+    /// We roll up all pending aggregations and mark them as belonging to
+    /// the block where the timestamp first fell into a new time period. We
+    /// only know about blocks where the subgraph actually performs a write.
+    /// That means that the block is not necessarily the block at the end of
+    /// the time period but might be a block after that time period if the
+    /// subgraph skips blocks. This can be a problem for time-travel queries
+    /// by block as it might not find a rollup that had occurred but is
+    /// marked with a later block; this is not an issue when writes happen
+    /// at every block. Queries for aggregations should therefore not do
+    /// time-travel by block number but rather by timestamp.
+    ///
+    /// It can also lead to unnecessarily reverting a rollup, but in that
+    /// case the results will be correct, we just do work that might not
+    /// have been necessary had we marked the rollup with the precise
+    /// smaller block number instead of the one we are using here.
+    ///
+    /// 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) async fn rollup(
+        &self,
+        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.
+        for (block, block_time) in block_times {
+            for rollup in &self.rollups {
+                let buckets = rollup.interval.buckets(last_rollup, *block_time);
+                // 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;
+        }
+        Ok(())
+    }
 }
 
 /// A user-defined enum
@@ -955,6 +1365,8 @@ pub enum ColumnType {
     BigInt,
     Bytes,
     Int,
+    Int8,
+    Timestamp,
     String,
     TSVector(FulltextConfig),
     Enum(EnumType),
@@ -965,28 +1377,50 @@ impl From<IdType> for ColumnType {
         match id_type {
             IdType::Bytes => ColumnType::Bytes,
             IdType::String => ColumnType::String,
+            IdType::Int8 => ColumnType::Int8,
+        }
+    }
+}
+
+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,
         field_type: &q::Type,
         catalog: &Catalog,
-        enums: &EnumMap,
-        id_types: &IdTypeMap,
         is_existing_text_column: bool,
     ) -> Result<ColumnType, StoreError> {
-        let name = named_type(field_type);
+        let name = field_type.get_base_type();
 
         // See if its an object type defined in the schema
-        if let Some(id_type) = id_types.get(&EntityType::new(name.to_string())) {
-            return Ok((*id_type).into());
+        if let Some(id_type) = schema
+            .entity_type(name)
+            .ok()
+            .map(|entity_type| entity_type.id_type())
+            .transpose()?
+        {
+            return Ok(id_type.into());
         }
 
         // Check if it's an enum, and if it is, return an appropriate
         // ColumnType::Enum
-        if let Some(values) = enums.get(name) {
+        if let Some(values) = schema.enum_values(name) {
             // We do things this convoluted way to make sure field_type gets
             // snakecased, but the `.` must stay a `.`
             let name = SqlName::qualified_name(&catalog.site.namespace, &SqlName::from(name));
@@ -1012,6 +1446,8 @@ impl ColumnType {
             ValueType::BigInt => Ok(ColumnType::BigInt),
             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),
         }
     }
@@ -1022,7 +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(),
@@ -1030,15 +1468,19 @@ impl ColumnType {
     }
 
     /// Return the `IdType` corresponding to this column type. This can only
-    /// be called on a column that stores an `ID` and will panic otherwise
-    pub(crate) fn id_type(&self) -> IdType {
+    /// be called on a column that stores an `ID` and will return an error
+    pub(crate) fn id_type(&self) -> QueryResult<IdType> {
         match self {
-            ColumnType::String => IdType::String,
-            ColumnType::Bytes => IdType::Bytes,
-            _ => unreachable!(
-                "only String and BytesId are allowed as primary keys but not {:?}",
-                self
-            ),
+            ColumnType::String => Ok(IdType::String),
+            ColumnType::Bytes => Ok(IdType::Bytes),
+            ColumnType::Int8 => Ok(IdType::Int8),
+            _ => Err(diesel::result::Error::QueryBuilderError(
+                anyhow!(
+                    "only String, Bytes, and Int8 are allowed as primary keys but not {:?}",
+                    self
+                )
+                .into(),
+            )),
         }
     }
 }
@@ -1046,7 +1488,7 @@ impl ColumnType {
 #[derive(Clone, Debug)]
 pub struct Column {
     pub name: SqlName,
-    pub field: String,
+    pub field: Word,
     pub field_type: q::Type,
     pub column_type: ColumnType,
     pub fulltext_fields: Option<HashSet<String>>,
@@ -1058,27 +1500,25 @@ pub struct Column {
 
 impl Column {
     fn new(
+        schema: &InputSchema,
         table_name: &SqlName,
-        field: &s::Field,
+        field: &Field,
         catalog: &Catalog,
-        enums: &EnumMap,
-        id_types: &IdTypeMap,
     ) -> Result<Column, StoreError> {
         SqlName::check_valid_identifier(&field.name, "attribute")?;
 
         let sql_name = SqlName::from(&*field.name);
-        let is_reference =
-            sql_name.as_str() != PRIMARY_KEY_COLUMN && is_object_type(&field.field_type, enums);
+
+        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()
         } else {
             let is_existing_text_column = catalog.is_existing_text_column(table_name, &sql_name);
             ColumnType::from_field_type(
+                schema,
                 &field.field_type,
                 catalog,
-                enums,
-                id_types,
                 is_existing_text_column,
             )?
         };
@@ -1112,13 +1552,28 @@ 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());
 
         Ok(Column {
             name: sql_name,
-            field: def.name.to_string(),
+            field: Word::from(def.name.to_string()),
             field_type: q::Type::NamedType("fulltext".to_string()),
             column_type: ColumnType::TSVector(def.config.clone()),
             fulltext_fields: Some(def.included_fields.clone()),
@@ -1132,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 {
@@ -1150,7 +1599,7 @@ impl Column {
     }
 
     pub fn is_fulltext(&self) -> bool {
-        named_type(&self.field_type) == "fulltext"
+        self.field_type.get_base_type() == "fulltext"
     }
 
     pub fn is_reference(&self) -> bool {
@@ -1199,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,
@@ -1225,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,
@@ -1232,30 +1689,35 @@ pub struct Table {
 
 impl Table {
     fn new(
-        defn: &s::ObjectType,
+        schema: &InputSchema,
+        defn: &EntityType,
         catalog: &Catalog,
         fulltexts: Vec<FulltextDefinition>,
-        enums: &EnumMap,
-        id_types: &IdTypeMap,
         position: u32,
         has_causality_region: bool,
     ) -> Result<Table, StoreError> {
-        SqlName::check_valid_identifier(&defn.name, "object")?;
+        SqlName::check_valid_identifier(defn.as_str(), "object")?;
 
-        let table_name = SqlName::from(&*defn.name);
-        let columns = defn
+        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
             .iter()
             .filter(|field| !field.is_derived())
-            .map(|field| Column::new(&table_name, field, catalog, enums, id_types))
+            .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: EntityType::from(defn),
+            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
@@ -1264,6 +1726,7 @@ impl Table {
             columns,
             position,
             immutable,
+            skip_duplicates,
             has_causality_region,
         };
         Ok(table)
@@ -1274,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,
         };
 
@@ -1287,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> {
@@ -1334,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(())
     }
 
@@ -1348,24 +1822,12 @@ impl Table {
             &crate::block_range::BLOCK_RANGE_COLUMN_SQL
         }
     }
-}
 
-/// Return the enclosed named type for a field type, i.e., the type after
-/// stripping List and NonNull.
-fn named_type(field_type: &q::Type) -> &str {
-    match field_type {
-        q::Type::NamedType(name) => name.as_str(),
-        q::Type::ListType(child) => named_type(child),
-        q::Type::NonNullType(child) => named_type(child),
+    pub fn dsl_table(&self) -> dsl::Table<'_> {
+        dsl::Table::new(self)
     }
 }
 
-fn is_object_type(field_type: &q::Type, enums: &EnumMap) -> bool {
-    let name = named_type(field_type);
-
-    !enums.contains_key(name) && !ValueType::is_scalar(name)
-}
-
 #[derive(Clone)]
 struct CacheEntry {
     value: Arc<Layout>,
@@ -1381,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 {
@@ -1389,20 +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())?;
-        let has_causality_region = deployment::entities_with_causality_region(conn, site.id)?;
-        let catalog = Catalog::load(conn, site.clone(), use_bytea_prefix, has_causality_region)?;
+    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).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,
@@ -1425,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();
@@ -1436,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
@@ -1448,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
             }
         }
     }
@@ -1491,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 5b20be43d29..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;
+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::{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,17 +40,19 @@ 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(&mut out)?;
+            table.as_ddl(&self.input_schema, &creat, &mut out)?;
         }
 
         Ok(out)
     }
 
     pub(crate) fn write_enum_ddl(&self, out: &mut dyn Write) -> Result<(), fmt::Error> {
-        for (name, values) in &self.enums {
+        for name in self.input_schema.enum_types() {
+            let values = self.input_schema.enum_values(name).unwrap();
             let mut sep = "";
-            let name = SqlName::from(name.as_str());
+            let name = SqlName::from(name);
             write!(
                 out,
                 "create type {}.{}\n    as enum (",
@@ -107,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})
@@ -120,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
             )
@@ -128,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
             )?;
 
@@ -142,17 +155,28 @@ impl Table {
         }
     }
 
-    fn create_time_travel_indexes(&self, out: &mut String) -> fmt::Result {
+    /// 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}, vid);\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
@@ -175,99 +199,210 @@ 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), coalesce(upper(block_range), {block_max}), vid);\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
     }
 
-    fn create_attribute_indexes(&self, out: &mut String) -> fmt::Result {
-        // Create indexes. 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 #1330)
-        for (i, column) in self
-            .columns
-            .iter()
-            .filter(|col| !(col.is_list() && col.is_enum()))
-            .enumerate()
-        {
-            if self.immutable && column.is_primary_key() {
-                // We create a unique index on `id` in `create_table`
-                // and don't need an explicit attribute index
-                continue;
+    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 {
+            column.name.quoted()
+        };
 
-            let (method, index_expr) = if column.is_reference() && !column.is_list() {
-                // For foreign keys, index the key together with the block range
-                // since we almost always also have a block_range clause in
-                // queries that look for specific foreign keys
-                if self.immutable {
-                    let index_expr = format!("{}, {}", column.name.quoted(), BLOCK_COLUMN);
-                    ("btree", index_expr)
-                } else {
-                    let index_expr = format!("{}, {}", column.name.quoted(), BLOCK_RANGE_COLUMN);
-                    ("gist", index_expr)
-                }
+        let method = if column.is_list() || column.is_fulltext() {
+            "gin".to_string()
+        } else {
+            "btree".to_string()
+        };
+
+        (method, index_expr)
+    }
+
+    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
+        // #1330)
+        let not_enum_list = |col: &&Column| !(col.is_list() && col.is_enum());
+
+        // We create a unique index on `id` in `create_table`
+        // and don't need an explicit attribute index
+        let not_immutable_pk = |col: &&Column| !(self.immutable && col.is_primary_key());
+
+        // GIN indexes on numeric types are not very useful, but expensive
+        // to build
+        let not_numeric_list = |col: &&Column| {
+            !(col.is_list()
+                && [ColumnType::BigDecimal, ColumnType::BigInt, ColumnType::Int]
+                    .contains(&col.column_type))
+        };
+
+        self.columns
+            .iter()
+            .filter(not_enum_list)
+            .filter(not_immutable_pk)
+            .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 {
-                // Attributes that are plain strings or bytes are
-                // indexed with a BTree; but they can be too large for
-                // Postgres' limit on values that can go into a BTree.
-                // For those attributes, only index the first
-                // STRING_PREFIX_SIZE or BYTE_ARRAY_PREFIX_SIZE characters
-                // see: attr-bytea-prefix
-                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
-                        ),
-                        _ => unreachable!("only String and Bytes can have arbitrary size"),
-                    }
-                } else {
-                    column.name.quoted()
-                };
-
-                let method = if column.is_list() || column.is_fulltext() {
-                    "gin"
-                } else {
-                    "btree"
-                };
-
-                (method, index_expr)
-            };
-            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_index = i,
-            column_name = column.name,
-            qname = self.qualified_name,
-            method = method,
-            index_expr = index_expr,
-        )?;
+                (
+                    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
@@ -275,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, 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(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 72a3b8bed7b..f32aa46d97e 100644
--- a/store/postgres/src/relational/ddl_tests.rs
+++ b/store/postgres/src/relational/ddl_tests.rs
@@ -3,26 +3,29 @@ 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 = Schema::parse(gql, subgraph.clone()).expect("Test schema invalid");
+    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::from_iter(["FileThing".into()]))
-        .expect("Can not create catalog");
-    Layout::new(site, &schema, catalog).expect("Failed to construct Layout")
+    let ents = {
+        match schema.entity_type("FileThing") {
+            Ok(entity_type) => BTreeSet::from_iter(vec![entity_type]),
+            Err(_) => BTreeSet::new(),
+        }
+    };
+    let catalog = Catalog::for_tests(site.clone(), ents).expect("Can not create catalog");
+    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());
 
@@ -49,11 +52,140 @@ 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() {
@@ -76,13 +208,21 @@ fn generate_ddl() {
     let layout = test_layout(FORWARD_ENUM_GQL);
     let sql = layout.as_ddl().expect("Failed to generate DDL");
     check_eqv(FORWARD_ENUM_SQL, &sql);
+
+    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]
 fn exlusion_ddl() {
     let layout = test_layout(THING_GQL);
     let table = layout
-        .table_for_entity(&EntityType::new("Thing".to_string()))
+        .table_for_entity(&layout.input_schema.entity_type("Thing").unwrap())
         .unwrap();
 
     // When `as_constraint` is false, just create an index
@@ -126,15 +266,16 @@ fn can_copy_from() {
 
     // We allow leaving out and adding types, and leaving out attributes
     // of existing types
-    let dest = test_layout("type Scalar { id: ID } type Other { id: ID, int: Int! }");
+    let dest =
+        test_layout("type Scalar @entity { id: ID } type Other @entity { id: ID, int: Int! }");
     assert!(dest.can_copy_from(&source).is_empty());
 
     // We allow making a non-nullable attribute nullable
-    let dest = test_layout("type Thing { id: ID! }");
+    let dest = test_layout("type Thing @entity { id: ID! }");
     assert!(dest.can_copy_from(&source).is_empty());
 
     // We can not turn a non-nullable attribute into a nullable attribute
-    let dest = test_layout("type Scalar { id: ID! }");
+    let dest = test_layout("type Scalar @entity { id: ID! }");
     assert_eq!(
         vec![
             "The attribute Scalar.id is non-nullable, but the \
@@ -144,7 +285,7 @@ fn can_copy_from() {
     );
 
     // We can not change a scalar field to an array
-    let dest = test_layout("type Scalar { id: ID, string: [String] }");
+    let dest = test_layout("type Scalar @entity { id: ID, string: [String] }");
     assert_eq!(
         vec![
             "The attribute Scalar.string has type [String], \
@@ -161,7 +302,7 @@ fn can_copy_from() {
         source.can_copy_from(&dest)
     );
     // We can not change the underlying type of a field
-    let dest = test_layout("type Scalar { id: ID, color: Int }");
+    let dest = test_layout("type Scalar @entity { id: ID, color: Int }");
     assert_eq!(
         vec![
             "The attribute Scalar.color has type Int, but \
@@ -170,8 +311,8 @@ fn can_copy_from() {
         dest.can_copy_from(&source)
     );
     // We can not change the underlying type of a field in arrays
-    let source = test_layout("type Scalar { id: ID, color: [Int!]! }");
-    let dest = test_layout("type Scalar { id: ID, color: [String!]! }");
+    let source = test_layout("type Scalar @entity { id: ID, color: [Int!]! }");
+    let dest = test_layout("type Scalar @entity { id: ID, color: [String!]! }");
     assert_eq!(
         vec![
             "The attribute Scalar.color has type [String!]!, but \
@@ -181,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!
@@ -191,7 +372,7 @@ const THING_GQL: &str = r#"
 
         enum Size { small, medium, large }
 
-        type Scalar {
+        type Scalar @entity {
             id: ID,
             bool: Boolean,
             int: Int,
@@ -201,7 +382,7 @@ const THING_GQL: &str = r#"
             bigInt: BigInt,
             color: Color,
         }
-        
+
         type FileThing @entity {
             id: ID!
         }
@@ -213,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
@@ -221,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), coalesce(upper(block_range), 2147483647), vid);
-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,
@@ -248,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), coalesce(upper(block_range), 2147483647), vid);
-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
@@ -281,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), coalesce(upper(block_range), 2147483647), vid);
-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!
@@ -319,89 +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), coalesce(upper(block_range), 2147483647), vid);
-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 index attr_0_3_musician_bands
-    on "sgd0815"."musician" using gin("bands");
-
-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), coalesce(upper(block_range), 2147483647), vid);
-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 index attr_1_2_band_original_songs
-    on "sgd0815"."band" using gin("original_songs");
-
-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$, vid);
-create index attr_2_1_song_title
-    on "sgd0815"."song" using btree(left("title", 256));
-create index attr_2_2_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), coalesce(upper(block_range), 2147483647), vid);
-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#"
@@ -425,63 +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), coalesce(upper(block_range), 2147483647), vid);
-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), coalesce(upper(block_range), 2147483647), vid);
-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), coalesce(upper(block_range), 2147483647), vid);
-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);
-create index attr_2_2_habitat_dwellers
-    on "sgd0815"."habitat" using gin("dwellers");
+    );
 
+    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(
@@ -514,73 +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), coalesce(upper(block_range), 2147483647), vid);
-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), coalesce(upper(block_range), 2147483647), vid);
-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), coalesce(upper(block_range), 2147483647), vid);
-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);
-create index attr_2_2_habitat_dwellers
-    on "sgd0815"."habitat" using gin("dwellers");
+    );
 
+    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#"
@@ -596,23 +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), coalesce(upper(block_range), 2147483647), vid);
-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: Timestamp!
+    amount: BigDecimal!
+}
+
+type Stats @aggregation(intervals: ["hour", "day"], source: "Data") {
+    id:        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                  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 e95b5fc44d8..2bfb7e6c9c9 100644
--- a/store/postgres/src/relational/prune.rs
+++ b/store/postgres/src/relational/prune.rs
@@ -1,27 +1,29 @@
-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::PruneReporter,
-    prelude::{BlockNumber, CancelHandle, CancelToken, CancelableError, CheapClone, StoreError},
-    slog::{warn, Logger},
+    components::store::{PrunePhase, PruneReporter, PruneRequest, PruningStrategy, VersionStats},
+    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::{Layout, Namespace};
 
+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
 /// table
@@ -39,21 +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,
     ) -> 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(&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,
@@ -67,168 +73,175 @@ 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<usize, CancelableError<StoreError>> {
-        let column_list = self.column_list();
+    ) -> Result<(), CancelableError<StoreError>> {
+        let column_list = Arc::new(self.column_list());
 
         // Determine the last vid that we need to copy
-        let VidRange { min_vid, max_vid } = sql_query(format!(
-            "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.src.qualified_name,
-        ))
-        .bind::<Integer, _>(earliest_block)
-        .bind::<Integer, _>(final_block)
-        .get_result::<VidRange>(conn)?;
-
-        let mut batch_size = AdaptiveBatchSize::new(&self.src);
-        // The first vid we still need to copy
-        let mut next_vid = min_vid;
-        let mut total_rows: usize = 0;
-        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!(
-                    "insert into {dst}({column_list}) \
+        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
-                ))
-                .bind::<Integer, _>(earliest_block)
-                .bind::<Integer, _>(final_block)
-                .bind::<BigInt, _>(next_vid)
-                .bind::<BigInt, _>(&batch_size)
-                .execute(conn)
-            })?;
-            cancel.check_cancel()?;
-
-            total_rows += rows;
-            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.copy_final_batch(self.src.name.as_str(), rows, total_rows, next_vid > max_vid);
+            reporter.prune_batch(
+                self.src.name.as_str(),
+                rows,
+                PrunePhase::CopyFinal,
+                batcher.finished(),
+            );
         }
-        Ok(total_rows)
+        Ok(())
     }
 
     /// 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<usize, StoreError> {
-        let column_list = self.column_list();
+    ) -> Result<(), StoreError> {
+        let column_list = Arc::new(self.column_list());
 
         // Determine the last vid that we need to copy
-        let VidRange { min_vid, max_vid } = sql_query(format!(
-            "select coalesce(min(vid), 0) as min_vid, \
-                    coalesce(max(vid), -1) as max_vid from {src} \
-              where coalesce(upper(block_range), 2147483647) > $1 \
-              and block_range && int4range($1, null)",
-            src = self.src.qualified_name,
-        ))
-        .bind::<Integer, _>(final_block)
-        .get_result::<VidRange>(conn)?;
-
-        let mut batch_size = AdaptiveBatchSize::new(&self.src);
-        // The first vid we still need to copy
-        let mut next_vid = min_vid;
-        let mut total_rows = 0;
-        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!(
-                    "insert into {dst}({column_list}) \
+        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,
-                ))
-                .bind::<Integer, _>(final_block)
-                .bind::<BigInt, _>(next_vid)
-                .bind::<BigInt, _>(&batch_size)
-                .execute(conn)
-                .map_err(StoreError::from)
-            })?;
-
-            total_rows += rows;
-            next_vid += batch_size.size;
+                        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);
 
-            batch_size.adapt(start.elapsed());
+            tracker
+                .finish_batch(conn, &self.src, rows as i64, &batcher)
+                .await?;
 
-            reporter.copy_nonfinal_batch(
+            reporter.prune_batch(
                 self.src.name.as_str(),
                 rows,
-                total_rows,
-                next_vid > max_vid,
+                PrunePhase::CopyNonfinal,
+                batcher.finished(),
             );
         }
-        Ok(total_rows)
+        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(())
     }
@@ -242,28 +255,101 @@ impl TablePair {
 }
 
 impl Layout {
+    /// Analyze the `tables` and return `VersionStats` for all tables in
+    /// this `Layout`
+    async fn analyze_tables(
+        &self,
+        conn: &mut AsyncPgConnection,
+        reporter: &mut dyn PruneReporter,
+        mut tables: Vec<&Arc<Table>>,
+    ) -> 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).await?;
+            reporter.finish_analyze_table(table.name.as_str());
+        }
+        let stats = self.catalog.stats(conn).await?;
+
+        let analyzed: Vec<_> = tables.iter().map(|table| table.name.as_str()).collect();
+        reporter.finish_analyze(&stats, &analyzed);
+
+        Ok(stats)
+    }
+
+    /// Return statistics for the tables in this `Layout`. If `analyze_all`
+    /// is `true`, analyze all tables before getting statistics. If it is
+    /// `false`, only analyze tables that Postgres' autovacuum daemon would
+    /// consider needing analysis.
+    async fn version_stats(
+        &self,
+        conn: &mut AsyncPgConnection,
+        reporter: &mut dyn PruneReporter,
+        analyze_all: bool,
+    ) -> Result<Vec<VersionStats>, StoreError> {
+        let needs_analyze = if analyze_all {
+            vec![]
+        } else {
+            catalog::needs_autoanalyze(conn, &self.site.namespace).await?
+        };
+        let tables: Vec<_> = self
+            .tables
+            .values()
+            .filter(|table| analyze_all || needs_analyze.contains(&table.name))
+            .collect();
+
+        self.analyze_tables(conn, reporter, tables).await
+    }
+
+    /// Return all tables and the strategy to prune them withir stats whose ratio of distinct entities
+    /// to versions is less than `prune_ratio`
+    fn prunable_tables(
+        &self,
+        stats: &[VersionStats],
+        req: &PruneRequest,
+    ) -> Vec<(&Arc<Table>, PruningStrategy)> {
+        let mut prunable_tables = self
+            .tables
+            .values()
+            .filter(|table| !table.immutable)
+            .filter_map(|table| {
+                stats
+                    .iter()
+                    .find(|stats| stats.tablename == table.name.as_str())
+                    .map(|stats| (table, stats))
+            })
+            .filter_map(|(table, stats)| req.strategy(stats).map(|strat| (table, strat)))
+            .collect::<Vec<_>>();
+        prunable_tables.sort_by(|(a, _), (b, _)| a.name.as_str().cmp(b.name.as_str()));
+        prunable_tables
+    }
+
     /// Remove all data from the underlying deployment that is not needed to
-    /// respond to queries before block `earliest_block`. The strategy
-    /// implemented here works well for situations in which pruning will
-    /// remove a large amount of data from the subgraph (at least 50%)
+    /// respond to queries before block `earliest_block`. The `req` is used
+    /// to determine which strategy should be used for pruning, rebuild or
+    /// delete.
+    ///
+    /// Blocks before `req.final_block` are considered final and it is
+    /// assumed that they will not be modified in any way while pruning is
+    /// running.
     ///
-    /// Blocks before `final_block` are considered final and it is assumed
-    /// that they will not be modified in any way while pruning is running.
-    /// Only tables where the ratio of entities to entity versions is below
-    /// `prune_ratio` will actually be pruned.
+    /// The rebuild strategy implemented here works well for situations in
+    /// which pruning will remove a large amount of data from the subgraph
+    /// (say, at least 50%)
     ///
-    /// The strategy for `prune_by_copying` is to copy all data that is
-    /// needed to respond to queries at block heights at or after
-    /// `earliest_block` to a new table and then to replace the existing
-    /// tables with these new tables atomically in a transaction. Copying
-    /// happens in two stages: we first copy data for final blocks without
-    /// blocking writes, and then copy data for nonfinal blocks. The latter
-    /// blocks writes by taking a lock on the row for the deployment in
-    /// `subgraph_deployment` (via `deployment::lock`) The process for
-    /// switching to the new tables needs to take the naming of various
-    /// database objects that Postgres creates automatically into account so
-    /// that they all have the same names as the original objects to ensure
-    /// that pruning can be done again without risking name clashes.
+    /// The strategy for rebuilding is to copy all data that is needed to
+    /// respond to queries at block heights at or after `earliest_block` to
+    /// a new table and then to replace the existing tables with these new
+    /// tables atomically in a transaction. Rebuilding happens in two stages
+    /// that are performed for each table in turn: we first copy data for
+    /// final blocks without blocking writes, and then copy data for
+    /// nonfinal blocks. The latter blocks writes by taking an advisory lock
+    /// on the deployment (via `deployment::lock`) The process for switching
+    /// to the new tables needs to take the naming of various database
+    /// objects that Postgres creates automatically into account so that
+    /// they all have the same names as the original objects to ensure that
+    /// pruning can be done again without risking name clashes.
     ///
     /// The reason this strategy works well when a lot (or even the
     /// majority) of the data needs to be removed is that in the more
@@ -275,125 +361,708 @@ impl Layout {
     /// tables. But a full vacuum takes an `access exclusive` lock which
     /// prevents both reads and writes to the table, which means it would
     /// also block queries to the deployment, often for extended periods of
-    /// time. The `prune_by_copying` strategy never blocks reads, it only
-    /// ever blocks writes.
-    pub fn prune_by_copying(
-        &self,
+    /// time. The rebuild strategy never blocks reads, it only ever blocks
+    /// writes.
+    ///
+    /// 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,
-        earliest_block: BlockNumber,
-        final_block: BlockNumber,
-        prune_ratio: f64,
-        cancel: &CancelHandle,
+        conn: &mut AsyncPgConnection,
+        req: &PruneRequest,
     ) -> Result<(), CancelableError<StoreError>> {
-        // Analyze all tables and get statistics for them
-        let mut tables: Vec<_> = self.tables.values().collect();
-        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)?;
-            reporter.finish_analyze_table(table.name.as_str());
-            cancel.check_cancel()?;
+        let tracker = status::Tracker::new(conn, self.clone()).await?;
+
+        let res = self
+            .prune_inner(logger, reporter, conn, req, &tracker)
+            .await;
+
+        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?;
+            }
         }
-        let stats = catalog::stats(conn, &self.site.namespace)?;
-        reporter.finish_analyze(stats.as_slice());
 
-        // Determine which tables are prunable and create a shadow table for
-        // them via `TablePair::create`
+        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 prunable_tables = conn.transaction(|| -> Result<_, StoreError> {
-            catalog::recreate_schema(conn, dst_nsp.as_str())?;
-
-            let mut prunable_tables: Vec<TablePair> = self
-                .tables
-                .values()
-                .filter_map(|table| {
-                    stats
-                        .iter()
-                        .find(|s| s.tablename == table.name.as_str())
-                        .map(|s| (table, s))
-                })
-                .filter(|(_, stats)| stats.ratio <= prune_ratio)
-                .map(|(table, _)| {
-                    TablePair::create(
+        let mut recreate_dst_nsp = true;
+
+        // Go table by table; note that the subgraph writer can write in
+        // between the execution of the `with_lock` block below, and might
+        // therefore work with tables where some are pruned and some are not
+        // pruned yet. That does not affect correctness since we make no
+        // assumption about where the subgraph head is. If the subgraph
+        // advances during this loop, we might have an unnecessarily
+        // pessimistic but still safe value for `final_block`. We do assume
+        // that `final_block` is far enough from the subgraph head that it
+        // stays final even if a revert happens during this loop, but that
+        // 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()).await?;
+                        recreate_dst_nsp = false;
+                    }
+                    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,
-                        table.cheap_clone(),
-                        self.site.namespace.clone(),
-                        dst_nsp.clone(),
+                        reporter,
+                        tracker,
+                        req.earliest_block,
+                        req.final_block,
                     )
+                    .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,
+                        async |conn| -> Result<_, StoreError> {
+                            pair.copy_nonfinal_entities(conn, reporter, tracker, req.final_block)
+                                .await?;
+
+                            pair.switch(logger, conn).await?;
+
+                            Ok(())
+                        },
+                    )
+                    .await?;
+                    reporter.finish_switch();
+                }
+                PruningStrategy::Delete => {
+                    // Delete all entity versions whose range was closed
+                    // before `req.earliest_block`
+                    let range = VidRange::for_prune(conn, table, 0, req.earliest_block).await?;
+                    let mut batcher =
+                        VidBatcher::load(conn, &self.site.namespace, table, range).await?;
+
+                    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);
+
+                        tracker
+                            .finish_batch(conn, table, -(rows as i64), &batcher)
+                            .await?;
+
+                        reporter.prune_batch(
+                            table.name.as_str(),
+                            rows,
+                            PrunePhase::Delete,
+                            batcher.finished(),
+                        );
+                    }
+                }
+            }
+            reporter.finish_table(table.name.as_str());
+            tracker.finish_table(conn, table).await?;
+        }
+        if !recreate_dst_nsp {
+            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)
+                .await?;
+        }
+        let tables = prunable_tables.iter().map(|(table, _)| *table).collect();
+        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
                 })
-                .collect::<Result<_, _>>()?;
-            prunable_tables.sort_by(|a, b| a.src.name.as_str().cmp(b.src.name.as_str()));
-            Ok(prunable_tables)
-        })?;
-        cancel.check_cancel()?;
-
-        // Copy final entities. This can happen in parallel to indexing as
-        // that part of the table will not change
-        reporter.copy_final_start(earliest_block, final_block);
-        for table in &prunable_tables {
-            table.copy_final_entities(conn, reporter, earliest_block, final_block, cancel)?;
+                .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>,
         }
-        reporter.copy_final_finish();
+    }
 
-        let prunable_src: Vec<_> = prunable_tables
-            .iter()
-            .map(|table| table.src.clone())
-            .collect();
+    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>,
 
-        // Copy nonfinal entities, and replace the original `src` table with
-        // the smaller `dst` table
-        reporter.start_switch();
-        //  see also: deployment-lock-for-update
-        deployment::with_lock(conn, &self.site, || -> Result<_, StoreError> {
-            for table in &prunable_tables {
-                reporter.copy_nonfinal_start(table.src.name.as_str());
-                table.copy_nonfinal_entities(conn, reporter, final_block)?;
-                cancel.check_cancel().map_err(CancelableError::from)?;
+            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,
             }
+        }
 
-            for table in prunable_tables {
-                conn.transaction(|| table.switch(logger, conn))?;
-                cancel.check_cancel().map_err(CancelableError::from)?;
+        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*",
             }
+        }
+    }
 
-            Ok(())
-        })?;
-        reporter.finish_switch();
+    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())
+        }
+    }
 
-        // Get rid of the temporary prune schema
-        catalog::drop_schema(conn, dst_nsp.as_str())?;
+    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())?))
+        }
+    }
 
-        // Analyze the new tables
-        reporter.start_analyze();
-        for table in &prunable_src {
-            reporter.start_analyze_table(table.name.as_str());
-            table.analyze(conn)?;
-            reporter.finish_analyze_table(table.name.as_str());
-            cancel.check_cancel()?;
+    /// 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 })
         }
-        let stats: Vec<_> = catalog::stats(conn, &self.site.namespace)?
-            .into_iter()
-            .filter(|s| {
-                prunable_src
-                    .iter()
-                    .any(|table| *table.name.as_str() == s.tablename)
+
+        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(())
             })
-            .collect();
-        reporter.finish_analyze(stats.as_slice());
+            .await
+        }
 
-        reporter.finish_prune();
+        pub(crate) async fn start_table(
+            &self,
+            conn: &mut AsyncPgConnection,
+            table: &Table,
+        ) -> StoreResult<()> {
+            use prune_table_state as pts;
 
-        Ok(())
+            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(())
+        }
     }
-}
 
-#[derive(QueryableByName)]
-struct VidRange {
-    #[sql_type = "BigInt"]
-    min_vid: i64,
-    #[sql_type = "BigInt"]
-    max_vid: i64,
+    /// 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 acb4610b301..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::{
-    components::store::EntityType,
-    prelude::{r, serde_json as json, DeploymentHash, EntityFilter, Schema},
+    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() {
@@ -30,7 +34,7 @@ fn gql_value_from_bytes() {
 
 fn test_layout(gql: &str) -> Layout {
     let subgraph = DeploymentHash::new("subgraph").unwrap();
-    let schema = Schema::parse(gql, subgraph.clone()).expect("Test schema invalid");
+    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 =
@@ -41,16 +45,17 @@ fn test_layout(gql: &str) -> Layout {
 #[track_caller]
 fn filter_contains(filter: EntityFilter, sql: &str) {
     const SCHEMA: &str = "
-    type Thing @entity { 
+    type Thing @entity {
         id: Bytes!,
         address: Bytes!,
         name: String
     }";
     let layout = test_layout(SCHEMA);
     let table = layout
-        .table_for_entity(&EntityType::new("Thing".to_string()))
-        .unwrap();
-    let filter = QueryFilter::new(&filter, table.as_ref(), &layout, Default::default()).unwrap();
+        .table_for_entity(&layout.input_schema.entity_type("Thing").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
new file mode 100644
index 00000000000..2c1ae754e95
--- /dev/null
+++ b/store/postgres/src/relational/rollup.rs
@@ -0,0 +1,1025 @@
+//! Queries and helpers to do rollups for aggregations, i.e., the queries
+//! 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;
+use diesel::sql_types::{Integer, Nullable, Timestamptz};
+use diesel_async::RunQueryDsl;
+
+use graph::blockchain::BlockTime;
+use graph::components::store::{BlockNumber, StoreError};
+use graph::data::store::IdType;
+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_columns: Vec<&'a str>,
+    expr: String,
+    agg_column: &'a Column,
+}
+
+impl<'a> Agg<'a> {
+    fn new(
+        aggregate: &'a Aggregate,
+        src_table: &'a Table,
+        agg_table: &'a Table,
+    ) -> Result<Self, StoreError> {
+        let (expr, src_columns) = rewrite(src_table, &aggregate.arg)?;
+        let agg_column = agg_table.column_for_field(&aggregate.name)?;
+        Ok(Self {
+            aggregate,
+            src_columns,
+            expr,
+            agg_column,
+        })
+    }
+
+    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({})", 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,
+    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 {
+    pub(crate) fn new(
+        interval: AggregationInterval,
+        aggregation: &Aggregation,
+        src_table: &Table,
+        agg_table: Arc<Table>,
+    ) -> Result<Self, StoreError> {
+        let dimensions: Box<[_]> = aggregation
+            .dimensions()
+            .map(|field| src_table.column_for_field(&field.name))
+            .collect::<Result<_, _>>()?;
+        let aggregates: Box<[Agg<'_>]> = aggregation
+            .aggregates
+            .iter()
+            .map(|aggregate| Agg::new(aggregate, src_table, &agg_table))
+            .collect::<Result<_, _>>()?;
+        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,
+        })
+    }
+
+    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
+    ///
+    /// 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;
+    ///
+    ///
+    /// Bind variables:
+    ///   $1: beginning timestamp (inclusive)
+    ///   $2: end timestamp (exclusive)
+    ///   $3: block number
+    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)
+    }
+
+    /// 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")
+    }
+
+    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!(
+            w,
+            " from (select *, 1 as seq from prev union all select *, 2 as seq from bucket) u "
+        )?;
+        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!(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"),
+        }
+    }
+
+    /// 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)
+        })?;
+        comma_sep(self.aggregates, w, true, |w, agg| agg.combine("seq", w))?;
+        write!(
+            w,
+            " from (select *, 1 as seq from prev union all select *, 2 as seq from bucket) u "
+        )?;
+        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")
+    }
+
+    /// 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()
+                .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} as c where c.timestamp >= coalesce(({last_rollup}), '-infinity'::timestamptz)",
+            src_table = self.src_table,
+            last_rollup = self.last_rollup(),
+        )?;
+        write!(w, " /*FILTERS*/) c")?;
+        if !self.dimensions.is_empty() {
+            write!(w, " group by ")?;
+            write_dims(self.dimensions, w, false)?;
+        }
+        Ok(())
+    }
+}
+
+/// 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)]
+mod tests {
+    use std::{collections::BTreeSet, sync::Arc};
+
+    use graph::{data::subgraph::DeploymentHash, schema::InputSchema};
+    use itertools::Itertools as _;
+
+    use crate::{
+        layout_for_tests::{Namespace, make_dummy_site},
+        relational::{Catalog, Layout, rollup::Rollup},
+    };
+
+    // Check that the two strings are the same after replacing runs of
+    // whitespace with a single space
+    #[track_caller]
+    fn check_eqv(left: &str, right: &str) {
+        use pretty_assertions::assert_eq;
+
+        fn normalize(s: &str) -> String {
+            s.replace("\\\n", "")
+                .split_whitespace()
+                .join(" ")
+                .replace("( ", "(")
+        }
+
+        let left = normalize(left);
+        let right = normalize(right);
+        assert_eq!(left, right);
+    }
+
+    #[test]
+    fn rollup() {
+        const SCHEMA: &str = r#"
+    type Data @entity(timeseries: true) {
+        id: Int8!
+        timestamp: Timestamp!
+        token: Bytes!
+        price: BigDecimal!
+        amount: Int!
+      }
+
+      type Stats @aggregation(intervals: ["day", "hour"], source: "Data") {
+        id: Int8!
+        timestamp: Timestamp!
+        token: Bytes!
+        sum: BigDecimal! @aggregate(fn: "sum", arg: "price")
+        max: BigDecimal! @aggregate(fn: "max", arg: "amount")
+      }
+
+      type TotalStats @aggregation(intervals: ["day"], source: "Data") {
+        id: 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, date_bin('3600s', timestamp, 'epoch'::timestamptz) as timestamp, "token", "amount", "price" \
+              from "sgd007"."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, date_bin('86400s', timestamp, 'epoch'::timestamptz) as timestamp, "token", "amount", "price" \
+              from "sgd007"."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", "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
+                .rollups
+                .iter()
+                .find(|rollup| rollup.agg_table.name.as_str() == table_name)
+                .unwrap()
+        }
+
+        let hash = DeploymentHash::new("rollup").unwrap();
+        let nsp = Namespace::new("sgd007".to_string()).unwrap();
+        let schema = InputSchema::parse_latest(SCHEMA, hash.clone()).unwrap();
+        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!(6, layout.rollups.len());
+
+        // Intervals are non-decreasing
+        assert!(layout.rollups[0].interval <= layout.rollups[1].interval);
+        assert!(layout.rollups[1].interval <= layout.rollups[2].interval);
+
+        // Generated SQL is correct
+        let stats_hour = rollup_for(&layout, "stats_hour");
+        let stats_day = rollup_for(&layout, "stats_day");
+        let stats_total = rollup_for(&layout, "total_stats_day");
+        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 ea13305afb0..d87b950adc1 100644
--- a/store/postgres/src/relational_queries.rs
+++ b/store/postgres/src/relational_queries.rs
@@ -1,60 +1,89 @@
-///! 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, Integer, Jsonb, Text};
-use diesel::Connection;
-
-use graph::components::store::EntityKey;
-use graph::data::value::Word;
+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::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::{AttributeNames, EntityType},
-    data::{schema::FulltextAlgorithm, store::scalar},
+    components::store::{AggregationCurrent, AttributeNames},
+    data::store::scalar,
 };
+use inflector::Inflector;
 use itertools::Itertools;
-use std::borrow::Cow;
-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::{BoundSide, EntityBlockRange};
+use crate::parquet::convert::RestoreRow;
+use crate::relational::dsl::AtBlock;
 use crate::relational::{
-    Column, ColumnType, IdType, 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::sql_value::SqlValue;
 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
+pub(crate) const PARENT_ID: &str = "g$parent_id";
+
+/// Describes at what level a `SELECT` statement is used.
+enum SelectStatementLevel {
+    // A `SELECT` statement that is nested inside another `SELECT` statement
+    InnerStatement,
+    // The top-level `SELECT` statement
+    OuterStatement,
+}
 
 #[derive(Debug)]
 pub(crate) struct UnsupportedFilter {
     pub filter: String,
-    pub value: Value,
+    pub value: String,
 }
 
 impl Display for UnsupportedFilter {
@@ -75,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())
     }};
@@ -86,191 +115,90 @@ macro_rules! constraint_violation {
     }}
 }
 
-fn str_as_bytes(id: &str) -> QueryResult<scalar::Bytes> {
-    scalar::Bytes::from_str(id).map_err(|e| DieselError::SerializationError(Box::new(e)))
+/// 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(())
 }
 
-/// Convert Postgres string representation of bytes "\xdeadbeef"
-/// to ours of just "deadbeef".
-fn bytes_as_str(id: &str) -> String {
-    id.trim_start_matches("\\x").to_owned()
+/// This trait is here to deal with the fact that we can't implement `ToSql`
+/// for `Id` and similar types since `ToSql` can only be implemented when
+/// the SQL type of the bind parameter is known at compile time. For `Id`,
+/// 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<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()>;
 }
 
-impl IdType {
-    /// Add `ids` as a bind variable to `out`, using the right SQL type
-    fn bind_ids<S>(&self, ids: &[S], out: &mut AstPass<Pg>) -> QueryResult<()>
-    where
-        S: AsRef<str> + diesel::serialize::ToSql<Text, Pg>,
-    {
+impl PushBindParam for Id {
+    fn push_bind_param<'b>(&'b self, out: &mut AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         match self {
-            IdType::String => out.push_bind_param::<Array<Text>, _>(&ids)?,
-            IdType::Bytes => {
-                let ids = ids
-                    .iter()
-                    .map(|id| str_as_bytes(id.as_ref()))
-                    .collect::<Result<Vec<scalar::Bytes>, _>>()?;
-                let id_slices = ids.iter().map(|id| id.as_slice()).collect::<Vec<_>>();
-                out.push_bind_param::<Array<Binary>, _>(&id_slices)?;
+            Id::String(s) => out.push_bind_param::<Text, _>(s),
+            Id::Bytes(b) => {
+                let slice = b.as_slice();
+                out.push_bind_param::<Binary, _>(slice)
             }
+            Id::Int8(i) => out.push_bind_param::<Int8, _>(i),
         }
-        // Generate '::text[]' or '::bytea[]'
-        out.push_sql("::");
-        out.push_sql(self.sql_type());
-        out.push_sql("[]");
-        Ok(())
     }
 }
 
-/// 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;
-
-    /// Add `id` as a bind variable to `out`, using the right SQL type
-    fn bind_id(&self, id: &str, out: &mut AstPass<Pg>) -> QueryResult<()> {
-        match self.column_type().id_type() {
-            IdType::String => out.push_bind_param::<Text, _>(&id)?,
-            IdType::Bytes => out.push_bind_param::<Binary, _>(&str_as_bytes(id)?.as_slice())?,
-        }
-        // Generate '::text' or '::bytea'
-        out.push_sql("::");
-        out.push_sql(self.column_type().sql_type());
-        Ok(())
-    }
-
-    /// Add `ids`  as a bind variable to `out`, using the right SQL type
-    fn bind_ids<S>(&self, ids: &[S], out: &mut AstPass<Pg>) -> QueryResult<()>
-    where
-        S: AsRef<str> + diesel::serialize::ToSql<Text, Pg>,
-    {
-        self.column_type().id_type().bind_ids(ids, out)
-    }
-
-    /// Generate a clause `{name()} = $id` using the right types to bind `$id`
-    /// into `out`
-    fn eq(&self, id: &str, out: &mut AstPass<Pg>) -> QueryResult<()> {
-        out.push_sql(self.name());
-        out.push_sql(" = ");
-        self.bind_id(id, 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<S>(&self, ids: &[S], out: &mut AstPass<Pg>) -> QueryResult<()>
-    where
-        S: AsRef<str> + diesel::serialize::ToSql<Text, Pg>,
-    {
-        out.push_sql("exists (select 1 from unnest(");
-        self.bind_ids(ids, out)?;
-        out.push_sql(") as p(g$id) where id = p.g$id)");
-        Ok(())
-    }
-
-    /// Generate an array of arrays as literal SQL. The `ids` must form a
-    /// valid matrix, i.e. the same numbe of entries in each row. This can
-    /// be achieved by padding them with `None` values. Diesel does not support
-    /// arrays of arrays as bind variables, nor arrays containing nulls, so
-    /// we have to manually serialize the `ids` as literal SQL.
-    fn push_matrix(
-        &self,
-        matrix: &[Vec<Option<SafeString>>],
-        out: &mut AstPass<Pg>,
-    ) -> QueryResult<()> {
-        out.push_sql("array[");
-        if matrix.is_empty() {
-            // If there are no ids, make sure we are producing an
-            // empty array of arrays
-            out.push_sql("array[null]");
-        } else {
-            for (i, ids) in matrix.iter().enumerate() {
-                if i > 0 {
-                    out.push_sql(", ");
-                }
-                out.push_sql("array[");
-                for (j, id) in ids.iter().enumerate() {
-                    if j > 0 {
-                        out.push_sql(", ");
-                    }
-                    match id {
-                        None => out.push_sql("null"),
-                        Some(id) => match self.column_type().id_type() {
-                            IdType::String => {
-                                out.push_sql("'");
-                                out.push_sql(&id.0);
-                                out.push_sql("'");
-                            }
-                            IdType::Bytes => {
-                                out.push_sql("'\\x");
-                                out.push_sql(id.0.trim_start_matches("0x"));
-                                out.push_sql("'");
-                            }
-                        },
-                    }
-                }
-                out.push_sql("]");
-            }
+impl PushBindParam for IdList {
+    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),
+            IdList::Int8(ids) => out.push_bind_param::<Array<Int8>, _>(ids),
         }
-        // Generate '::text[][]' or '::bytea[][]'
-        out.push_sql("]::");
-        out.push_sql(self.column_type().sql_type());
-        out.push_sql("[][]");
-        Ok(())
     }
 }
 
-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;
 
-pub trait FromEntityData: std::fmt::Debug + std::default::Default {
     type Value: FromColumnValue;
 
-    fn new_entity(typename: String) -> Self;
-
-    fn insert_entity_data(&mut self, key: String, v: Self::Value);
+    fn from_data<I: Iterator<Item = Result<(Word, Self::Value), StoreError>>>(
+        schema: &InputSchema,
+        parent_id: Option<Id>,
+        iter: I,
+    ) -> Result<Self, StoreError>;
 }
 
 impl FromEntityData for Entity {
-    type Value = graph::prelude::Value;
+    const WITH_INTERNAL_KEYS: bool = false;
 
-    fn new_entity(typename: String) -> Self {
-        let mut entity = Entity::new();
-        entity.insert("__typename".to_string(), Self::Value::String(typename));
-        entity
-    }
+    type Value = graph::prelude::Value;
 
-    fn insert_entity_data(&mut self, key: String, v: Self::Value) {
-        self.insert(key, v);
+    fn from_data<I: Iterator<Item = Result<(Word, Self::Value), StoreError>>>(
+        schema: &InputSchema,
+        parent_id: Option<Id>,
+        iter: I,
+    ) -> Result<Self, StoreError> {
+        debug_assert_eq!(None, parent_id);
+        schema.try_make_entity(iter).map_err(StoreError::from)
     }
 }
 
-impl FromEntityData for BTreeMap<Word, r::Value> {
-    type Value = r::Value;
+impl FromEntityData for QueryObject {
+    const WITH_INTERNAL_KEYS: bool = true;
 
-    fn new_entity(typename: String) -> Self {
-        let mut map = BTreeMap::new();
-        map.insert("__typename".into(), Self::Value::from_string(typename));
-        map
-    }
+    type Value = r::Value;
 
-    fn insert_entity_data(&mut self, key: String, v: Self::Value) {
-        self.insert(Word::from(key), v);
+    fn from_data<I: Iterator<Item = Result<(Word, Self::Value), StoreError>>>(
+        _schema: &InputSchema,
+        parent: Option<Id>,
+        iter: I,
+    ) -> Result<Self, StoreError> {
+        let entity = <Result<Object, StoreError> as FromIterator<
+            Result<(Word, Self::Value), StoreError>,
+        >>::from_iter(iter)?;
+        Ok(QueryObject { parent, entity })
     }
 }
 
@@ -285,6 +213,8 @@ pub trait FromColumnValue: Sized + std::fmt::Debug {
 
     fn from_i32(i: i32) -> Self;
 
+    fn from_i64(i: i64) -> Self;
+
     fn from_big_decimal(d: scalar::BigDecimal) -> Self;
 
     fn from_big_int(i: serde_json::Number) -> Result<Self, StoreError>;
@@ -292,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(
@@ -314,6 +246,13 @@ pub trait FromColumnValue: Sized + std::fmt::Debug {
                     number
                 ))),
             },
+            (j::Number(number), ColumnType::Int8) => match number.as_i64() {
+                Some(i) => Ok(Self::from_i64(i)),
+                None => Err(StoreError::Unknown(anyhow!(
+                    "failed to convert {} to Int8",
+                    number
+                ))),
+            },
             (j::Number(number), ColumnType::BigDecimal) => {
                 let s = number.to_string();
                 scalar::BigDecimal::from_str(s.as_str())
@@ -336,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,
@@ -375,6 +315,10 @@ impl FromColumnValue for r::Value {
         r::Value::Int(i.into())
     }
 
+    fn from_i64(i: i64) -> Self {
+        r::Value::String(i.to_string())
+    }
+
     fn from_big_decimal(d: scalar::BigDecimal) -> Self {
         r::Value::String(d.to_string())
     }
@@ -394,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)
     }
@@ -420,6 +372,10 @@ impl FromColumnValue for graph::prelude::Value {
         graph::prelude::Value::Int(i)
     }
 
+    fn from_i64(i: i64) -> Self {
+        graph::prelude::Value::Int8(i)
+    }
+
     fn from_big_decimal(d: scalar::BigDecimal) -> Self {
         graph::prelude::Value::BigDecimal(d)
     }
@@ -436,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)
     }
@@ -445,17 +409,17 @@ 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,
 }
 
 impl EntityDeletion {
-    pub fn entity_type(&self) -> EntityType {
-        EntityType::new(self.entity.clone())
+    pub fn entity_type(&self, schema: &InputSchema) -> EntityType {
+        schema.entity_type(&self.entity).unwrap()
     }
 
     pub fn id(&self) -> &str {
@@ -467,22 +431,85 @@ impl EntityDeletion {
     }
 }
 
+pub fn parse_id(id_type: IdType, json: serde_json::Value) -> Result<Id, StoreError> {
+    const HEX_PREFIX: &str = "\\x";
+    if let serde_json::Value::String(s) = json {
+        let s = if s.starts_with(HEX_PREFIX) {
+            Word::from(s.trim_start_matches(HEX_PREFIX))
+        } else {
+            Word::from(s)
+        };
+        id_type.parse(s).map_err(StoreError::from)
+    } else {
+        Err(graph::internal_error!(
+            "the value {:?} can not be converted into an id of type {}",
+            json,
+            id_type
+        ))
+    }
+}
+
+#[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 entity_type(&self) -> EntityType {
-        EntityType::new(self.entity.clone())
+    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()
     }
 
     /// Map the `EntityData` using the schema information in `Layout`
@@ -490,46 +517,72 @@ impl EntityData {
         self,
         layout: &Layout,
         parent_type: Option<&ColumnType>,
-        remove_typename: bool,
     ) -> Result<T, StoreError> {
-        let entity_type = EntityType::new(self.entity);
+        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;
         match self.data {
-            j::Object(map) => {
-                let mut out = if !remove_typename {
-                    T::new_entity(entity_type.into_string())
-                } else {
-                    T::default()
-                };
-                for (key, json) in map {
-                    // Simply ignore keys that do not have an underlying table
-                    // column; those will be things like the block_range that
-                    // is used internally for versioning
-                    if key == "g$parent_id" {
+            j::Object(mut map) => {
+                let parent_id = map
+                    .remove(PARENT_ID)
+                    .and_then(|json| {
+                        if !T::WITH_INTERNAL_KEYS {
+                            return None;
+                        }
                         match &parent_type {
                             None => {
                                 // A query that does not have parents
                                 // somehow returned parent ids. We have no
                                 // idea how to deserialize that
-                                return Err(graph::constraint_violation!(
+                                Some(Err(graph::internal_error!(
                                     "query unexpectedly produces parent ids"
-                                ));
-                            }
-                            Some(parent_type) => {
-                                let value = T::Value::from_column_value(parent_type, json)?;
-                                out.insert_entity_data("g$parent_id".to_owned(), value);
+                                )))
                             }
+                            Some(parent_type) => Some(
+                                parent_type
+                                    .id_type()
+                                    .map_err(StoreError::from)
+                                    .and_then(|id_type| parse_id(id_type, json)),
+                            ),
+                        }
+                    })
+                    .transpose()?;
+                let map = map;
+                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.to_string()),
+                        )))
+                    } else {
+                        None
+                    }
+                });
+                let entries = map.into_iter().filter_map(move |(key, json)| {
+                    // Simply ignore keys that do not have an underlying
+                    // table column; those will be things like the
+                    // block_range that `select *` pulls in but that we
+                    // don't care about here
+                    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)) {
-                        let value = T::Value::from_column_value(&column.column_type, json)?;
-                        if !value.is_null() {
-                            out.insert_entity_data(column.field.clone(), value);
+                        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))),
+                            Err(e) => Some(Err(e)),
                         }
+                    } else {
+                        None
                     }
-                }
-                Ok(out)
+                });
+                T::from_data(&layout.input_schema, parent_id, typname.chain(entries))
             }
             _ => unreachable!(
                 "we use `to_json` in our queries, and will therefore always get an object back"
@@ -538,17 +591,147 @@ 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::Enum(enum_type) => {
                     out.push_bind_param::<Text, _>(s)?;
@@ -562,37 +745,38 @@ 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::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) => {
-                let sql_values = SqlValue::new_array(values.clone());
+            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>, _>(&sql_values),
-                    ColumnType::Bytes => out.push_bind_param::<Array<Binary>, _>(&sql_values),
-                    ColumnType::Int => out.push_bind_param::<Array<Integer>, _>(&sql_values),
-                    ColumnType::String => out.push_bind_param::<Array<Text>, _>(&sql_values),
+                    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::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>, _>(&sql_values)?;
+                        out.push_bind_param::<Array<Text>, _>(values)?;
                         out.push_sql("::");
                         out.push_sql(enum_type.name.as_str());
                         out.push_sql("[]");
@@ -600,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 sql_values.is_empty() {
-                            out.push_sql("''::tsvector");
-                        } else {
-                            out.push_sql("(");
-                            for (i, value) in sql_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,
@@ -658,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()
             )),
         }
@@ -681,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(")");
@@ -701,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(")");
@@ -762,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
@@ -814,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()
             )
         })?;
@@ -869,396 +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::QueryExecutionError(
-                        "Child filters can not be nested".to_string(),
-                    ));
-                }
+impl<'a> QueryFragment<Pg> for QueryChild<'a> {
+    fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
 
-                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())?;
+        let QueryChild {
+            parent_column,
+            child_from,
+            child_column,
+            child_filter,
+            derived,
+            at_block,
+        } = self;
+        let derived = *derived;
 
-                    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, _)
-            | 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");
-
-        let child_prefix = "i.";
-        let parent_prefix = "c.";
-
-        out.push_sql("exists (select 1 from ");
-        out.push_sql(child_table.qualified_name.as_str());
-        out.push_sql(" as i");
+        out.push_sql("exists (select 1 from ");
+        child_from.walk_ast(out.reborrow())?;
 
         out.push_sql(" where ");
 
         // 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();
-
-            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)?;
+        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::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::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(());
@@ -1277,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 {
@@ -1299,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,
                 })
             {
@@ -1312,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(")");
         }
@@ -1340,181 +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::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)?,
-
-            Equal(attr, value) => self.equals(attr, value, c::Equal, out)?,
-            Not(attr, value) => self.equals(attr, value, c::NotEqual, out)?,
-
-            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)?,
-
-            In(attr, values) => self.in_array(attr, values, false, out)?,
-            NotIn(attr, values) => self.in_array(attr, values, true, out)?,
+        use Filter::*;
+        match self {
+            And(filters) => Self::binary_op(filters, " and ", " true ", out)?,
+            Or(filters) => Self::binary_op(filters, " or ", " false ", out)?,
 
-            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)?
+            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)?;
             }
-            ChangeBlockGte(block_number) => self.filter_block_gte(block_number, out)?,
-            Child(child) => self.child(
-                &child.attr,
-                &child.entity_type,
-                &child.filter,
-                child.derived,
-                out,
-            )?,
+            ChangeBlockGte(changed_since) => changed_since.walk_ast(out.reborrow())?,
+            Child(child) => child.walk_ast(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,
+#[derive(Debug, Clone)]
+pub struct FindRangeQuery<'a> {
+    tables: &'a Vec<&'a Table>,
+    causality_region: CausalityRegion,
+    bound_side: BoundSide,
+    imm_range: EntityBlockRange,
+    mut_range: EntityBlockRange,
 }
 
-impl<'a> QueryFragment<Pg> for FindQuery<'a> {
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+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,
+        }
+    }
+}
+
+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;
 
-        let EntityKey {
-            entity_type: _,
-            entity_id,
-            causality_region,
-        } = self.key;
+        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
-        //      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(entity_id, &mut out)?;
-        out.push_sql(" and ");
-        if self.table.has_causality_region {
-            out.push_sql("causality_region = ");
-            out.push_bind_param::<Integer, _>(causality_region)?;
-            out.push_sql(" and ");
+                // 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)?;
+                }
+            }
         }
-        BlockRangeColumn::new(self.table, "e.", self.block).contains(&mut out)
+
+        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");
+        }
+
+        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() {
@@ -1522,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(())
@@ -1540,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> {}
@@ -1556,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() {
@@ -1572,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, ");
@@ -1583,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(())
@@ -1596,26 +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) _namespace: &'a Namespace,
-    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), Vec<String>>,
-    pub(crate) block: BlockNumber,
+    pub(crate) ids_for_type: &'a BTreeMap<(EntityType, CausalityRegion), IdList>,
+}
+
+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
@@ -1626,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)?;
+            br_column.contains(&mut out, true)?;
         }
         Ok(())
     }
@@ -1657,77 +2182,309 @@ 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)]
+pub struct FindDerivedQuery<'a> {
+    table: &'a Table,
+    derived_query: &'a DerivedEntityQuery,
+    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<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
+        out.unsafe_to_cache_prepared();
+
+        let DerivedEntityQuery {
+            entity_type: _,
+            entity_field,
+            value: entity_id,
+            causality_region,
+        } = self.derived_query;
+
+        // Generate
+        //    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_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 ");
+        // 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())?;
+        out.push_sql(" = ");
+        entity_id.push_bind_param(&mut out)?;
+        out.push_sql(" and ");
+        if self.table.has_causality_region {
+            out.push_sql("causality_region = ");
+            out.push_bind_param::<Integer, _>(causality_region)?;
+            out.push_sql(" and ");
+        }
+        self.br_column.contains(&mut out, false)
+    }
+}
+
+impl<'a> QueryId for FindDerivedQuery<'a> {
+    type QueryId = ();
+
+    const HAS_STATIC_QUERY_ID: bool = false;
+}
+
+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)]
+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(())
+            }
+        }
+    }
+}
+
+/// 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()
+                    .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,
+        })
     }
 }
 
-impl<'a, Conn> RunQueryDsl<Conn> for FindManyQuery<'a> {}
-
 #[derive(Debug)]
 pub struct InsertQuery<'a> {
     table: &'a Table,
-    entities: &'a [(&'a EntityKey, Cow<'a, Entity>)],
+    rows: Vec<InsertRow<'a>>,
     unique_columns: Vec<&'a Column>,
-    br_column: BlockRangeColumn<'a>,
 }
 
 impl<'a> InsertQuery<'a> {
-    pub fn new(
-        table: &'a Table,
-        entities: &'a mut [(&'a EntityKey, Cow<Entity>)],
-        block: BlockNumber,
-    ) -> Result<InsertQuery<'a>, StoreError> {
-        for (entity_key, entity) in entities.iter_mut() {
+    pub fn new(table: &'a Table, rows: &'a WriteChunk<'a>) -> Result<InsertQuery<'a>, StoreError> {
+        for row in rows {
             for column in table.columns.iter() {
-                if let Some(fields) = column.fulltext_fields.as_ref() {
-                    let fulltext_field_values = fields
-                        .iter()
-                        .filter_map(|field| entity.get(field))
-                        .cloned()
-                        .collect::<Vec<Value>>();
-                    if !fulltext_field_values.is_empty() {
-                        entity
-                            .to_mut()
-                            .insert(column.field.to_string(), Value::List(fulltext_field_values));
-                    }
-                }
-                if !column.is_nullable() && !entity.contains_key(&column.field) {
+                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.",
-                    entity_key.entity_type, entity_key.entity_id, column.field
-                )));
+                        table.object, row.id, column.field
+                    )));
                 }
             }
         }
-        let unique_columns = InsertQuery::unique_columns(table, entities);
-        let br_column = BlockRangeColumn::new(table, "", block);
+
+        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,
-            entities,
+            rows,
             unique_columns,
-            br_column,
         })
     }
 
-    /// 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,
-        entities: &'a [(&'a EntityKey, Cow<'a, Entity>)],
-    ) -> Vec<&'a Column> {
-        let mut hashmap = HashMap::new();
-        for (_key, entity) in entities.iter() {
-            for column in &table.columns {
-                if entity.get(&column.field).is_some() {
-                    hashmap.entry(column.name.as_str()).or_insert(column);
-                }
-            }
-        }
-        hashmap.into_values().collect()
+        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 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()
+                    }
+                })
+            })
+            .collect()
     }
 
     /// Return the maximum number of entities that can be inserted with one
@@ -1736,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
@@ -1754,9 +2518,12 @@ impl<'a> InsertQuery<'a> {
 }
 
 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
@@ -1775,43 +2542,45 @@ impl<'a> QueryFragment<Pg> for InsertQuery<'a> {
             out.push_identifier(column.name.as_str())?;
             out.push_sql(", ");
         }
-        self.br_column.name(&mut out);
+        out.push_sql(self.table.block_column().as_str());
+
         if self.table.has_causality_region {
             out.push_sql(", ");
             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.entities.iter().peekable();
-        while let Some((key, entity)) = 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 {
-                // If the column name is not within this entity's fields, we will issue the
-                // null value in its place
-                if let Some(value) = entity.get(&column.field) {
-                    QueryValue(value, &column.column_type).walk_ast(out.reborrow())?;
-                } else {
-                    out.push_sql("null");
-                }
+            for iv in &row.values {
+                iv.walk_ast(out.reborrow())?;
                 out.push_sql(", ");
             }
-            self.br_column.literal_range_current(&mut out)?;
+            row.br_value.walk_ast(out.reborrow())?;
             if self.table.has_causality_region {
                 out.push_sql(", ");
-                out.push_bind_param::<Integer, _>(&key.causality_region)?;
+                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");
         }
-        out.push_sql("\nreturning ");
-        out.push_sql(PRIMARY_KEY_COLUMN);
-        out.push_sql("::text");
 
         Ok(())
     }
@@ -1823,47 +2592,36 @@ impl<'a> QueryId for InsertQuery<'a> {
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, ReturnedEntityData> for InsertQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<ReturnedEntityData>> {
-        conn.query_by_name(&self)
-            .map(|data| ReturnedEntityData::bytes_as_str(self.table, data))
-    }
-}
-
 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 str,
+    ids: IdList,
 }
-impl<'a> ConflictingEntityQuery<'a> {
+impl<'a> ConflictingEntitiesQuery<'a> {
     pub fn new(
         layout: &'a Layout,
-        entities: Vec<EntityType>,
-        entity_id: &'a str,
+        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() {
@@ -1871,85 +2629,50 @@ 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 = ");
-            table.primary_key().bind_id(self.entity_id, &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> {}
-
-/// A string where we have checked that it is safe to embed it literally
-/// in a string in a SQL query. In particular, we have escaped any use
-/// of the string delimiter `'`.
-///
-/// This is only needed for `ParentIds::List` since we can't send those to
-/// the database as a bind variable, and therefore need to embed them in
-/// the query literally
-#[derive(Debug, Clone)]
-struct SafeString(String);
+impl<'a, Conn> RunQueryDsl<Conn> for ConflictingEntitiesQuery<'a> {}
 
-/// A `ParentLink` where we've made sure for the `List` variant that each
-/// `Vec<Option<String>>` has the same length
-/// Use the provided constructors to make sure this invariant holds
 #[derive(Debug, Clone)]
 enum ParentIds {
-    List(Vec<Vec<Option<SafeString>>>),
-    Scalar(Vec<String>),
+    List(Vec<IdList>),
+    Scalar(IdList),
 }
 
 impl ParentIds {
-    fn new(link: ParentLink) -> Self {
-        match link {
+    fn new(link: ParentLink) -> Result<Self, QueryExecutionError> {
+        let link = match link {
             ParentLink::Scalar(child_ids) => ParentIds::Scalar(child_ids),
-            ParentLink::List(child_ids) => {
-                // Postgres will only accept child_ids, which is a Vec<Vec<String>>
-                // if all Vec<String> are the same length. We therefore pad
-                // shorter ones with None, which become nulls in the database
-                let maxlen = child_ids.iter().map(|ids| ids.len()).max().unwrap_or(0);
-                let child_ids = child_ids
-                    .into_iter()
-                    .map(|ids| {
-                        let mut ids: Vec<_> = ids
-                            .into_iter()
-                            .map(|s| {
-                                if s.contains('\'') {
-                                    SafeString(s.replace('\'', "''"))
-                                } else {
-                                    SafeString(s)
-                                }
-                            })
-                            .map(Some)
-                            .collect();
-                        ids.resize_with(maxlen, || None);
-                        ids
-                    })
-                    .collect();
-                ParentIds::List(child_ids)
-            }
-        }
+            ParentLink::List(child_ids) => ParentIds::List(child_ids),
+        };
+        Ok(link)
     }
 }
 
@@ -1957,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),
 }
@@ -1965,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 {
@@ -1975,7 +2698,10 @@ impl<'a> TableLink<'a> {
             }
             EntityLink::Parent(parent_type, parent_link) => {
                 let parent_table = layout.table_for_entity(&parent_type)?;
-                Ok(TableLink::Parent(parent_table, ParentIds::new(parent_link)))
+                Ok(TableLink::Parent(
+                    parent_table,
+                    ParentIds::new(parent_link)?,
+                ))
             }
         }
     }
@@ -1986,64 +2712,65 @@ 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)?;
-            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
     /// column must have the same type as the primary key of the parent
     /// table, we can deduce the correct `IdType` that way
-    ids: Vec<String>,
+    ids: IdList,
     /// How to filter by a set of parents
     link: TableLink<'a>,
     column_names: AttributeNames,
+    at_block: AtBlock<'a>,
 }
 
 impl<'a> FilterWindow<'a> {
@@ -2059,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 {
@@ -2069,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) -> IdType {
+    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());
 
@@ -2117,29 +2849,29 @@ impl<'a> FilterWindow<'a> {
         //     order by c.{sort_key}
 
         out.push_sql("\n/* children_type_a */  from unnest(");
-        column.bind_ids(&self.ids, out)?;
+        self.ids.push_bind_param(out)?;
         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)?;
-        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());
 
@@ -2155,32 +2887,32 @@ impl<'a> FilterWindow<'a> {
         // TYPEA_BATCH_SIZE children and helps Postgres to narrow down the
         // rows it needs to pick from `children` to join with `p(id)`
         out.push_sql("\n/* child_type_a */ from unnest(");
-        column.bind_ids(&self.ids, out)?;
+        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)?;
-        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(" && ");
-            column.bind_ids(&self.ids, out)?;
+            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());
 
@@ -2196,28 +2928,28 @@ impl<'a> FilterWindow<'a> {
         //     order by c.{sort_key}
 
         out.push_sql("\n/* children_type_b */  from unnest(");
-        column.bind_ids(&self.ids, out)?;
+        self.ids.push_bind_param(out)?;
         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)?;
-        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());
 
@@ -2228,65 +2960,92 @@ impl<'a> FilterWindow<'a> {
         //     limit {parent_ids.len} + 1
 
         out.push_sql("\n/* child_type_b */  from unnest(");
-        column.bind_ids(&self.ids, out)?;
+        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)?;
-        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,
-        parent_primary_key: &Column,
-        child_ids: &[Vec<Option<SafeString>>],
-        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<()> {
-        // Generate
-        //      from rows from (unnest({parent_ids}), reduce_dim({child_id_matrix}))
-        //                  as p(id, child_ids)
-        //           cross join lateral
-        //           (select {column names}
-        //              from children c
-        //             where c.id = any(p.child_ids)
-        //               and .. other conditions on c ..
-        //             order by c.{sort_key}
-        //             limit {first} offset {skip}) c
-        //     order by c.{sort_key}
-
-        out.push_sql("\n/* children_type_c */  from ");
-        out.push_sql("rows from (unnest(");
-        parent_primary_key.bind_ids(&self.ids, out)?;
-        out.push_sql("), reduce_dim(");
-        self.table.primary_key().push_matrix(child_ids, out)?;
-        out.push_sql(")) as p(id, child_ids)");
-        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)?;
-        limit.filter(out);
-        out.push_sql(" and c.id = any(p.child_ids)");
-        self.and_filter(out.reborrow())?;
-        limit.restrict(out)?;
-        out.push_sql(") c");
+        out.push_sql("\n/* children_type_c */ ");
+
+        // An empty `self.ids` leads to an empty `(values )` clause which is
+        // not legal SQL. In that case we generate some dummy SQL where the
+        // resulting empty table has the same structure as the one we
+        // generate when `self.ids` is not empty
+        if !self.ids.is_empty() {
+            // Generate
+            //      from (values ({parent_id}, {child_ids}), ...)
+            //                     as p(id, child_ids)
+            //           cross join lateral
+            //           (select {column names}
+            //              from children c
+            //             where c.id = any(p.child_ids)
+            //               and .. other conditions on c ..
+            //             order by c.{sort_key}
+            //             limit {first} offset {skip}) c
+            //     order by c.{sort_key}
+
+            out.push_sql("from (values ");
+            for i in 0..self.ids.len() {
+                let child_ids = &child_ids[i];
+                if i > 0 {
+                    out.push_sql(", (");
+                } else {
+                    out.push_sql("(");
+                }
+                self.ids.bind_entry(i, out)?;
+                out.push_sql(",");
+                child_ids.push_bind_param(out)?;
+                out.push_sql(")");
+            }
+            out.push_sql(") as p(id, child_ids)");
+            out.push_sql(" cross join lateral (select ");
+            write_column_names(&self.column_names, self.table, None, out)?;
+            out.push_sql(" from ");
+            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)?;
+            limit.restrict(is_outer, out)?;
+            out.push_sql(") c");
+        } else {
+            // Generate
+            //      from unnest(array[]::text[]) as p(id) cross join
+            //           (select {column names}
+            //              from children c
+            //             where false) c
+
+            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 ");
+            self.from_table.walk_ast(out.reborrow())?;
+            out.push_sql(" where false) c");
+        }
         Ok(())
     }
 
-    fn child_type_d(
-        &self,
-        child_ids: &[String],
-        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),
@@ -2295,66 +3054,60 @@ impl<'a> FilterWindow<'a> {
         //       and .. other conditions on c ..
 
         out.push_sql("\n/* child_type_d */ from rows from (unnest(");
-        out.push_bind_param::<Array<Text>, _>(&self.ids)?;
+        self.ids.push_bind_param(out)?;
         out.push_sql("), unnest(");
-        self.table.primary_key().bind_ids(child_ids, out)?;
+        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)?;
-        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 mut child_set: Vec<&str> = child_ids.iter().map(|id| id.as_str()).collect();
-            child_set.sort_unstable();
-            child_set.dedup();
-
-            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(");
-                self.table.primary_key().bind_ids(&child_set, 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(parent_table, ParentIds::List(child_ids)) => self.children_type_c(
-                parent_table.primary_key(),
-                child_ids,
-                limit,
-                block,
-                &mut out,
-            ),
+            TableLink::Parent(_, ParentIds::List(child_ids)) => {
+                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)
             }
         }
     }
@@ -2362,37 +3115,79 @@ 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("' as entity, c.id, c.vid, p.id::text as g$parent_id");
-        sort_key.select(&mut out)?;
-        self.children(ParentLimit::Outer, block, out)
+        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);
+        limit
+            .sort_key
+            .select(&mut out, SelectStatementLevel::InnerStatement)?;
+        self.children(true, limit, &mut out)
     }
 
     /// Collect all the parent id's from all windows
-    fn collect_parents(windows: &[FilterWindow]) -> Vec<String> {
-        let parent_ids: HashSet<String> =
-            HashSet::from_iter(windows.iter().flat_map(|window| window.ids.iter().cloned()));
-        parent_ids.into_iter().collect()
+    fn collect_parents(windows: &'a [FilterWindow]) -> Result<IdList, QueryExecutionError> {
+        let parent_ids: HashSet<IdRef<'a>> =
+            HashSet::from_iter(windows.iter().flat_map(|window| window.ids.iter()));
+        IdList::try_from_iter_ref(parent_ids.into_iter())
+    }
+}
+
+#[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>>, Vec<String>),
+    MultiWindow(Vec<FilterWindow<'a>>, IdList),
 }
 
 /// String representation that is useful for debugging when `walk_ast` fails
@@ -2400,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(","))?,
@@ -2419,17 +3218,20 @@ 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::*;
 
                 write!(f, "<")?;
 
+                let ids = ids.iter().map(|id| id.to_string()).collect::<Vec<_>>();
                 match link {
                     TableLink::Direct(col, Single) => {
                         write!(f, "uniq:{}={}", col.name(), ids.join(","))?
@@ -2440,12 +3242,12 @@ impl<'a> fmt::Display for FilterCollection<'a> {
                     TableLink::Parent(_, ParentIds::List(css)) => {
                         let css = css
                             .iter()
-                            .map(|cs| cs.iter().filter_map(|c| c.as_ref().map(|s| &s.0)).join(","))
+                            .map(|cs| cs.iter().map(|c| c.to_string()).join(","))
                             .join("],[");
                         write!(f, "uniq:id=[{}]", css)?
                     }
                     TableLink::Parent(_, ParentIds::Scalar(cs)) => {
-                        write!(f, "uniq:id={}", cs.join(","))?
+                        write!(f, "uniq:id={}", cs.iter().map(|c| c.to_string()).join(","))?
                     }
                 };
                 write!(f, " for {}>", ids.join(","))?;
@@ -2455,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) => {
@@ -2493,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))
@@ -2517,7 +3311,7 @@ impl<'a> FilterCollection<'a> {
                         windows.pop().expect("we just checked there is an element"),
                     )
                 } else {
-                    let parent_ids = FilterWindow::collect_parents(&windows);
+                    let parent_ids = FilterWindow::collect_parents(&windows)?;
                     FilterCollection::MultiWindow(windows, parent_ids)
                 };
                 Ok(collection)
@@ -2525,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),
         }
@@ -2543,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)
             }
         }
     }
@@ -2557,12 +3351,12 @@ impl<'a> FilterCollection<'a> {
     pub(crate) fn parent_type(&self) -> Result<Option<IdType>, StoreError> {
         match self {
             FilterCollection::All(_) => Ok(None),
-            FilterCollection::SingleWindow(window) => Ok(Some(window.parent_type())),
+            FilterCollection::SingleWindow(window) => Ok(Some(window.parent_type()?)),
             FilterCollection::MultiWindow(windows, _) => {
                 if windows.iter().map(FilterWindow::parent_type).all_equal() {
-                    Ok(Some(windows[0].parent_type()))
+                    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`"
                     ))
                 }
@@ -2573,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`
@@ -2636,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>),
@@ -2655,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,
@@ -2667,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) => {
+                ChildKey::ManyId(direction, details, UseBlockColumn::No) => {
                     details.iter().try_for_each(|details| {
-                        write!(
-                            f,
-                            "{}.{}",
-                            details.child_table.name.as_str(),
-                            PRIMARY_KEY_COLUMN
-                        )
+                        write!(f, "{}{direction}", details.child_table.primary_key())
                     })
                 }
-                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::Yes) => {
                     details.iter().try_for_each(|details| {
                         write!(
                             f,
-                            "{}.{} desc",
-                            details.child_table.name.as_str(),
-                            PRIMARY_KEY_COLUMN
+                            "{}{direction}, {}{direction}",
+                            details.child_table.primary_key(),
+                            details.child_table.block_column()
                         )
                     })
                 }
-                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::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
                     )
                 }
             },
@@ -2773,44 +3526,76 @@ 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: dsl::Column<'a>,
+            value: &'a Value,
+            direction: SortDirection,
+        ) -> Result<SortKey<'a>, QueryExecutionError> {
+            let sort_value = value.as_str();
+
+            Ok(SortKey::Key {
+                column,
+                value: sort_value,
+                direction,
+            })
+        }
+
         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() {
                 match filter {
-                    Some(EntityFilter::Equal(_, value)) => {
-                        let sort_value = value.as_str();
-
-                        Ok(SortKey::Key {
-                            column,
-                            value: sort_value,
-                            direction,
-                        })
+                    Some(EntityFilter::Fulltext(_, value)) => {
+                        sort_key_from_value(column, value, direction)
                     }
+                    Some(EntityFilter::And(vec)) => match vec.first() {
+                        Some(EntityFilter::Fulltext(_, value)) => {
+                            sort_key_from_value(column, value, direction)
+                        }
+                        _ => unreachable!(),
+                    },
                     _ => 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,
@@ -2821,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(
@@ -2839,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()
                             )
                         })?,
                     ),
@@ -2850,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(),
@@ -2861,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,
                 })))
             }
@@ -2901,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(
@@ -2923,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()
                                 )
                                     })?,
                             ),
@@ -2934,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,
-            child: EntityOrderByChildInfo,
-            entity_types: Vec<EntityType>,
-            br_column: Option<BlockRangeColumn<'a>>,
-            direction: &'static str,
-        ) -> 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 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(|asd| ChildIdDetails {
-                                parent_table: asd.parent_table,
-                                child_table: asd.child_table,
-                                parent_join_column: asd.parent_join_column,
-                                child_join_column: asd.child_join_column,
-                                prefix: asd.prefix.clone(),
-                            })
-                            .collect(),
-                            br_column,
-                        )))
-                    } else {
-                        Ok(SortKey::ChildKey(ChildKey::ManyIdDesc(
-                            build_children_vec(
-                                layout,
-                                parent_table,
-                                entity_types,
-                                child,
-                                direction,
-                            )?
-                            .iter()
-                            .map(|asd| ChildIdDetails {
-                                parent_table: asd.parent_table,
-                                child_table: asd.child_table,
-                                parent_join_column: asd.parent_join_column,
-                                child_join_column: asd.child_join_column,
-                                prefix: asd.prefix.clone(),
-                            })
-                            .collect(),
-                            br_column,
-                        )))
-                    }
-                } else {
-                    Ok(SortKey::ChildKey(ChildKey::Many(
-                        build_children_vec(layout, parent_table, entity_types, child, direction)?
-                            .iter()
-                            .map(|asd| ChildKeyDetails {
-                                parent_table: asd.parent_table,
-                                parent_join_column: asd.parent_join_column,
-                                child_table: asd.child_table,
-                                child_join_column: asd.child_join_column,
-                                sort_by_column: asd.sort_by_column,
-                                prefix: asd.prefix.clone(),
-                                direction: asd.direction,
-                            })
-                            .collect(),
-                    )))
-                }
+        fn with_child_interface_key<'a>(
+            layout: &'a Layout,
+            block: BlockNumber,
+            parent_table: dsl::Table<'a>,
+            child: EntityOrderByChildInfo,
+            entity_types: Vec<EntityType>,
+            use_block_column: UseBlockColumn,
+            direction: SortDirection,
+        ) -> Result<SortKey<'a>, QueryExecutionError> {
+            if entity_types.is_empty() {
+                return Err(QueryExecutionError::InternalError(
+                    "Cannot order by child interface with no implementing entity types".to_string(),
+                ));
+            }
+
+            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(),
+                )))
             }
         }
 
@@ -3045,58 +3835,86 @@ 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>) -> QueryResult<()> {
+    fn select<'b>(
+        &'b self,
+        out: &mut AstPass<'_, 'b, Pg>,
+        select_statement_level: SelectStatementLevel,
+    ) -> QueryResult<()> {
         match self {
-            SortKey::None => Ok(()),
-            SortKey::IdAsc(br_column) | SortKey::IdDesc(br_column) => {
+            SortKey::None => {}
+            SortKey::Id(_, br_column) => {
                 if let Some(br_column) = br_column {
                     out.push_sql(", ");
-                    br_column.name(out);
+
+                    match select_statement_level {
+                        SelectStatementLevel::InnerStatement => {
+                            br_column.walk_ast(out.reborrow())?;
+                            out.push_sql(" as ");
+                            out.push_sql(SORT_KEY_COLUMN);
+                        }
+                        SelectStatementLevel::OuterStatement => out.push_sql(SORT_KEY_COLUMN),
+                    }
                 }
-                Ok(())
             }
             SortKey::Key {
                 column,
@@ -3104,82 +3922,94 @@ 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(", ");
+                        column.walk_ast(out.reborrow())?;
+                        out.push_sql(" as ");
+                        out.push_sql(SORT_KEY_COLUMN);
+                    }
+                    SelectStatementLevel::OuterStatement => {
+                        out.push_sql(", ");
+                        out.push_sql(SORT_KEY_COLUMN);
+                    }
                 }
-                out.push_sql(", c.");
-                out.push_identifier(column.name.as_str())?;
-                Ok(())
             }
             SortKey::ChildKey(nested) => {
                 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(", ");
+                                child.sort_by_column.walk_ast(out.reborrow())?;
+                            }
+                            SelectStatementLevel::OuterStatement => {
+                                out.push_sql(", ");
+                                out.push_sql(SORT_KEY_COLUMN);
+                            }
                         }
-                        out.push_sql(", ");
-                        out.push_sql(child.prefix.as_str());
-                        out.push_sql(".");
-                        out.push_identifier(child.sort_by_column.name.as_str())?;
                     }
-                    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  */ }
                 }
 
-                Ok(())
+                if let SelectStatementLevel::InnerStatement = select_statement_level {
+                    out.push_sql(" as ");
+                    out.push_sql(SORT_KEY_COLUMN);
+                }
             }
         }
+        Ok(())
     }
 
     /// Generate
     ///   order by [name direction], id
-    fn order_by(&self, out: &mut AstPass<Pg>) -> 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 {
-                    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 {
-                    out.push_sql(", ");
-                    br_column.bare_name(out);
-                    out.push_sql(" desc");
+                    if use_sort_key_alias {
+                        out.push_sql(", ");
+                        out.push_sql(SORT_KEY_COLUMN);
+                    } else {
+                        out.push_sql(", ");
+                        out.push_sql(br_column.name());
+                    }
+                    out.push_sql(direction.as_sql());
                 }
                 Ok(())
             }
@@ -3189,66 +4019,37 @@ impl<'a> SortKey<'a> {
                 direction,
             } => {
                 out.push_sql("order by ");
-                SortKey::sort_expr(column, value, direction, None, None, 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(parent_pk, children) => SortKey::multi_sort_expr(
+                        parent_pk,
+                        children,
+                        &children.first().unwrap().direction,
                         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::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(())
                     }
@@ -3259,17 +4060,26 @@ impl<'a> SortKey<'a> {
 
     /// Generate
     ///   order by g$parent_id, [name direction], id
-    fn order_by_parent(&self, out: &mut AstPass<Pg>) -> QueryResult<()> {
+    /// 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<'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(", ");
+        }
+
         match self {
             SortKey::None => Ok(()),
-            SortKey::IdAsc(_) => {
-                out.push_sql("order by g$parent_id, ");
-                out.push_identifier(PRIMARY_KEY_COLUMN)
-            }
-            SortKey::IdDesc(_) => {
-                out.push_sql("order by g$parent_id, ");
+            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 {
@@ -3277,8 +4087,8 @@ impl<'a> SortKey<'a> {
                 value,
                 direction,
             } => {
-                out.push_sql("order by g$parent_id, ");
-                SortKey::sort_expr(column, value, direction, None, None, out)
+                order_by_parent_id(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(),
@@ -3288,19 +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>,
-        out: &mut AstPass<Pg>,
+        use_sort_key_alias: bool,
+        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>) {
@@ -3310,256 +4118,210 @@ impl<'a> SortKey<'a> {
             }
         }
 
-        match &column.column_type {
+        match column.column_type() {
             ColumnType::TSVector(config) => {
                 let algorithm = match config.algorithm {
                     FulltextAlgorithm::Rank => "ts_rank(",
                     FulltextAlgorithm::ProximityRank => "ts_rank_cd(",
                 };
                 out.push_sql(algorithm);
-                let name = column.name.as_str();
-                push_prefix(column_prefix, out);
-                out.push_identifier(name)?;
+                if use_sort_key_alias {
+                    out.push_sql(SORT_KEY_COLUMN);
+                } else {
+                    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("))");
             }
             _ => {
-                let name = column.name.as_str();
-                push_prefix(column_prefix, out);
-                out.push_identifier(name)?;
+                if use_sort_key_alias {
+                    out.push_sql(SORT_KEY_COLUMN);
+                } else {
+                    column.walk_ast(out.reborrow())?;
+                }
             }
         }
-        if ENV_VARS.store.reversible_order_by_off {
-            // Old behavior
-            out.push_sql(" ");
-            out.push_sql(direction);
-            out.push_sql(" nulls last");
-            out.push_sql(", ");
-            push_prefix(rest_prefix, out);
-            out.push_identifier(PRIMARY_KEY_COLUMN)?;
-        } else {
-            out.push_sql(" ");
-            out.push_sql(direction);
-            out.push_sql(", ");
+        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_identifier(PRIMARY_KEY_COLUMN)?;
+        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.as_sql());
+        out.push_sql(", ");
 
-        if ENV_VARS.store.reversible_order_by_off {
-            // Old behavior
-            out.push_sql(direction);
-            out.push_sql(" nulls last");
-            out.push_sql(", ");
-            push_prefix(rest_prefix, out);
-            out.push_identifier(PRIMARY_KEY_COLUMN)?;
-        } else {
-            out.push_sql(direction);
-            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(())
     }
@@ -3607,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
@@ -3620,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)?;
@@ -3639,40 +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 ");
-        BlockRangeColumn::new(table, "c.", self.block).contains(&mut out)?;
-        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())?;
         }
@@ -3680,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");
     }
 
@@ -3698,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)?;
-        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(())
     }
 
@@ -3720,32 +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 g$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)
+
+        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
@@ -3774,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");
             }
@@ -3783,44 +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)?;
-            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)?;
-        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)?;
+            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)?;
+        self.limit.sort_key.order_by(out, true)?;
         Ok(())
     }
 
     /// Multiple windows
-    fn query_window(
-        &self,
-        windows: &[FilterWindow],
-        parent_ids: &[String],
-        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
@@ -3851,19 +4768,18 @@ impl<'a> FilterQuery<'a> {
         out.push_sql("with matches as (");
         out.push_sql("select c.* from ");
         out.push_sql("unnest(");
-        // windows always has at least 2 entries
-        windows[0].parent_type().bind_ids(parent_ids, &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)?;
-        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
@@ -3878,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,
                 )
             })
@@ -3890,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)
+        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(());
@@ -3933,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)
             }
         }
     }
@@ -3955,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> {}
@@ -3966,20 +4880,20 @@ impl<'a, Conn> RunQueryDsl<Conn> for FilterQuery<'a> {}
 /// Reduce the upper bound of the current entry's block range to `block` as
 /// long as that does not result in an empty block range
 #[derive(Debug)]
-pub struct ClampRangeQuery<'a, S> {
+pub struct ClampRangeQuery<'a> {
     table: &'a Table,
-    entity_ids: &'a [S],
+    entity_ids: &'a IdList,
     br_column: BlockRangeColumn<'a>,
 }
 
-impl<'a, S> ClampRangeQuery<'a, S> {
+impl<'a> ClampRangeQuery<'a> {
     pub fn new(
         table: &'a Table,
-        entity_ids: &'a [S],
+        entity_ids: &'a IdList,
         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
             ))
@@ -3994,11 +4908,8 @@ impl<'a, S> ClampRangeQuery<'a, S> {
     }
 }
 
-impl<'a, S> QueryFragment<Pg> for ClampRangeQuery<'a, S>
-where
-    S: AsRef<str> + diesel::serialize::ToSql<Text, Pg>,
-{
-    fn walk_ast(&self, mut out: AstPass<Pg>) -> QueryResult<()> {
+impl<'a> QueryFragment<Pg> for ClampRangeQuery<'a> {
+    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)
@@ -4010,7 +4921,7 @@ where
         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(")");
@@ -4019,41 +4930,22 @@ where
     }
 }
 
-impl<'a, S> QueryId for ClampRangeQuery<'a, S>
-where
-    S: AsRef<str> + diesel::serialize::ToSql<Text, Pg>,
-{
+impl<'a> QueryId for ClampRangeQuery<'a> {
     type QueryId = ();
 
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a, S, Conn> RunQueryDsl<Conn> for ClampRangeQuery<'a, S> {}
+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)]
 pub struct ReturnedEntityData {
-    #[sql_type = "Text"]
+    #[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 bytes_as_str(table: &Table, mut data: Vec<ReturnedEntityData>) -> Vec<ReturnedEntityData> {
-        match table.primary_key().column_type.id_type() {
-            IdType::String => data,
-            IdType::Bytes => {
-                for entry in data.iter_mut() {
-                    entry.id = bytes_as_str(&entry.id);
-                }
-                data
-            }
-        }
-    }
-}
-
 /// A query that removes all versions whose block range lies entirely
 /// beyond `block`.
 #[derive(Debug, Clone)]
@@ -4070,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
@@ -4094,11 +4986,8 @@ impl<'a> QueryId for RevertRemoveQuery<'a> {
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, ReturnedEntityData> for RevertRemoveQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<ReturnedEntityData>> {
-        conn.query_by_name(&self)
-            .map(|data| ReturnedEntityData::bytes_as_str(self.table, data))
-    }
+impl<'a> Query for RevertRemoveQuery<'a> {
+    type SqlType = Untyped;
 }
 
 impl<'a, Conn> RunQueryDsl<Conn> for RevertRemoveQuery<'a> {}
@@ -4113,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
             ))
@@ -4124,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
@@ -4177,11 +5066,8 @@ impl<'a> QueryId for RevertClampQuery<'a> {
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> LoadQuery<PgConnection, ReturnedEntityData> for RevertClampQuery<'a> {
-    fn internal_load(self, conn: &PgConnection) -> QueryResult<Vec<ReturnedEntityData>> {
-        conn.query_by_name(&self)
-            .map(|data| ReturnedEntityData::bytes_as_str(self.table, data))
-    }
+impl<'a> Query for RevertClampQuery<'a> {
+    type SqlType = Untyped;
 }
 
 impl<'a, Conn> RunQueryDsl<Conn> for RevertClampQuery<'a> {}
@@ -4205,6 +5091,7 @@ pub struct CopyEntityBatchQuery<'a> {
     columns: Vec<&'a Column>,
     first_vid: i64,
     last_vid: i64,
+    target_block: BlockNumber,
 }
 
 impl<'a> CopyEntityBatchQuery<'a> {
@@ -4213,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 {
@@ -4239,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("(");
@@ -4267,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 {
@@ -4312,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) {
@@ -4325,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(())
     }
 }
@@ -4350,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<()> {
@@ -4389,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 {
@@ -4422,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()
     }
@@ -4440,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
new file mode 100644
index 00000000000..d0dea82aca9
--- /dev/null
+++ b/store/postgres/src/retry.rs
@@ -0,0 +1,41 @@
+//! Helpers to retry an operation indefinitely with exponential backoff
+//! while the database is not available
+use std::time::Duration;
+
+use graph::{
+    prelude::StoreError,
+    slog::{Logger, warn},
+    util::backoff::ExponentialBackoff,
+};
+
+const BACKOFF_BASE: Duration = Duration::from_millis(100);
+const BACKOFF_CEIL: Duration = Duration::from_secs(10);
+
+fn log_backoff_warning(logger: &Logger, op: &str, backoff: &ExponentialBackoff) {
+    warn!(logger,
+            "database unavailable, will retry";
+            "operation" => op,
+            "attempt" => backoff.attempt,
+            "delay_ms" => backoff.delay().as_millis());
+}
+
+/// 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<T, F, Fut>(logger: &Logger, op: &str, f: F) -> Result<T, StoreError>
+where
+    F: Fn() -> Fut,
+    Fut: std::future::Future<Output = Result<T, StoreError>>,
+{
+    let mut backoff = ExponentialBackoff::new(BACKOFF_BASE, BACKOFF_CEIL);
+    loop {
+        match f().await {
+            Ok(v) => return Ok(v),
+            Err(StoreError::DatabaseUnavailable) => {
+                log_backoff_warning(logger, op, &backoff);
+            }
+            Err(e) => return Err(e),
+        }
+        backoff.sleep_async().await;
+    }
+}
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/sql_value.rs b/store/postgres/src/sql_value.rs
deleted file mode 100644
index 22439449f2b..00000000000
--- a/store/postgres/src/sql_value.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-use diesel::pg::Pg;
-use diesel::serialize::{self, Output, ToSql};
-use diesel::sql_types::{Binary, Bool, Integer, Text};
-use graph::prelude::anyhow::anyhow;
-use std::io::Write;
-use std::str::FromStr;
-
-use graph::data::store::{scalar, Value};
-
-#[derive(Clone, Debug, PartialEq, Eq, AsExpression)]
-pub struct SqlValue(Value);
-
-impl SqlValue {
-    pub fn new_array(values: Vec<Value>) -> Vec<Self> {
-        values.into_iter().map(SqlValue).collect()
-    }
-}
-
-impl ToSql<Bool, Pg> for SqlValue {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
-        match &self.0 {
-            Value::Bool(b) => <bool as ToSql<Bool, Pg>>::to_sql(b, out),
-            v => Err(anyhow!(
-                "Failed to convert non-boolean attribute value to boolean in SQL: {}",
-                v
-            )
-            .into()),
-        }
-    }
-}
-
-impl ToSql<Integer, Pg> for SqlValue {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
-        match &self.0 {
-            Value::Int(i) => <i32 as ToSql<Integer, Pg>>::to_sql(i, out),
-            v => Err(anyhow!(
-                "Failed to convert non-int attribute value to int in SQL: {}",
-                v
-            )
-            .into()),
-        }
-    }
-}
-
-impl ToSql<Text, Pg> for SqlValue {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
-        match &self.0 {
-            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),
-            v => Err(anyhow!(
-                "Failed to convert attribute value to String or Bytes in SQL: {}",
-                v
-            )
-            .into()),
-        }
-    }
-}
-
-impl ToSql<Binary, Pg> for SqlValue {
-    fn to_sql<W: Write>(&self, out: &mut Output<W, Pg>) -> serialize::Result {
-        match &self.0 {
-            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)
-            }
-            v => Err(anyhow!("Failed to convert attribute value to Bytes in SQL: {}", v).into()),
-        }
-    }
-}
diff --git a/store/postgres/src/store.rs b/store/postgres/src/store.rs
index 07fea71829d..2ddc926539a 100644
--- a/store/postgres/src/store.rs
+++ b/store/postgres/src/store.rs
@@ -5,18 +5,19 @@ use graph::{
     components::{
         server::index_node::VersionInfo,
         store::{
-            BlockStore as BlockStoreTrait, QueryStoreManager, StatusStore, Store as StoreTrait,
+            BlockPtrForNumber, BlockStore as BlockStoreTrait, QueryPermit, QueryStoreManager,
+            StatusStore, Store as StoreTrait,
         },
     },
-    constraint_violation,
     data::subgraph::status,
+    internal_error,
     prelude::{
-        tokio, 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.
@@ -31,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,
@@ -46,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()
     }
 }
@@ -59,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()
     }
 }
@@ -69,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,
@@ -78,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());
@@ -117,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(
@@ -155,14 +159,20 @@ impl StatusStore for Store {
         &self,
         subgraph_id: &DeploymentHash,
         block_number: BlockNumber,
+        fetch_block_ptr: &dyn BlockPtrForNumber,
     ) -> Result<Option<(PartialBlockPtr, [u8; 32])>, StoreError> {
         self.subgraph_store
-            .get_public_proof_of_indexing(subgraph_id, block_number, self.block_store().clone())
+            .get_public_proof_of_indexing(
+                subgraph_id,
+                block_number,
+                self.block_store().clone(),
+                fetch_block_ptr,
+            )
             .await
     }
 
-    async fn query_permit(&self) -> Result<tokio::sync::OwnedSemaphorePermit, 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 d60474fd1eb..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,
@@ -21,7 +22,7 @@ impl StoreEventListener {
     pub fn new(
         logger: Logger,
         postgres_url: String,
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
     ) -> (Self, Box<dyn Stream<Item = StoreEvent, Error = ()> + Send>) {
         let channel = SafeChannelName::i_promise_this_is_safe("store_events");
         let (notification_listener, receiver) =
@@ -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<dyn MetricsRegistry>) -> Self {
-        let (listener, store_events) = StoreEventListener::new(logger, postgres_url, registry);
+    pub fn new(logger: Logger, postgres_url: String, registry: Arc<MetricsRegistry>) -> Self {
+        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 9ed0ca09c12..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,42 +17,52 @@ use graph::{
     components::{
         server::index_node::VersionInfo,
         store::{
-            self, BlockStore, DeploymentLocator, DeploymentSchemaVersion,
-            EnsLookup as EnsLookupTrait, PruneReporter, SubgraphFork,
+            self, BlockPtrForNumber, BlockStore, DeploymentLocator, DeploymentSchemaVersion,
+            DumpReporter, EnsLookup as EnsLookupTrait, PruneReporter, PruneRequest,
+            RestoreReporter, SubgraphFork,
         },
     },
-    constraint_violation,
-    data::query::QueryTarget,
-    data::subgraph::{schema::DeploymentCreate, status},
-    prelude::StoreEvent,
+    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, ApiSchema,
         ApiVersion, BlockNumber, BlockPtr, ChainStore, DeploymentHash, EntityOperation, Logger,
-        MetricsRegistry, NodeId, PartialBlockPtr, Schema, StoreError, SubgraphDeploymentEntity,
-        SubgraphName, SubgraphStore as SubgraphStoreTrait, SubgraphVersionSwitchingMode,
+        MetricsRegistry, NodeId, PartialBlockPtr, StoreError, StoreEvent, SubgraphDeploymentEntity,
+        SubgraphName, SubgraphStore as SubgraphStoreTrait, SubgraphVersionSwitchingMode, anyhow,
+        lazy_static, o,
     },
+    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! {
@@ -81,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))
@@ -99,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)
     }
 }
@@ -119,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,
@@ -134,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),
     }
 }
 
@@ -172,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
@@ -188,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 {
@@ -218,13 +233,12 @@ impl SubgraphStore {
         placer: Arc<dyn DeploymentPlacer + Send + Sync + 'static>,
         sender: Arc<NotificationSender>,
         fork_base: Option<Url>,
-        registry: Arc<dyn MetricsRegistry>,
+        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,
         }
     }
 
@@ -241,27 +255,353 @@ 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
-            .get_public_proof_of_indexing(id, block_number, block_store)
+            .get_public_proof_of_indexing(id, block_number, block_store, fetch_block_ptr)
             .await
     }
 
     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
@@ -274,10 +614,14 @@ pub struct SubgraphStoreInner {
     placer: Arc<dyn DeploymentPlacer + Send + Sync + 'static>,
     sender: Arc<NotificationSender>,
     writables: Mutex<HashMap<DeploymentId, Arc<WritableStore>>>,
-    registry: Arc<dyn MetricsRegistry>,
+    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
     ///
@@ -297,8 +641,15 @@ impl SubgraphStoreInner {
         stores: Vec<(Shard, ConnectionPool, Vec<ConnectionPool>, Vec<usize>)>,
         placer: Arc<dyn DeploymentPlacer + Send + Sync + 'static>,
         sender: Arc<NotificationSender>,
-        registry: Arc<dyn MetricsRegistry>,
+        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
@@ -315,6 +666,7 @@ impl SubgraphStoreInner {
                     name,
                     Arc::new(DeploymentStore::new(
                         &logger,
+                        primary.cheap_clone(),
                         main_pool,
                         read_only_pools,
                         weights,
@@ -323,7 +675,7 @@ impl SubgraphStoreInner {
             },
         ));
         let sites = TimedCache::new(SITES_CACHE_TTL);
-        SubgraphStoreInner {
+        Inner {
             mirror,
             stores,
             sites,
@@ -331,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();
         }
@@ -345,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())
     }
 
@@ -357,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);
 
@@ -375,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
@@ -386,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);
 
@@ -403,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)
@@ -418,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,
@@ -435,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,
@@ -472,116 +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: &Schema,
-        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()
-            .map(|base| self.layout(base))
-            .transpose()?;
-
-        let (site, 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 schema_version = match &graft_base {
-                None => DeploymentSchemaVersion::LATEST,
-                Some(src_layout) => src_layout.site.schema_version,
-            };
-            let conn = self.primary_conn()?;
-            let site = conn.allocate_site(shard, &schema.id, network_name, schema_version)?;
-            let node_id = conn.assigned_node(&site)?.unwrap_or(node_id);
-            (site, node_id)
-        };
-        let site = Arc::new(site);
-
-        if let Some(graft_base) = &graft_base {
-            self.primary_conn()?
-                .record_active_copy(graft_base.site.as_ref(), site.as_ref())?;
-        }
-
-        // 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,
@@ -589,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())? {
-            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.as_ref())?;
-        if deployment.failed {
+        if let Some(node) = self.mirror.assigned_node(dst.as_ref()).await? {
             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 {
@@ -628,12 +886,13 @@ impl SubgraphStoreInner {
             graft_base: Some(src.deployment.clone()),
             graft_block: Some(block),
             debug_fork: deployment.debug_fork,
+            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
@@ -641,82 +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: &Schema,
-        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) 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))
     }
@@ -725,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(())
     }
 
@@ -764,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
@@ -785,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 => {
@@ -856,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?
             }
         };
 
@@ -873,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 {
@@ -906,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)
@@ -915,35 +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 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(
@@ -952,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
     }
 
@@ -960,28 +1247,39 @@ 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 chain_store = match block_store.chain_store(&site.network) {
-            Some(chain_store) => chain_store,
-            None => return Ok(None),
+        let block_hash = {
+            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)
+                .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
+            if hashes.len() == 1 {
+                hashes.pop().unwrap()
+            } else {
+                match fetch_block_ptr
+                    .block_ptr_for_number(site.network.clone(), block_number)
+                    .await
+                    .ok()
+                    .flatten()
+                {
+                    None => return Ok(None),
+                    Some(block_ptr) => block_ptr.hash,
+                }
+            }
         };
-        let mut hashes = chain_store.block_hashes_by_block_number(block_number)?;
-
-        // If we don't have this block or we have multiple versions of this block
-        // and using any of them could introduce non-deterministic because we don't
-        // know which one is the right one -> return no block hash
-        if hashes.is_empty() || hashes.len() > 1 {
-            return Ok(None);
-        }
-
-        // This `unwrap` is safe to do now
-        let block_hash = hashes.pop().unwrap();
 
         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?;
@@ -999,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()))
     }
@@ -1028,39 +1327,48 @@ impl SubgraphStoreInner {
         .await;
     }
 
-    pub fn analyze(
+    pub async fn refresh_materialized_views(&self, logger: &Logger) {
+        join_all(
+            self.stores
+                .values()
+                .map(|store| store.refresh_materialized_views(logger)),
+        )
+        .await;
+    }
+
+    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(
@@ -1069,10 +1377,11 @@ impl SubgraphStoreInner {
         entity_name: &str,
         field_names: Vec<String>,
         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)
+            .create_manual_index(site, entity_name, field_names, index_method, after)
             .await
     }
 
@@ -1081,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
     }
 
@@ -1090,34 +1399,83 @@ 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
     }
 
-    /// Remove the history that is only needed to respond to queries before
-    /// block number `earliest_block` from the given deployment
-    ///
-    /// Only tables with a ratio of entities to entity versions below
-    /// `prune_ratio` will be pruned; that ratio is determined by looking at
-    /// Postgres planner stats to avoid lengthy counting queries. It is
-    /// assumed that if the ratio is higher than `prune_ratio` that pruning
-    /// won't make much of a difference and will just cause unnecessary
-    /// work.
-    ///
-    /// The `reorg_threshold` is used to determine which blocks will not be
-    /// modified any more by the subgraph writer that may be running
-    /// concurrently to reduce the amount of time that the writer needs to
-    /// be locked out while pruning is happening.
+    /// Prune the history according to the parameters in `req`.
     ///
     /// Pruning can take a long time, and is structured into multiple
     /// transactions such that none of them takes an excessively long time.
@@ -1128,23 +1486,72 @@ impl SubgraphStoreInner {
         &self,
         reporter: Box<dyn PruneReporter>,
         deployment: &DeploymentLocator,
-        earliest_block: BlockNumber,
-        reorg_threshold: BlockNumber,
-        prune_ratio: f64,
+        req: PruneRequest,
     ) -> 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 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()).await?;
         let store = self.for_site(&site)?;
 
         store
-            .prune(reporter, site, earliest_block, reorg_threshold, prune_ratio)
+            .set_history_blocks(&site, history_blocks, reorg_threshold)
             .await
     }
 
-    pub fn load_deployment(&self, site: &Site) -> Result<SubgraphDeploymentEntity, StoreError> {
-        let src_store = self.for_site(site)?;
-        src_store.load_deployment(site)
+    pub async fn load_deployment(
+        &self,
+        site: Arc<Site>,
+    ) -> Result<SubgraphDeploymentEntity, StoreError> {
+        let src_store = self.for_site(&site)?;
+        src_store.load_deployment(site).await
+    }
+
+    pub async fn load_deployment_by_id(
+        &self,
+        id: DeploymentId,
+    ) -> Result<SubgraphDeploymentEntity, StoreError> {
+        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_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
     }
 }
 
@@ -1173,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),
@@ -1193,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,
@@ -1212,10 +1620,10 @@ 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: &Schema,
+        schema: &InputSchema,
         deployment: DeploymentCreate,
         node_id: NodeId,
         network_name: String,
@@ -1230,84 +1638,186 @@ 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 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 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
+    }
+
+    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
     }
 
-    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 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 assignments(&self, node: &NodeId) -> Result<Vec<DeploymentLocator>, StoreError> {
+    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.
+    async fn assignment_status(
+        &self,
+        deployment: &DeploymentLocator,
+    ) -> Result<Option<(NodeId, bool)>, StoreError> {
+        let site = self.find_site(deployment.id.into()).await?;
+        self.mirror.assignment_status(site).await
+    }
+
+    async fn active_assignments(
+        &self,
+        node: &NodeId,
+    ) -> Result<Vec<DeploymentLocator>, StoreError> {
         self.mirror
-            .assignments(node)
+            .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(
+        &self,
+        deployment: &DeploymentHash,
+    ) -> Result<Option<DeploymentFeatures>, StoreError> {
+        let deployment = deployment.to_string();
+        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<Arc<Schema>, 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(
@@ -1324,36 +1834,27 @@ impl SubgraphStoreTrait for SubgraphStore {
         self: Arc<Self>,
         logger: Logger,
         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, 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> {
@@ -1368,39 +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),
         }
     }
 
+    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()
             ));
@@ -1408,12 +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
+    }
+
+    async fn raw_manifest(
+        &self,
+        hash: &DeploymentHash,
+    ) -> Result<Option<serde_yaml::Mapping>, StoreError> {
+        let (store, site) = self.store(hash).await?;
+
+        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 28a35d6a5d3..633688aeb1a 100644
--- a/store/postgres/src/writable.rs
+++ b/store/postgres/src/writable.rs
@@ -1,36 +1,47 @@
 use std::collections::BTreeSet;
-use std::sync::atomic::{AtomicBool, Ordering};
+use std::ops::{Deref, Range};
 use std::sync::Mutex;
-use std::time::Duration;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+use graph::parking_lot::RwLock;
+use std::time::Instant;
 use std::{collections::BTreeMap, sync::Arc};
 
-use graph::blockchain::block_stream::FirehoseCursor;
-use graph::components::store::EntityKey;
-use graph::components::store::ReadStore;
+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::data::store::IdList;
 use graph::data::subgraph::schema;
 use graph::data_source::CausalityRegion;
+use graph::internal_error;
 use graph::prelude::{
-    BlockNumber, Entity, MetricsRegistry, Schema, SubgraphDeploymentEntity, SubgraphStore as _,
-    BLOCK_NUMBER_MAX,
+    BLOCK_NUMBER_MAX, BlockNumber, CacheWeight, Entity, MetricsRegistry, SubgraphDeploymentEntity,
+    SubgraphStore as _,
 };
-use graph::slog::info;
+use graph::schema::{EntityKey, EntityType, InputSchema};
+use graph::slog::{debug, info, warn};
 use graph::util::bounded_queue::BoundedQueue;
 use graph::{
     cheap_clone::CheapClone,
-    components::store::{self, EntityType, 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, warn},
-    util::backoff::ExponentialBackoff,
+    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::{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
@@ -40,24 +51,107 @@ 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()
+    }
+
+    async fn layout(&self, id: &DeploymentHash) -> Result<Arc<Layout>, StoreError> {
+        self.0.layout(id).await
+    }
+
+    async fn load_deployment(
+        &self,
+        site: Arc<Site>,
+    ) -> Result<SubgraphDeploymentEntity, StoreError> {
+        self.0.load_deployment(site).await
+    }
+
+    async fn find_site(&self, id: DeploymentId) -> Result<Arc<Site>, StoreError> {
+        self.0.find_site(id).await
+    }
+
+    async fn load_indexes(&self, site: Arc<Site>) -> Result<IndexList, StoreError> {
+        self.0.load_indexes(site).await
     }
+}
+
+#[derive(Copy, Clone)]
+pub enum LastRollup {
+    /// We do not need to track the block time since the subgraph doesn't
+    /// use timeseries
+    NotNeeded,
+    /// We do not know the block time yet
+    Unknown,
+    /// The block time
+    Some(BlockTime),
+}
 
-    pub(crate) fn send_store_event(&self, event: &StoreEvent) -> Result<(), StoreError> {
-        self.0.send_store_event(event)
+impl LastRollup {
+    async fn new(
+        store: Arc<DeploymentStore>,
+        site: Arc<Site>,
+        has_aggregations: bool,
+        block: Option<BlockNumber>,
+    ) -> Result<Self, StoreError> {
+        let kind = match (has_aggregations, block) {
+            (false, _) => LastRollup::NotNeeded,
+            (true, None) => LastRollup::Unknown,
+            (true, Some(_)) => {
+                let block_time = store.block_time(site).await?;
+                block_time
+                    .map(LastRollup::Some)
+                    .unwrap_or(LastRollup::Unknown)
+            }
+        };
+        Ok(kind)
     }
+}
 
-    fn layout(&self, id: &DeploymentHash) -> Result<Arc<Layout>, StoreError> {
-        self.0.layout(id)
+pub struct LastRollupTracker(Mutex<LastRollup>);
+
+impl LastRollupTracker {
+    async fn new(
+        store: Arc<DeploymentStore>,
+        site: Arc<Site>,
+        has_aggregations: bool,
+        block: Option<BlockNumber>,
+    ) -> Result<Self, StoreError> {
+        let rollup = LastRollup::new(
+            store.cheap_clone(),
+            site.cheap_clone(),
+            has_aggregations,
+            block,
+        )
+        .await
+        .map(Mutex::new)?;
+        Ok(Self(rollup))
     }
 
-    fn load_deployment(&self, site: &Site) -> Result<SubgraphDeploymentEntity, StoreError> {
-        self.0.load_deployment(site)
+    fn set(&self, block_time: Option<BlockTime>) -> Result<(), StoreError> {
+        let mut last = self.0.lock().unwrap();
+        match (&*last, block_time) {
+            (LastRollup::NotNeeded, _) => { /* nothing to do */ }
+            (LastRollup::Some(_) | LastRollup::Unknown, Some(block_time)) => {
+                *last = LastRollup::Some(block_time);
+            }
+            (LastRollup::Some(_) | LastRollup::Unknown, None) => {
+                internal_error!("block time cannot be unset");
+            }
+        }
+
+        Ok(())
     }
 
-    fn find_site(&self, id: DeploymentId) -> Result<Arc<Site>, StoreError> {
-        self.0.find_site(id)
+    fn get(&self) -> Option<BlockTime> {
+        let last = self.0.lock().unwrap();
+        match &*last {
+            LastRollup::NotNeeded | LastRollup::Unknown => None,
+            LastRollup::Some(block_time) => Some(*block_time),
+        }
     }
 }
 
@@ -69,91 +163,46 @@ struct SyncStore {
     store: WritableSubgraphStore,
     writable: Arc<DeploymentStore>,
     site: Arc<Site>,
-    input_schema: Arc<Schema>,
+    input_schema: InputSchema,
+    manifest_idx_and_name: Arc<Vec<(u32, String)>>,
+    last_rollup: LastRollupTracker,
 }
 
 impl SyncStore {
-    const BACKOFF_BASE: Duration = Duration::from_millis(100);
-    const BACKOFF_CEIL: Duration = Duration::from_secs(10);
-
-    fn new(
+    async fn new(
         subgraph_store: SubgraphStore,
         logger: Logger,
         site: Arc<Site>,
+        manifest_idx_and_name: Arc<Vec<(u32, String)>>,
+        block: Option<BlockNumber>,
     ) -> 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,
             store,
             writable,
             site,
             input_schema,
+            manifest_idx_and_name,
+            last_rollup,
         })
     }
-
-    fn log_backoff_warning(&self, op: &str, backoff: &ExponentialBackoff) {
-        warn!(self.logger,
-            "database unavailable, will retry";
-            "operation" => op,
-            "attempt" => backoff.attempt,
-            "delay_ms" => backoff.delay().as_millis());
-    }
-
-    fn retry<T, F>(&self, op: &str, f: F) -> Result<T, StoreError>
-    where
-        F: Fn() -> Result<T, StoreError>,
-    {
-        let mut backoff = ExponentialBackoff::new(Self::BACKOFF_BASE, Self::BACKOFF_CEIL);
-        loop {
-            match f() {
-                Ok(v) => return Ok(v),
-                Err(StoreError::DatabaseUnavailable) => {
-                    self.log_backoff_warning(op, &backoff);
-                }
-                Err(e) => return Err(e),
-            }
-            backoff.sleep();
-        }
-    }
-
-    async fn retry_async<T, F, Fut>(&self, op: &str, f: F) -> Result<T, StoreError>
-    where
-        F: Fn() -> Fut,
-        Fut: std::future::Future<Output = Result<T, StoreError>>,
-    {
-        let mut backoff = ExponentialBackoff::new(Self::BACKOFF_BASE, Self::BACKOFF_CEIL);
-        loop {
-            match f().await {
-                Ok(v) => return Ok(v),
-                Err(StoreError::DatabaseUnavailable) => {
-                    self.log_backoff_warning(op, &backoff);
-                }
-                Err(e) => return Err(e),
-            }
-            backoff.sleep_async().await;
-        }
-    }
-
-    /// 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> {
-        self.retry_async("block_ptr", || {
+        retry::forever(&self.logger, "block_ptr", || {
             let site = self.site.clone();
             async move { self.writable.block_ptr(site).await }
         })
@@ -161,67 +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> {
-        self.retry("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)?;
-                    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> {
-        self.retry("revert_block_operations", || {
-            let event = self.writable.revert_block_operations(
-                self.site.clone(),
-                block_ptr_to.clone(),
-                firehose_cursor,
-            )?;
+        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> {
-        self.retry("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> {
-        self.retry("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> {
-        self.retry_async("fail_subgraph", || {
+        retry::forever(&self.logger, "fail_subgraph", || {
             let error = error.clone();
             async {
                 self.writable
@@ -233,72 +290,77 @@ impl SyncStore {
         .await
     }
 
-    async fn supports_proof_of_indexing(&self) -> Result<bool, StoreError> {
-        self.retry_async("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> {
-        self.retry("get", || {
-            self.writable.get(self.site.cheap_clone(), key, block)
-        })
-    }
-
-    fn transact_block_operations(
+    async fn transact_block_operations(
         &self,
-        block_ptr_to: &BlockPtr,
-        firehose_cursor: &FirehoseCursor,
-        mods: &[EntityModification],
+        batch: &Batch,
         stopwatch: &StopwatchMetrics,
-        data_sources: &[StoredDynamicDataSource],
-        deterministic_errors: &[SubgraphError],
-        manifest_idx_and_name: &[(u32, String)],
-        processed_data_sources: &[StoredDynamicDataSource],
     ) -> Result<(), StoreError> {
-        self.retry("transact_block_operations", move || {
-            let event = self.writable.transact_block_operations(
-                self.site.clone(),
-                block_ptr_to,
-                firehose_cursor,
-                mods,
-                stopwatch,
-                data_sources,
-                deterministic_errors,
-                manifest_idx_and_name,
-                processed_data_sources,
-            )?;
-
-            let _section = stopwatch.start_section("send_store_event");
-            self.try_send_store_event(event)?;
-            Ok(())
+        retry::forever(&self.logger, "transact_block_operations", move || {
+            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,
     ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
-        let mut by_type: BTreeMap<(EntityType, CausalityRegion), Vec<String>> = BTreeMap::new();
+        let mut by_type: BTreeMap<(EntityType, CausalityRegion), IdList> = BTreeMap::new();
         for key in keys {
+            let id_type = key.entity_type.id_type()?;
             by_type
                 .entry((key.entity_type, key.causality_region))
-                .or_default()
-                .push(key.entity_id.into());
+                .or_insert_with(|| IdList::new(id_type))
+                .push(key.entity_id)?;
         }
 
-        self.retry("get_many", || {
+        retry::forever(&self.logger, "get_many", || async {
             self.writable
                 .get_many(self.site.cheap_clone(), &by_type, block)
+                .await
         })
+        .await
+    }
+
+    async fn get_derived(
+        &self,
+        key: &DerivedEntityQuery,
+        block: BlockNumber,
+        excluded_keys: Vec<EntityKey>,
+    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
+        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> {
-        self.retry_async("is_deployment_synced", || async {
+        retry::forever(&self.logger, "is_deployment_synced", || async {
             self.writable
                 .exists_and_synced(self.site.deployment.cheap_clone())
                 .await
@@ -306,14 +368,36 @@ impl SyncStore {
         .await
     }
 
-    fn unassign_subgraph(&self, site: &Site) -> Result<(), StoreError> {
-        self.retry("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(
@@ -321,7 +405,7 @@ impl SyncStore {
         block: BlockNumber,
         manifest_idx_and_name: Vec<(u32, String)>,
     ) -> Result<Vec<StoredDynamicDataSource>, StoreError> {
-        self.retry_async("load_dynamic_data_sources", || async {
+        retry::forever(&self.logger, "load_dynamic_data_sources", || async {
             self.writable
                 .load_dynamic_data_sources(
                     self.site.cheap_clone(),
@@ -336,7 +420,7 @@ impl SyncStore {
     pub(crate) async fn causality_region_curr_val(
         &self,
     ) -> Result<Option<CausalityRegion>, StoreError> {
-        self.retry_async("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
@@ -344,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> {
-        self.retry("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 {
@@ -394,14 +487,20 @@ impl SyncStore {
     }
 
     async fn health(&self) -> Result<schema::SubgraphHealth, StoreError> {
-        self.retry_async("health", || async {
+        retry::forever(&self.logger, "health", || async {
             self.writable.health(&self.site).await.map(Into::into)
         })
         .await
     }
 
-    fn input_schema(&self) -> Arc<Schema> {
-        self.input_schema.clone()
+    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()
     }
 }
 
@@ -411,11 +510,12 @@ impl SyncStore {
 /// number at which queries should run so that they only consider data that
 /// is not affected by any requests currently queued.
 ///
-/// The tracker relies on `update` being called in the order newest request
-/// in the queue to oldest request so that reverts are seen before the
-/// writes that they revert.
+/// The best way to use the tracker is to use the `fold_map` and `find`
+/// methods.
+#[derive(Debug)]
 struct BlockTracker {
-    /// The smallest block number that has been reverted to
+    /// The smallest block number that has been reverted to. Only writes
+    /// before this block will be visible
     revert: BlockNumber,
     /// The largest block number that is not affected by entries in the
     /// queue
@@ -430,19 +530,15 @@ impl BlockTracker {
         }
     }
 
-    fn update(&mut self, req: &Request) {
-        match req {
-            Request::Write { block_ptr, .. } => {
-                self.block = self.block.min(block_ptr.number - 1);
-            }
-            Request::RevertTo { block_ptr, .. } => {
-                // `block_ptr` is the block pointer we are reverting _to_,
-                // and is not affected by the revert
-                self.revert = self.revert.min(block_ptr.number);
-                self.block = self.block.min(block_ptr.number);
-            }
-            Request::Stop => { /* do nothing */ }
-        }
+    fn write(&mut self, block_ptr: &BlockPtr) {
+        self.block = self.block.min(block_ptr.number - 1);
+    }
+
+    fn revert(&mut self, block_ptr: &BlockPtr) {
+        // `block_ptr` is the block pointer we are reverting _to_,
+        // and is not affected by the revert
+        self.revert = self.revert.min(block_ptr.number);
+        self.block = self.block.min(block_ptr.number);
     }
 
     /// The block at which a query should run so it does not see the result
@@ -452,77 +548,319 @@ impl BlockTracker {
         self.block
     }
 
-    /// Return `true` if a write at this block will be visible, i.e., not
-    /// reverted by a previous queue entry
-    fn visible(&self, block_ptr: &BlockPtr) -> bool {
-        block_ptr.number <= self.revert
+    /// Iterate over all batches currently in the queue, from newest to
+    /// oldest, and call `f` for each batch whose changes will actually be
+    /// visible in the database once the entire queue has been processed.
+    ///
+    /// The iteration ends the first time that `f` returns `Some(_)`. The
+    /// queue will be locked during the iteration, so `f` should not do any
+    /// slow work.
+    ///
+    /// The returned `BlockNumber` is the block at which queries should run
+    /// to only consider the state of the database before any of the queued
+    /// changes have been applied.
+    fn find_map<R, F>(queue: &BoundedQueue<Arc<Request>>, f: F) -> (Option<R>, BlockNumber)
+    where
+        F: Fn(&Batch, BlockNumber) -> Option<R>,
+    {
+        let mut tracker = BlockTracker::new();
+        // Going from newest to oldest entry in the queue as `find_map` does
+        // ensures that we see reverts before we see the corresponding write
+        // request. We ignore any write request that writes blocks that have
+        // a number strictly higher than the revert with the smallest block
+        // number, as all such writes will be undone once the revert is
+        // processed.
+        let res = queue.find_map(|req| match req.as_ref() {
+            Request::Write { batch, .. } => {
+                let batch = batch.read();
+                tracker.write(&batch.block_ptr);
+                if batch.first_block <= tracker.revert {
+                    let res = f(batch.deref(), tracker.revert);
+                    if res.is_some() {
+                        return res;
+                    }
+                }
+                None
+            }
+            Request::RevertTo { block_ptr, .. } => {
+                tracker.revert(block_ptr);
+                None
+            }
+            Request::Stop => None,
+        });
+        (res, tracker.query_block())
+    }
+
+    /// Iterate over all batches currently in the queue, from newest to
+    /// oldest, and call `f` for each batch whose changes will actually be
+    /// visible in the database once the entire queue has been processed.
+    ///
+    /// Return the value that the last invocation of `f` returned, together
+    /// with the block at which queries should run to only consider the
+    /// state of the database before any of the queued changes have been
+    /// applied.
+    ///
+    /// The queue will be locked during the iteration, so `f` should not do
+    /// any slow work.
+    fn fold<F, B>(queue: &BoundedQueue<Arc<Request>>, init: B, mut f: F) -> (B, BlockNumber)
+    where
+        F: FnMut(B, &Batch, BlockNumber) -> B,
+    {
+        let mut tracker = BlockTracker::new();
+
+        let accum = queue.fold(init, |accum, req| {
+            match req.as_ref() {
+                Request::Write { batch, .. } => {
+                    let batch = batch.read();
+                    let mut accum = accum;
+                    tracker.write(&batch.block_ptr);
+                    if batch.first_block <= tracker.revert {
+                        accum = f(accum, batch.deref(), tracker.revert);
+                    }
+                    accum
+                }
+                Request::RevertTo { block_ptr, .. } => {
+                    tracker.revert(block_ptr);
+                    accum
+                }
+                Request::Stop => {
+                    /* nothing to do */
+                    accum
+                }
+            }
+        });
+        (accum, tracker.query_block())
+    }
+}
+
+/// 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,
         store: Arc<SyncStore>,
         stopwatch: StopwatchMetrics,
-        /// The block at which we are writing the changes
-        block_ptr: BlockPtr,
-        firehose_cursor: FirehoseCursor,
-        mods: Vec<EntityModification>,
-        data_sources: Vec<StoredDynamicDataSource>,
-        deterministic_errors: Vec<SubgraphError>,
-        manifest_idx_and_name: Vec<(u32, String)>,
-        processed_data_sources: Vec<StoredDynamicDataSource>,
+        // The batch is in a `RwLock` because `push_write` will try to add
+        // to the batch under the right conditions, and other operations
+        // 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<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 {
         store: Arc<SyncStore>,
         /// The subgraph head will be at this block pointer after the revert
         block_ptr: BlockPtr,
         firehose_cursor: FirehoseCursor,
+        processed: AtomicBool,
     },
     Stop,
 }
 
+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();
+                write!(
+                    f,
+                    "write[{}, {:p}, {} entities]",
+                    batch.block_ptr.number,
+                    store.as_ref(),
+                    batch.entity_count()
+                )
+            }
+            Self::RevertTo {
+                block_ptr, store, ..
+            } => write!(f, "revert[{}, {:p}]", block_ptr.number, store.as_ref()),
+            Self::Stop => write!(f, "stop"),
+        }
+    }
+}
+
 enum ExecResult {
     Continue,
     Stop,
 }
 
 impl Request {
-    fn execute(&self) -> Result<ExecResult, StoreError> {
+    fn write(store: Arc<SyncStore>, stopwatch: StopwatchMetrics, batch: Batch) -> Self {
+        Self::Write {
+            queued: Instant::now(),
+            store,
+            stopwatch,
+            batch: RwLock::new(QueuedBatch::Open(Box::new(batch))),
+            processed: AtomicBool::new(false),
+        }
+    }
+
+    fn revert(store: Arc<SyncStore>, block_ptr: BlockPtr, firehose_cursor: FirehoseCursor) -> Self {
+        Self::RevertTo {
+            store,
+            block_ptr,
+            firehose_cursor,
+            processed: AtomicBool::new(false),
+        }
+    }
+
+    fn start_process(&self) {
+        match self {
+            Request::Write { processed, .. } | Request::RevertTo { processed, .. } => {
+                processed.store(true, Ordering::SeqCst)
+            }
+            Request::Stop => { /* nothing to do  */ }
+        }
+    }
+
+    fn processed(&self) -> bool {
+        match self {
+            Request::Write { processed, .. } | Request::RevertTo { processed, .. } => {
+                processed.load(Ordering::SeqCst)
+            }
+            Request::Stop => false,
+        }
+    }
+
+    async fn execute(&self) -> Result<ExecResult, StoreError> {
         match self {
             Request::Write {
+                batch,
                 store,
                 stopwatch,
-                block_ptr: block_ptr_to,
-                firehose_cursor,
-                mods,
-                data_sources,
-                deterministic_errors,
-                manifest_idx_and_name,
-                processed_data_sources,
-            } => store
-                .transact_block_operations(
-                    block_ptr_to,
-                    firehose_cursor,
-                    mods,
-                    stopwatch,
-                    data_sources,
-                    deterministic_errors,
-                    manifest_idx_and_name,
-                    processed_data_sources,
-                )
-                .map(|()| ExecResult::Continue),
+                queued: _,
+                processed: _,
+            } => {
+                let start = Instant::now();
+
+                let batch = batch.write().close();
+
+                if let Some(err) = &batch.error {
+                    // This can happen when appending to the batch failed
+                    // 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, stopwatch)
+                    .await
+                    .map(|()| ExecResult::Continue);
+                info!(store.logger, "Committed write batch";
+                        "block_number" => batch.block_ptr.number,
+                        "block_count" => batch.block_ptr.number - batch.first_block + 1,
+                        "entities" => batch.entity_count(),
+                        "weight" => batch.weight(),
+                        "time_ms" => start.elapsed().as_millis());
+                res
+            }
             Request::RevertTo {
                 store,
                 block_ptr,
                 firehose_cursor,
+                processed: _,
             } => store
                 .revert_block_operations(block_ptr.clone(), firehose_cursor)
+                .await
                 .map(|()| ExecResult::Continue),
             Request::Stop => Ok(ExecResult::Stop),
         }
     }
+
+    /// Return `true` if we should process this request right away. Return
+    /// `false` if we should wait for a little longer with processing the
+    /// request
+    fn should_process(&self) -> bool {
+        match self {
+            Request::Write { queued, batch, .. } => {
+                batch.read().weight() >= ENV_VARS.store.write_batch_size
+                    || queued.elapsed() >= ENV_VARS.store.write_batch_duration
+            }
+            Request::RevertTo { .. } | Request::Stop => true,
+        }
+    }
+
+    fn is_write(&self) -> bool {
+        match self {
+            Request::Write { .. } => true,
+            Request::RevertTo { .. } | Request::Stop => false,
+        }
+    }
 }
 
 /// A queue that asynchronously writes requests queued with `push` to the
@@ -547,6 +885,15 @@ struct Queue {
     poisoned: AtomicBool,
 
     stopwatch: StopwatchMetrics,
+
+    /// Wether we should attempt to combine writes into large batches
+    /// spanning multiple blocks. This is initially `true` and gets set to
+    /// `false` when the subgraph is marked as synced.
+    batch_writes: AtomicBool,
+
+    /// Notify the background writer as soon as we are told to stop
+    /// batching or there is a batch that is big enough to proceed.
+    batch_ready_notify: Arc<Notify>,
 }
 
 /// Support for controlling the background writer (pause/resume) only for
@@ -555,28 +902,66 @@ struct Queue {
 /// allowed to process as many requests as it can
 #[cfg(debug_assertions)]
 pub(crate) mod test_support {
-    use std::sync::atomic::{AtomicBool, Ordering};
+    use std::{
+        collections::HashMap,
+        sync::{Arc, Mutex},
+    };
 
-    use graph::{prelude::lazy_static, util::bounded_queue::BoundedQueue};
+    use graph::{
+        components::store::{DeploymentId, DeploymentLocator},
+        prelude::lazy_static,
+        util::bounded_queue::BoundedQueue,
+    };
 
     lazy_static! {
-        static ref DO_STEP: AtomicBool = AtomicBool::new(false);
-        static ref ALLOWED_STEPS: BoundedQueue<()> = BoundedQueue::with_capacity(1_000);
+        static ref STEPS: Mutex<HashMap<DeploymentId, Arc<BoundedQueue<()>>>> =
+            Mutex::new(HashMap::new());
     }
 
-    pub(super) async fn take_step() {
-        if DO_STEP.load(Ordering::SeqCst) {
-            ALLOWED_STEPS.pop().await
+    pub(super) async fn take_step(deployment: &DeploymentLocator) {
+        let steps = STEPS.lock().unwrap().get(&deployment.id).cloned();
+        if let Some(steps) = steps {
+            steps.pop().await;
         }
     }
 
     /// Allow the writer to process `steps` requests. After calling this,
     /// the writer will only process the number of requests it is allowed to
-    pub async fn allow_steps(steps: usize) {
+    pub async fn allow_steps(deployment: &DeploymentLocator, steps: usize) {
+        let queue = {
+            let mut map = STEPS.lock().unwrap();
+            map.entry(deployment.id)
+                .or_insert_with(|| Arc::new(BoundedQueue::with_capacity(1_000)))
+                .clone()
+        };
         for _ in 0..steps {
-            ALLOWED_STEPS.push(()).await
+            queue.push(()).await
+        }
+    }
+
+    pub async fn flush_steps(deployment: graph::components::store::DeploymentId) {
+        let queue = {
+            let mut map = STEPS.lock().unwrap();
+            map.remove(&deployment)
+        };
+        if let Some(queue) = queue {
+            queue.push(()).await;
+        }
+    }
+}
+
+impl std::fmt::Debug for Queue {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let reqs = self.queue.fold(vec![], |mut reqs, req| {
+            reqs.push(req.clone());
+            reqs
+        });
+
+        write!(f, "reqs[{} : ", self.store.site)?;
+        for req in reqs {
+            write!(f, " {:?}", req)?;
         }
-        DO_STEP.store(true, Ordering::SeqCst);
+        writeln!(f, "]")
     }
 }
 
@@ -586,12 +971,45 @@ impl Queue {
         logger: Logger,
         store: Arc<SyncStore>,
         capacity: usize,
-        registry: Arc<dyn MetricsRegistry>,
-    ) -> Arc<Self> {
-        async fn start_writer(queue: Arc<Queue>, logger: Logger) {
+        registry: Arc<MetricsRegistry>,
+    ) -> (Arc<Self>, JoinHandle<()>) {
+        async fn start_writer(queue: Arc<Queue>, logger: Logger, batch_stop_notify: Arc<Notify>) {
             loop {
                 #[cfg(debug_assertions)]
-                test_support::take_step().await;
+                test_support::take_step(&queue.store.site.as_ref().into()).await;
+
+                // If batching is enabled, hold off on writing a batch for a
+                // little bit to give processing a chance to add more
+                // changes. We start processing a batch if it is big enough
+                // or old enough, or if there is more than one request in
+                // the queue. The latter condition makes sure that we do not
+                // wait for a batch to grow when `push_write` would never
+                // add to it again.
+                if queue.batch_writes() && queue.queue.len() <= 1 {
+                    loop {
+                        let _section = queue.stopwatch.start_section("queue_idle");
+                        let req = queue.queue.peek().await;
+
+                        // When this is true, push_write would never add to
+                        // `req`, and we therefore execute the request as
+                        // waiting for more changes to it would be pointless
+                        if !queue.batch_writes() || queue.queue.len() > 1 || req.should_process() {
+                            break;
+                        }
+
+                        // Wait until something has changed before checking
+                        // again, either because we were notified that the
+                        // 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 = tokio::time::sleep(ENV_VARS.store.write_batch_duration);
+                        let notify = batch_stop_notify.notified();
+                        select!(
+                            () = sleep => (),
+                            () = notify => (),
+                        );
+                    }
+                }
 
                 // We peek at the front of the queue, rather than pop it
                 // right away, so that query methods like `get` have access
@@ -600,12 +1018,15 @@ impl Queue {
                 // the write transaction commits, causing them to return
                 // incorrect results.
                 let req = {
-                    let _section = queue.stopwatch.start_section("queue_wait");
-                    queue.queue.peek().await
+                    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
+                    queue.queue.peek_with(|req| req.start_process()).await
                 };
                 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");
@@ -620,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)) => {
@@ -647,36 +1069,168 @@ impl Queue {
             store.site.deployment.clone(),
             "writer",
             registry,
+            store.shard().to_string(),
         );
 
+        let batch_ready_notify = Arc::new(Notify::new());
         let queue = Self {
             store,
             queue,
             write_err,
             poisoned: AtomicBool::new(false),
             stopwatch,
+            batch_writes: AtomicBool::new(true),
+            batch_ready_notify: batch_ready_notify.clone(),
         };
         let queue = Arc::new(queue);
 
-        graph::spawn(start_writer(queue.cheap_clone(), logger));
+        let handle = graph::spawn(start_writer(
+            queue.cheap_clone(),
+            logger,
+            batch_ready_notify,
+        ));
 
-        queue
+        (queue, handle)
     }
 
     /// Add a write request to the queue
     async fn push(&self, req: Request) -> Result<(), StoreError> {
         self.check_err()?;
+        // If we see anything but a write we have to turn off batching as
+        // that would risk adding changes from after a revert into a batch
+        // that gets processed before the revert
+        if !req.is_write() {
+            self.stop_batching();
+        }
         self.queue.push(Arc::new(req)).await;
         Ok(())
     }
 
+    /// Try to append the `batch` to the newest request in the queue if that
+    /// is a write request. We will only append if several conditions are
+    /// true:
+    ///
+    ///   1. The subgraph is not synced
+    ///   2. The newest request (back of the queue) is a write
+    ///   3. The newest request is not already being processed by the
+    ///      writing thread
+    ///   4. The newest write request is not older than
+    ///      `GRAPH_STORE_WRITE_BATCH_DURATION`
+    ///   5. The newest write request is not bigger than
+    ///      `GRAPH_STORE_WRITE_BATCH_SIZE`
+    ///
+    /// In all other cases, we queue a new write request. Note that (3)
+    /// means that the oldest request (front of the queue) does not
+    /// necessarily fulfill (4) and (5) even if it is a write and the
+    /// subgraph is not synced yet.
+    ///
+    /// This strategy is closely tied to how start_writer waits for writes
+    /// 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,
+        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()
+        {
+            Some(batch)
+        } else {
+            self.queue.map_newest(move |newest| {
+                let newest = match newest {
+                    Some(newest) => newest,
+                    None => {
+                        return Ok(Some(batch));
+                    }
+                };
+                // This check at first seems redundant with getting the lock
+                // on the batch in the request below, but is very important
+                // for correctness: if the writer has finished processing
+                // the request and released its lock on the batch, without
+                // this check, we would modify a request that has already
+                // been written, and our changes would therefore never be
+                // written
+                if newest.processed() {
+                    return Ok(Some(batch));
+                }
+                match newest.as_ref() {
+                    Request::Write {
+                        batch: existing,
+                        queued,
+                        ..
+                    } => {
+                        if queued.elapsed() < ENV_VARS.store.write_batch_duration {
+                            // We are being very defensive here: if anything
+                            // is holding the lock on the batch, do not
+                            // modify it. We create a new request instead of
+                            // waiting for the lock since writing a batch
+                            // holds a read lock on the batch for the
+                            // duration of the write, and we do not want to
+                            // slow down queueing requests unnecessarily
+                            match existing.try_write() {
+                                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 {
+                                            self.batch_ready_notify.notify_one();
+                                        }
+                                        res
+                                    } else {
+                                        Ok(Some(batch))
+                                    }
+                                }
+                                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
+                                    Ok(Some(batch))
+                                }
+                            }
+                        } else {
+                            Ok(Some(batch))
+                        }
+                    }
+                    Request::RevertTo { .. } | Request::Stop => Ok(Some(batch)),
+                }
+            })?
+        };
+
+        if let Some(batch) = batch {
+            let req = Request::write(
+                self.store.cheap_clone(),
+                self.stopwatch.cheap_clone(),
+                batch,
+            );
+            let _section = stopwatch.start_section("queue_push_blocked");
+            self.push(req).await?;
+        }
+        Ok(())
+    }
+
     /// Wait for the background writer to finish processing queued entries
     async fn flush(&self) -> Result<(), StoreError> {
+        self.check_err()?;
+
+        #[cfg(debug_assertions)]
+        test_support::flush_steps(self.store.site.id.into()).await;
+
+        // Turn off batching so the queue doesn't wait for a batch to become
+        // full, but restore the old behavior once the queue is empty.
+        let batching = self.batch_writes.load(Ordering::SeqCst);
+        self.stop_batching();
+
         self.queue.wait_empty().await;
+
+        self.batch_writes.store(batching, Ordering::SeqCst);
         self.check_err()
     }
 
     async fn stop(&self) -> Result<(), StoreError> {
+        self.stop_batching();
         self.push(Request::Stop).await
     }
 
@@ -700,86 +1254,66 @@ 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,
         }
 
-        // Going from newest to oldest entry in the queue as `find_map` does
-        // ensures that we see reverts before we see the corresponding write
-        // request. We ignore any write request that writes blocks that have
-        // a number strictly higher than the revert with the smallest block
-        // number, as all such writes will be undone once the revert is
-        // processed.
-        let mut tracker = BlockTracker::new();
-
-        let op = self.queue.find_map(|req| {
-            tracker.update(req.as_ref());
-            match req.as_ref() {
-                Request::Write {
-                    block_ptr, mods, ..
-                } => {
-                    if tracker.visible(block_ptr) {
-                        mods.iter()
-                            .find(|emod| emod.entity_ref() == key)
-                            .map(|emod| match emod {
-                                EntityModification::Insert { data, .. }
-                                | EntityModification::Overwrite { data, .. } => {
-                                    Op::Write(data.clone())
-                                }
-                                EntityModification::Remove { .. } => Op::Remove,
-                            })
-                    } else {
-                        None
-                    }
+        impl<'a> From<EntityOp<'a>> for Op {
+            fn from(value: EntityOp) -> Self {
+                match value {
+                    EntityOp::Write { key: _, entity } => Self::Write(entity.clone()),
+                    EntityOp::Remove { .. } => Self::Remove,
                 }
-                Request::RevertTo { .. } | Request::Stop => None,
             }
+        }
+
+        let (op, query_block) = BlockTracker::find_map(&self.queue, |batch, at| {
+            batch.last_op(key, at).map(Op::from)
         });
 
         match op {
             Some(Op::Write(entity)) => Ok(Some(entity)),
             Some(Op::Remove) => Ok(None),
-            None => self.store.get(key, tracker.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> {
-        // See the implementation of `get` for how we handle reverts
-        let mut tracker = BlockTracker::new();
-
-        // Get entities from entries in the queue
-        let entities_in_queue = self.queue.fold(
+        let (entities_in_queue, query_block) = BlockTracker::fold(
+            &self.queue,
             BTreeMap::new(),
-            |mut map: BTreeMap<EntityKey, Option<Entity>>, req| {
-                tracker.update(req.as_ref());
-                match req.as_ref() {
-                    Request::Write {
-                        block_ptr, mods, ..
-                    } => {
-                        if tracker.visible(block_ptr) {
-                            for emod in mods {
-                                let key = emod.entity_ref();
-                                // The key must be removed to avoid overwriting it with a stale value.
-                                if let Some(key) = keys.take(key) {
-                                    map.insert(key, emod.entity().cloned());
-                                }
-                            }
+            |mut map: BTreeMap<EntityKey, Option<Entity>>, batch, at| {
+                // See if we have changes for any of the keys. Since we are
+                // going from newest to oldest block, do not clobber already
+                // existing entries in map as that would make us use an
+                // older value.
+                for key in &keys {
+                    if map.contains_key(key) {
+                        continue;
+                    }
+                    match batch.last_op(key, at) {
+                        Some(EntityOp::Write { key: _, entity }) => {
+                            map.insert(key.clone(), Some(entity.clone()));
                         }
+                        Some(EntityOp::Remove { .. }) => {
+                            map.insert(key.clone(), None);
+                        }
+                        None => { /* nothing to do  */ }
                     }
-                    Request::RevertTo { .. } | Request::Stop => { /* nothing to do */ }
                 }
                 map
             },
         );
 
-        // Whatever remains in `keys` needs to be gotten from the store
-        let mut map = self.store.get_many(keys, tracker.query_block())?;
+        // 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).await?;
 
         // Extend the store results with the entities from the queue.
         for (key, entity) in entities_in_queue {
@@ -792,38 +1326,83 @@ impl Queue {
         Ok(map)
     }
 
+    async fn get_derived(
+        &self,
+        derived_query: &DerivedEntityQuery,
+    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
+        fn is_related(derived_query: &DerivedEntityQuery, entity: &Entity) -> bool {
+            entity
+                .get(&derived_query.entity_field)
+                .map(|v| &derived_query.value == v)
+                .unwrap_or(false)
+        }
+
+        fn effective_ops<'a>(
+            batch: &'a Batch,
+            derived_query: &'a DerivedEntityQuery,
+            at: BlockNumber,
+        ) -> impl Iterator<Item = (EntityKey, Option<Entity>)> + 'a {
+            batch
+                .effective_ops(&derived_query.entity_type, at)
+                .filter_map(|op| match op {
+                    EntityOp::Write { key, entity } if is_related(derived_query, entity) => {
+                        Some((key.clone(), Some(entity.clone())))
+                    }
+                    EntityOp::Write { .. } => None,
+                    EntityOp::Remove { key } => Some((key.clone(), None)),
+                })
+        }
+
+        // Get entities from entries in the queue
+        let (entities_in_queue, query_block) = BlockTracker::fold(
+            &self.queue,
+            BTreeMap::new(),
+            |mut map: BTreeMap<EntityKey, Option<Entity>>, batch, at| {
+                // Since we are going newest to oldest, do not clobber
+                // already existing entries in map as that would make us
+                // produce stale values
+                for (k, v) in effective_ops(batch, derived_query, at) {
+                    map.entry(k).or_insert(v);
+                }
+                map
+            },
+        );
+
+        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)
+            .await?;
+
+        // Extend the store results with the entities from the queue.
+        // This overwrites any entitiy from the database with the same key from queue
+        let items_from_queue: BTreeMap<EntityKey, Entity> = entities_in_queue
+            .into_iter()
+            .filter_map(|(key, entity)| entity.map(|entity| (key, entity)))
+            .collect();
+        items_from_database.extend(items_from_queue);
+
+        Ok(items_from_database)
+    }
+
     /// Load dynamic data sources by looking at both the queue and the store
     async fn load_dynamic_data_sources(
         &self,
         manifest_idx_and_name: Vec<(u32, String)>,
     ) -> Result<Vec<StoredDynamicDataSource>, StoreError> {
-        // See the implementation of `get` for how we handle reverts
-        let mut tracker = BlockTracker::new();
-
         // We need to produce a list of dynamic data sources that are
         // ordered by their creation block. We first look through all the
         // dds that are still in the queue, and then load dds from the store
         // as long as they were written at a block before whatever is still
         // in the queue. The overall list of dds is the list of dds from the
         // store plus the ones still in memory sorted by their block number.
-        let mut queue_dds = self.queue.fold(Vec::new(), |mut dds, req| {
-            tracker.update(req.as_ref());
-            match req.as_ref() {
-                Request::Write {
-                    block_ptr,
-                    data_sources,
-                    processed_data_sources,
-                    ..
-                } => {
-                    if tracker.visible(block_ptr) {
-                        dds.extend(data_sources.clone());
-                        dds.retain(|dds| !processed_data_sources.contains(dds));
-                    }
-                }
-                Request::RevertTo { .. } | Request::Stop => { /* nothing to do */ }
-            }
-            dds
-        });
+        let (mut queue_dds, query_block) =
+            BlockTracker::fold(&self.queue, Vec::new(), |mut dds, batch, at| {
+                dds.extend(batch.new_data_sources(at).cloned());
+                dds
+            });
         // Using a stable sort is important here so that dds created at the
         // same block stay in the order in which they were added (and
         // therefore will be loaded from the store in that order once the
@@ -832,7 +1411,7 @@ impl Queue {
 
         let mut dds = self
             .store
-            .load_dynamic_data_sources(tracker.query_block(), manifest_idx_and_name)
+            .load_dynamic_data_sources(query_block, manifest_idx_and_name)
             .await?;
         dds.append(&mut queue_dds);
 
@@ -842,12 +1421,34 @@ impl Queue {
     fn poisoned(&self) -> bool {
         self.poisoned.load(Ordering::SeqCst)
     }
+
+    fn deployment_synced(&self) {
+        self.stop_batching();
+        self.stopwatch.disable()
+    }
+
+    fn batch_writes(&self) -> bool {
+        self.batch_writes.load(Ordering::SeqCst)
+    }
+
+    fn stop_batching(&self) {
+        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
 enum Writer {
     Sync(Arc<SyncStore>),
-    Async(Arc<Queue>),
+    Async {
+        queue: Arc<Queue>,
+        join_handle: JoinHandle<()>,
+    },
 }
 
 impl Writer {
@@ -855,51 +1456,41 @@ impl Writer {
         logger: Logger,
         store: Arc<SyncStore>,
         capacity: usize,
-        registry: Arc<dyn MetricsRegistry>,
+        registry: Arc<MetricsRegistry>,
     ) -> Self {
         info!(logger, "Starting subgraph writer"; "queue_size" => capacity);
         if capacity == 0 {
             Self::Sync(store)
         } else {
-            Self::Async(Queue::start(logger, store, capacity, registry))
+            let (queue, join_handle) = Queue::start(logger, store.clone(), capacity, registry);
+            Self::Async { queue, join_handle }
         }
     }
 
-    async fn write(
-        &self,
-        block_ptr_to: BlockPtr,
-        firehose_cursor: FirehoseCursor,
-        mods: Vec<EntityModification>,
-        stopwatch: &StopwatchMetrics,
-        data_sources: Vec<StoredDynamicDataSource>,
-        deterministic_errors: Vec<SubgraphError>,
-        manifest_idx_and_name: Vec<(u32, String)>,
-        processed_data_sources: Vec<StoredDynamicDataSource>,
-    ) -> Result<(), StoreError> {
+    fn check_queue_running(&self) -> Result<(), StoreError> {
         match self {
-            Writer::Sync(store) => store.transact_block_operations(
-                &block_ptr_to,
-                &firehose_cursor,
-                &mods,
-                stopwatch,
-                &data_sources,
-                &deterministic_errors,
-                &manifest_idx_and_name,
-                &processed_data_sources,
-            ),
-            Writer::Async(queue) => {
-                let req = Request::Write {
-                    store: queue.store.cheap_clone(),
-                    stopwatch: queue.stopwatch.cheap_clone(),
-                    block_ptr: block_ptr_to,
-                    firehose_cursor,
-                    mods,
-                    data_sources,
-                    deterministic_errors,
-                    manifest_idx_and_name,
-                    processed_data_sources,
-                };
-                queue.push(req).await
+            Writer::Sync(_) => Ok(()),
+            Writer::Async { join_handle, queue } => {
+                // If there was an error, report that instead of a naked 'writer not running'
+                queue.check_err()?;
+                if join_handle.is_finished() {
+                    Err(internal_error!(
+                        "Subgraph writer for {} is not running",
+                        queue.store.site
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
+        }
+    }
+
+    async fn write(&self, batch: Batch, stopwatch: &StopwatchMetrics) -> Result<(), StoreError> {
+        match self {
+            Writer::Sync(store) => store.transact_block_operations(&batch, stopwatch).await,
+            Writer::Async { queue, .. } => {
+                self.check_queue_running()?;
+                queue.push_write(batch, stopwatch).await
             }
         }
     }
@@ -910,13 +1501,14 @@ impl Writer {
         firehose_cursor: FirehoseCursor,
     ) -> Result<(), StoreError> {
         match self {
-            Writer::Sync(store) => store.revert_block_operations(block_ptr_to, &firehose_cursor),
-            Writer::Async(queue) => {
-                let req = Request::RevertTo {
-                    store: queue.store.cheap_clone(),
-                    block_ptr: 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);
                 queue.push(req).await
             }
         }
@@ -925,24 +1517,37 @@ impl Writer {
     async fn flush(&self) -> Result<(), StoreError> {
         match self {
             Writer::Sync { .. } => Ok(()),
-            Writer::Async(queue) => queue.flush().await,
+            Writer::Async { queue, .. } => {
+                self.check_queue_running()?;
+                queue.flush().await
+            }
         }
     }
 
-    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,
+        }
+    }
+
+    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![]).await,
+            Writer::Async { queue, .. } => queue.get_derived(key).await,
         }
     }
 
@@ -956,21 +1561,37 @@ impl Writer {
                     .load_dynamic_data_sources(BLOCK_NUMBER_MAX, manifest_idx_and_name)
                     .await
             }
-            Writer::Async(queue) => queue.load_dynamic_data_sources(manifest_idx_and_name).await,
+            Writer::Async { queue, .. } => {
+                queue.load_dynamic_data_sources(manifest_idx_and_name).await
+            }
         }
     }
 
     fn poisoned(&self) -> bool {
         match self {
             Writer::Sync(_) => false,
-            Writer::Async(queue) => queue.poisoned(),
+            Writer::Async { queue, .. } => queue.poisoned(),
         }
     }
 
     async fn stop(&self) -> Result<(), StoreError> {
         match self {
             Writer::Sync(_) => Ok(()),
-            Writer::Async(queue) => queue.stop().await,
+            Writer::Async { queue, .. } => queue.stop().await,
+        }
+    }
+
+    fn deployment_synced(&self) {
+        match self {
+            Writer::Sync(_) => {}
+            Writer::Async { queue, .. } => queue.deployment_synced(),
+        }
+    }
+
+    fn start_batching(&self) {
+        match self {
+            Writer::Sync(_) => {}
+            Writer::Async { queue, .. } => queue.start_batching(),
         }
     }
 }
@@ -980,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 {
@@ -987,10 +1611,24 @@ impl WritableStore {
         subgraph_store: SubgraphStore,
         logger: Logger,
         site: Arc<Site>,
-        registry: Arc<dyn MetricsRegistry>,
+        manifest_idx_and_name: Arc<Vec<(u32, String)>>,
+        registry: Arc<MetricsRegistry>,
     ) -> Result<Self, StoreError> {
-        let store = Arc::new(SyncStore::new(subgraph_store, logger.clone(), site)?);
-        let block_ptr = Mutex::new(store.block_ptr().await?);
+        let block_ptr = subgraph_store
+            .for_site(&site)?
+            .block_ptr(site.cheap_clone())
+            .await?;
+        let store = Arc::new(
+            SyncStore::new(
+                subgraph_store,
+                logger.clone(),
+                site,
+                manifest_idx_and_name,
+                block_ptr.as_ref().map(|ptr| ptr.number),
+            )
+            .await?,
+        );
+        let block_ptr = Mutex::new(block_ptr);
         let block_cursor = Mutex::new(store.block_cursor().await?);
         let writer = Writer::new(
             logger,
@@ -999,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),
         })
     }
 
@@ -1016,39 +1657,95 @@ 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
+    }
+
+    async fn get_derived(
+        &self,
+        key: &DerivedEntityQuery,
+    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
+        self.writer.get_derived(key).await
     }
 
-    fn input_schema(&self) -> Arc<Schema> {
+    fn input_schema(&self) -> InputSchema {
         self.store.input_schema()
     }
 }
 
-#[async_trait::async_trait]
-impl WritableStoreTrait 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()
     }
 
-    fn block_cursor(&self) -> FirehoseCursor {
+    fn firehose_cursor(&self) -> FirehoseCursor {
         self.block_cursor.lock().unwrap().clone()
     }
 
+    fn input_schema(&self) -> InputSchema {
+        self.store.input_schema()
+    }
+}
+
+#[async_trait::async_trait]
+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?;
@@ -1075,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?;
@@ -1085,47 +1783,61 @@ 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,
+        block_time: BlockTime,
         firehose_cursor: FirehoseCursor,
         mods: Vec<EntityModification>,
         stopwatch: &StopwatchMetrics,
         data_sources: Vec<StoredDynamicDataSource>,
         deterministic_errors: Vec<SubgraphError>,
-        manifest_idx_and_name: Vec<(u32, String)>,
         processed_data_sources: Vec<StoredDynamicDataSource>,
+        is_non_fatal_errors_active: bool,
+        is_caught_up_with_chain_head: bool,
     ) -> Result<(), StoreError> {
-        self.writer
-            .write(
-                block_ptr_to.clone(),
-                firehose_cursor.clone(),
-                mods,
-                stopwatch,
-                data_sources,
-                deterministic_errors,
-                manifest_idx_and_name,
-                processed_data_sources,
-            )
-            .await?;
+        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,
+            firehose_cursor.clone(),
+            mods,
+            data_sources,
+            deterministic_errors,
+            processed_data_sources,
+            is_non_fatal_errors_active,
+            self.store.logger.clone(),
+        )?;
+        self.writer.write(batch, stopwatch).await?;
 
         *self.block_ptr.lock().unwrap() = Some(block_ptr_to);
         *self.block_cursor.lock().unwrap() = firehose_cursor;
@@ -1133,16 +1845,25 @@ impl WritableStoreTrait for WritableStore {
         Ok(())
     }
 
-    fn deployment_synced(&self) -> Result<(), StoreError> {
-        self.store.deployment_synced()
+    /// 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();
+        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(
@@ -1168,7 +1889,41 @@ 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
     }
+
+    async fn restart(self: Arc<Self>) -> Result<Option<Arc<dyn WritableStoreTrait>>, StoreError> {
+        if self.poisoned() {
+            // When the writer is poisoned, the background thread has
+            // finished since `start_writer` returns whenever it encounters
+            // an error. Just to make extra-sure, we log a warning if the
+            // join handle indicates that the writer hasn't stopped yet.
+            let logger = self.store.logger.clone();
+            match &self.writer {
+                Writer::Sync(_) => { /* can't happen, a sync writer never gets poisoned */ }
+                Writer::Async { join_handle, queue } => {
+                    let err = match queue.check_err() {
+                        Ok(()) => "error missing".to_string(),
+                        Err(e) => e.to_string(),
+                    };
+                    if !join_handle.is_finished() {
+                        warn!(logger, "Writer was poisoned, but background thread didn't finish. Creating new writer regardless"; "error" => err);
+                    }
+                }
+            }
+            let store = Arc::new(self.store.store.0.clone());
+            let manifest_idx_and_name = self.store.manifest_idx_and_name.cheap_clone();
+            store
+                .writable(logger, self.store.site.id.into(), manifest_idx_and_name)
+                .await
+                .map(Some)
+        } else {
+            Ok(None)
+        }
+    }
 }
diff --git a/store/postgres/tests/README.md b/store/postgres/tests/README.md
new file mode 100644
index 00000000000..9fa18d53625
--- /dev/null
+++ b/store/postgres/tests/README.md
@@ -0,0 +1,5 @@
+Put integration tests for this crate into `store/test-store/tests/postgres`.
+This avoids cyclic dev-dependencies which make rust-analyzer nearly
+unusable. Once [this
+issue](https://github.com/rust-lang/rust-analyzer/issues/14167) has been
+fixed, we can move tests back here
diff --git a/store/postgres/tests/chain_head.rs b/store/postgres/tests/chain_head.rs
deleted file mode 100644
index 9614dc0ae79..00000000000
--- a/store/postgres/tests/chain_head.rs
+++ /dev/null
@@ -1,389 +0,0 @@
-//! Test ChainStore implementation of Store, in particular, how
-//! the chain head pointer gets updated in various situations
-
-use futures::executor;
-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::prelude::{BlockNumber, QueryStoreManager, QueryTarget};
-use graph::{cheap_clone::CheapClone, prelude::web3::types::H160};
-use graph::{components::store::BlockStore as _, prelude::DeploymentHash};
-use graph::{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 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,
-};
-use test_store::*;
-
-// The ancestor count we use for chain head updates. We keep this very small
-// to make setting up the tests easier
-const ANCESTOR_COUNT: BlockNumber = 3;
-
-/// Test harness for running database integration tests.
-fn run_test<F>(chain: FakeBlockList, test: F)
-where
-    F: Fn(Arc<DieselChainStore>, Arc<DieselStore>) -> Result<(), Error> + Send + 'static,
-{
-    run_test_sequentially(|store| async move {
-        for name in &[NETWORK_NAME, FAKE_NETWORK_SHARED] {
-            block_store::set_chain(chain.clone(), name);
-
-            let chain_store = store.block_store().chain_store(name).expect("chain store");
-
-            // Run test
-            test(chain_store.cheap_clone(), store.cheap_clone())
-                .unwrap_or_else(|_| panic!("test finishes successfully on network {}", name));
-        }
-    });
-}
-
-fn run_test_async<R, F>(chain: FakeBlockList, test: F)
-where
-    F: Fn(Arc<DieselChainStore>, Arc<DieselStore>) -> R + Send + Sync + 'static,
-    R: Future<Output = ()> + Send + 'static,
-{
-    run_test_sequentially(|store| async move {
-        for name in &[NETWORK_NAME, FAKE_NETWORK_SHARED] {
-            block_store::set_chain(chain.clone(), name);
-
-            let chain_store = store.block_store().chain_store(name).expect("chain store");
-
-            // Run test
-            test(chain_store.cheap_clone(), store.clone()).await;
-        }
-    });
-}
-
-/// Check that `attempt_chain_head_update` works as expected on the given
-/// chain. After writing the blocks in `chain` to the store, call
-/// `attempt_chain_head_update` and check its result. Check that the new head
-/// is the one indicated in `head_exp`. If `missing` is not `None`, check that
-/// `attempt_chain_head_update` reports that block as missing
-fn check_chain_head_update(
-    chain: FakeBlockList,
-    head_exp: Option<&'static FakeBlock>,
-    missing: Option<&'static str>,
-) {
-    run_test_async(chain, move |store, _| async move {
-        let missing_act: Vec<_> = store
-            .clone()
-            .attempt_chain_head_update(ANCESTOR_COUNT)
-            .await
-            .expect("attempt_chain_head_update failed")
-            .iter()
-            .map(|h| format!("{:x}", h))
-            .collect();
-        let missing_exp: Vec<_> = missing.into_iter().collect();
-        assert_eq!(missing_exp, missing_act);
-
-        let head_hash_exp = head_exp.map(|block| block.hash.clone());
-        let head_hash_act = store
-            .chain_head_ptr()
-            .await
-            .expect("chain_head_ptr failed")
-            .map(|ebp| ebp.hash_hex());
-        assert_eq!(head_hash_exp, head_hash_act);
-    })
-}
-
-#[test]
-fn genesis_only() {
-    check_chain_head_update(vec![&*GENESIS_BLOCK], Some(&GENESIS_BLOCK), None);
-}
-
-#[test]
-fn genesis_plus_one() {
-    check_chain_head_update(vec![&*GENESIS_BLOCK, &*BLOCK_ONE], Some(&BLOCK_ONE), None);
-}
-
-#[test]
-fn genesis_plus_two() {
-    check_chain_head_update(
-        vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_TWO],
-        Some(&*BLOCK_TWO),
-        None,
-    );
-}
-
-#[test]
-fn genesis_plus_one_with_sibling() {
-    // Two valid blocks at the same height should give an error, but
-    // we currently get one of them at random
-    let chain = vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_ONE_SIBLING];
-    check_chain_head_update(chain, Some(&*BLOCK_ONE), None);
-}
-
-#[test]
-fn short_chain_missing_parent() {
-    let chain = vec![&*BLOCK_ONE_NO_PARENT];
-    check_chain_head_update(chain, None, Some(NO_PARENT));
-}
-
-#[test]
-fn long_chain() {
-    let chain = vec![
-        &*BLOCK_ONE,
-        &*BLOCK_TWO,
-        &*BLOCK_THREE,
-        &*BLOCK_FOUR,
-        &*BLOCK_FIVE,
-    ];
-    check_chain_head_update(chain, Some(&*BLOCK_FIVE), None);
-}
-
-#[test]
-fn long_chain_missing_blocks_within_ancestor_count() {
-    // BLOCK_THREE does not have a parent in the store
-    let chain = vec![&*BLOCK_THREE, &*BLOCK_FOUR, &*BLOCK_FIVE];
-    check_chain_head_update(chain, None, Some(&BLOCK_THREE.parent_hash));
-}
-
-#[test]
-fn long_chain_missing_blocks_beyond_ancestor_count() {
-    // We don't mind missing blocks ANCESTOR_COUNT many blocks out, in
-    // this case BLOCK_ONE
-    let chain = vec![&*BLOCK_TWO, &*BLOCK_THREE, &*BLOCK_FOUR, &*BLOCK_FIVE];
-    check_chain_head_update(chain, Some(&*BLOCK_FIVE), None);
-}
-
-#[test]
-fn long_chain_with_uncles() {
-    let chain = vec![
-        &*BLOCK_ONE,
-        &*BLOCK_TWO,
-        &*BLOCK_TWO_NO_PARENT,
-        &*BLOCK_THREE,
-        &*BLOCK_THREE_NO_PARENT,
-        &*BLOCK_FOUR,
-    ];
-    check_chain_head_update(chain, Some(&*BLOCK_FOUR), None);
-}
-
-#[test]
-fn test_get_block_number() {
-    let chain = vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_TWO];
-    let subgraph = DeploymentHash::new("nonExistentSubgraph").unwrap();
-
-    run_test_async(chain, move |_, subgraph_store| {
-        let subgraph = subgraph.cheap_clone();
-        async move {
-            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,
-                )
-                .await
-                .unwrap();
-
-            let block = query_store
-                .block_number(&GENESIS_BLOCK.block_hash())
-                .await
-                .expect("Found genesis block");
-            assert_eq!(Some(0), block);
-
-            let block = query_store
-                .block_number(&BLOCK_ONE.block_hash())
-                .await
-                .expect("Found block 1");
-            assert_eq!(Some(1), block);
-
-            let block = query_store
-                .block_number(&BLOCK_THREE.block_hash())
-                .await
-                .expect("Looked for block 3");
-            assert!(block.is_none());
-        }
-    })
-}
-
-#[test]
-fn block_hashes_by_number() {
-    let chain = vec![
-        &*GENESIS_BLOCK,
-        &*BLOCK_ONE,
-        &*BLOCK_TWO,
-        &*BLOCK_TWO_NO_PARENT,
-    ];
-    run_test(chain, move |store, _| {
-        let hashes = store.block_hashes_by_block_number(1).unwrap();
-        assert_eq!(vec![BLOCK_ONE.block_hash()], hashes);
-
-        let hashes = store.block_hashes_by_block_number(2).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();
-        assert_eq!(0, hashes.len());
-
-        let deleted = store
-            .confirm_block_hash(1, &BLOCK_ONE.block_hash())
-            .unwrap();
-        assert_eq!(0, deleted);
-
-        let deleted = store
-            .confirm_block_hash(2, &BLOCK_TWO.block_hash())
-            .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())
-            .unwrap();
-        assert_eq!(0, deleted);
-
-        let hashes = store.block_hashes_by_block_number(1).unwrap();
-        assert_eq!(vec![BLOCK_ONE.block_hash()], hashes);
-
-        let hashes = store.block_hashes_by_block_number(2).unwrap();
-        assert_eq!(vec![BLOCK_TWO.block_hash()], hashes);
-        Ok(())
-    })
-}
-
-#[track_caller]
-fn check_ancestor(
-    store: &Arc<DieselChainStore>,
-    child: &FakeBlock,
-    offset: BlockNumber,
-    exp: &FakeBlock,
-) -> Result<(), Error> {
-    let act = executor::block_on(
-        store
-            .cheap_clone()
-            .ancestor_block(child.block_ptr(), offset),
-    )?
-    .map(json::from_value::<EthereumBlock>)
-    .transpose()?
-    .ok_or_else(|| anyhow!("block {} has no ancestor at offset {}", child.hash, offset))?;
-    let act_hash = format!("{:x}", act.block.hash.unwrap());
-    let exp_hash = &exp.hash;
-
-    if &act_hash != exp_hash {
-        Err(anyhow!(
-            "expected hash `{}` but got `{}`",
-            exp_hash,
-            act_hash
-        ))
-    } else {
-        Ok(())
-    }
-}
-
-#[test]
-fn ancestor_block_simple() {
-    let chain = vec![
-        &*GENESIS_BLOCK,
-        &*BLOCK_ONE,
-        &*BLOCK_TWO,
-        &*BLOCK_THREE,
-        &*BLOCK_FOUR,
-        &*BLOCK_FIVE,
-    ];
-
-    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)?;
-
-        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),
-            );
-            assert!(res.is_err());
-        }
-
-        let block = executor::block_on(store.ancestor_block(BLOCK_TWO_NO_PARENT.block_ptr(), 1))?;
-        assert!(block.is_none());
-        Ok(())
-    });
-}
-
-#[test]
-fn ancestor_block_ommers() {
-    let chain = vec![
-        &*GENESIS_BLOCK,
-        &*BLOCK_ONE,
-        &*BLOCK_ONE_SIBLING,
-        &*BLOCK_TWO,
-    ];
-
-    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)?;
-        Ok(())
-    });
-}
-
-#[test]
-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]);
-        let call: [u8; 6] = [1, 2, 3, 4, 5, 6];
-        let return_value: [u8; 3] = [7, 8, 9];
-
-        store
-            .set_call(address, &call, BLOCK_ONE.block_ptr(), &return_value)
-            .unwrap();
-
-        let ret = store
-            .get_call(address, &call, GENESIS_BLOCK.block_ptr())
-            .unwrap();
-        assert!(ret.is_none());
-
-        let ret = store
-            .get_call(address, &call, BLOCK_ONE.block_ptr())
-            .unwrap()
-            .unwrap();
-        assert_eq!(&return_value, ret.as_slice());
-
-        let ret = store
-            .get_call(address, &call, BLOCK_TWO.block_ptr())
-            .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)
-            .unwrap();
-        let ret = store
-            .get_call(address, &call, BLOCK_TWO.block_ptr())
-            .unwrap()
-            .unwrap();
-        assert_eq!(&new_return_value, ret.as_slice());
-
-        Ok(())
-    })
-}
-
-#[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())
-            .await
-            .unwrap();
-        assert!(receipts.is_empty())
-    })
-}
diff --git a/store/postgres/tests/writable.rs b/store/postgres/tests/writable.rs
deleted file mode 100644
index a171de104cf..00000000000
--- a/store/postgres/tests/writable.rs
+++ /dev/null
@@ -1,163 +0,0 @@
-use graph::blockchain::block_stream::FirehoseCursor;
-use graph::data::subgraph::schema::DeploymentCreate;
-use lazy_static::lazy_static;
-use std::marker::PhantomData;
-use test_store::*;
-
-use graph::components::store::{DeploymentLocator, EntityKey, WritableStore};
-use graph::data::subgraph::*;
-use graph::prelude::*;
-use graph::semver::Version;
-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,
-    }
-";
-
-const COUNTER: &str = "Counter";
-
-lazy_static! {
-    static ref TEST_SUBGRAPH_ID_STRING: String = String::from("writableSubgraph");
-    static ref TEST_SUBGRAPH_ID: DeploymentHash =
-        DeploymentHash::new(TEST_SUBGRAPH_ID_STRING.as_str()).unwrap();
-    static ref TEST_SUBGRAPH_SCHEMA: Schema =
-        Schema::parse(SCHEMA_GQL, TEST_SUBGRAPH_ID.clone()).expect("Failed to parse user schema");
-}
-
-/// Inserts test data into the store.
-///
-/// Create a new empty subgraph with schema `SCHEMA_GQL`
-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),
-        features: Default::default(),
-        description: None,
-        repository: None,
-        schema: TEST_SUBGRAPH_SCHEMA.clone(),
-        data_sources: vec![],
-        graft: None,
-        templates: vec![],
-        chain: PhantomData,
-    };
-
-    // Create SubgraphDeploymentEntity
-    let deployment = DeploymentCreate::new(String::new(), &manifest, None);
-    let name = SubgraphName::new("test/writable").unwrap();
-    let node_id = NodeId::new("test").unwrap();
-
-    store
-        .create_subgraph_deployment(
-            name,
-            &TEST_SUBGRAPH_SCHEMA,
-            deployment,
-            node_id,
-            NETWORK_NAME.to_string(),
-            SubgraphVersionSwitchingMode::Instant,
-        )
-        .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,
-{
-    run_test_sequentially(|store| async move {
-        let subgraph_store = store.subgraph_store();
-        // Reset state before starting
-        remove_test_data(subgraph_store.clone());
-
-        // Seed database with test data
-        let deployment = insert_test_data(subgraph_store.clone()).await;
-        let writable = store
-            .subgraph_store()
-            .writable(LOGGER.clone(), 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.clone(), deployment).await;
-        writable.flush().await.unwrap();
-    });
-}
-
-fn block_pointer(number: u8) -> BlockPtr {
-    let hash = H256::from([number; 32]);
-    BlockPtr::from((hash, number as BlockNumber))
-}
-
-fn count_key(id: &str) -> EntityKey {
-    EntityKey::data(COUNTER.to_owned(), id.to_owned())
-}
-
-async fn insert_count(store: &Arc<DieselSubgraphStore>, deployment: &DeploymentLocator, count: u8) {
-    let data = entity! {
-        id: "1",
-        count: count as i32
-    };
-    let entity_op = EntityOperation::Set {
-        key: count_key(&data.get("id").unwrap().to_string()),
-        data,
-    };
-    transact_entity_operations(store, deployment, block_pointer(count), vec![entity_op])
-        .await
-        .unwrap();
-}
-
-async fn pause_writer(deployment: &DeploymentLocator) {
-    flush(deployment).await.unwrap();
-    writable::allow_steps(0).await;
-}
-
-async fn resume_writer(deployment: &DeploymentLocator, steps: usize) {
-    writable::allow_steps(steps).await;
-    flush(deployment).await.unwrap();
-}
-
-#[test]
-fn tracker() {
-    run_test(|store, writable, deployment| async move {
-        let subgraph_store = store.subgraph_store();
-
-        let read_count = || {
-            let counter = writable.get(&count_key("1")).unwrap().unwrap();
-            counter.get("count").unwrap().as_int().unwrap()
-        };
-        for count in 1..4 {
-            insert_count(&subgraph_store, &deployment, count).await;
-        }
-        pause_writer(&deployment).await;
-
-        // Test reading back with a pending write
-        insert_count(&subgraph_store, &deployment, 4).await;
-        assert_eq!(4, read_count());
-        resume_writer(&deployment, 1).await;
-        assert_eq!(4, read_count());
-
-        // Test reading back with a pending revert
-        writable
-            .revert_block_operations(block_pointer(2), FirehoseCursor::None)
-            .await
-            .unwrap();
-
-        assert_eq!(2, read_count());
-
-        resume_writer(&deployment, 1).await;
-        assert_eq!(2, read_count());
-    })
-}
diff --git a/store/test-store/Cargo.toml b/store/test-store/Cargo.toml
index 0c7c55bc662..45027b972d3 100644
--- a/store/test-store/Cargo.toml
+++ b/store/test-store/Cargo.toml
@@ -6,15 +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-mock = { path = "../../mock" }
 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.3"
-diesel = { version = "1.4.8", features = ["postgres", "serde_json", "numeric", "r2d2"] }
-serde = "1.0"
+graph-chain-ethereum = { path = "../../chain/ethereum" }
+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.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 fc3e40d08c8..70459d6b39b 100644
--- a/store/test-store/src/block_store.rs
+++ b/store/test-store/src/block_store.rs
@@ -1,18 +1,22 @@
 use std::{convert::TryFrom, str::FromStr, sync::Arc};
 
+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 {
@@ -32,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)));
@@ -40,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");
 }
@@ -66,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,
@@ -84,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()
+        }
     }
 }
 
@@ -149,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");
                 }
             });
@@ -157,21 +189,36 @@ impl BlockchainBlock for FakeBlock {
 
         Ok(value)
     }
+
+    fn timestamp(&self) -> BlockTime {
+        BlockTime::NONE
+    }
 }
 
-pub type FakeBlockList<'a> = Vec<&'static FakeBlock>;
+pub type FakeBlockList = Vec<&'static FakeBlock>;
 
 /// Store the given chain as the blocks for the `network` set the
 /// network's genesis block to `genesis_hash`, and head block to
 /// `null`
-pub fn set_chain(chain: FakeBlockList, network: &str) {
-    let store = crate::store::STORE
-        .block_store()
-        .chain_store(network)
-        .unwrap();
-    let chain: Vec<&dyn BlockchainBlock> = chain
+pub async fn set_chain(chain: FakeBlockList, network: &str) -> Vec<(BlockPtr, BlockHash)> {
+    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()
-        .map(|block| *block as &dyn BlockchainBlock)
+        .cloned()
+        .map(|block| Arc::new(block.clone()) as Arc<dyn BlockchainBlock>)
         .collect();
-    store.set_chain(&GENESIS_BLOCK.hash, chain);
+    store.set_chain(&GENESIS_BLOCK.hash, chain).await
 }
diff --git a/store/test-store/src/store.rs b/store/test-store/src/store.rs
index dc38e59dbdf..ba57dff430d 100644
--- a/store/test-store/src/store.rs
+++ b/store/test-store/src/store.rs
@@ -1,30 +1,36 @@
-use diesel::{self, PgConnection};
-use graph::data::graphql::effort::LoadManager;
+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::SubgraphFeature;
 use graph::data::subgraph::schema::{DeploymentCreate, SubgraphError};
-use graph::data_source::CausalityRegion;
+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::EntityKey,
-    components::store::EntityType, 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_mock::MockMetricsRegistry;
 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;
@@ -32,10 +38,9 @@ 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";
 pub const NETWORK_VERSION: &str = "graph test suite";
 
 pub use graph_store_postgres::Store;
@@ -48,33 +53,37 @@ 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<MockMetricsRegistry> =
-        Arc::new(MockMetricsRegistry::new());
+    pub static ref METRICS_REGISTRY: Arc<MetricsRegistry> = Arc::new(MetricsRegistry::mock());
     pub static ref LOAD_MANAGER: Arc<LoadManager> = Arc::new(LoadManager::new(
         &LOGGER,
+        CONFIG.stores.keys().cloned().collect(),
         Vec::new(),
         METRICS_REGISTRY.clone(),
     ));
     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
@@ -82,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,
@@ -114,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() {
@@ -131,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");
 }
 
@@ -153,11 +167,11 @@ pub async fn create_subgraph(
     schema: &str,
     base: Option<(DeploymentHash, BlockPtr)>,
 ) -> Result<DeploymentLocator, StoreError> {
-    let schema = Schema::parse(schema, subgraph_id.clone()).unwrap();
+    let schema = InputSchema::parse_latest(schema, subgraph_id.clone()).unwrap();
 
     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)),
@@ -166,29 +180,37 @@ pub async fn create_subgraph(
         graft: None,
         templates: vec![],
         chain: PhantomData,
+        indexer_hints: None,
     };
 
+    create_subgraph_with_manifest(subgraph_id, schema, manifest, base).await
+}
+
+pub async fn create_subgraph_with_manifest(
+    subgraph_id: &DeploymentHash,
+    schema: InputSchema,
+    manifest: SubgraphManifest<graph::blockchain::mock::MockBlockchain>,
+    base: Option<(DeploymentHash, BlockPtr)>,
+) -> Result<DeploymentLocator, StoreError> {
     let mut yaml = serde_yaml::Mapping::new();
     yaml.insert("dataSources".into(), Vec::<serde_yaml::Value>::new().into());
     let yaml = serde_yaml::to_string(&yaml).unwrap();
     let deployment = DeploymentCreate::new(yaml, &manifest, None).graft(base);
-    let name = {
-        let mut name = subgraph_id.to_string();
-        name.truncate(32);
-        SubgraphName::new(name).unwrap()
-    };
-    let deployment = SUBGRAPH_STORE.create_deployment_replace(
-        name,
-        &schema,
-        deployment,
-        NODE_ID.clone(),
-        NETWORK_NAME.to_string(),
-        SubgraphVersionSwitchingMode::Instant,
-    )?;
+    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,
+        )
+        .await?;
 
     SUBGRAPH_STORE
         .cheap_clone()
-        .writable(LOGGER.clone(), deployment.id)
+        .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
         .await?
         .start_subgraph_deployment(&LOGGER)
         .await?;
@@ -199,45 +221,98 @@ pub async fn create_test_subgraph(subgraph_id: &DeploymentHash, schema: &str) ->
     create_subgraph(subgraph_id, schema, None).await.unwrap()
 }
 
-pub fn remove_subgraph(id: &DeploymentHash) {
-    let name = {
-        let mut name = id.to_string();
-        name.truncate(32);
-        SubgraphName::new(name).unwrap()
+pub async fn create_test_subgraph_with_features(
+    subgraph_id: &DeploymentHash,
+    schema: &str,
+) -> DeploymentLocator {
+    let schema = InputSchema::parse_latest(schema, subgraph_id.clone()).unwrap();
+
+    let features = [
+        SubgraphFeature::FullTextSearch,
+        SubgraphFeature::NonFatalErrors,
+    ]
+    .iter()
+    .cloned()
+    .collect::<BTreeSet<_>>();
+
+    let manifest = SubgraphManifest::<graph::blockchain::mock::MockBlockchain> {
+        id: subgraph_id.clone(),
+        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(),
+        data_sources: vec![DataSource::Onchain(MockDataSource {
+            kind: DATA_SOURCE_KIND.into(),
+            api_version: Version::new(1, 0, 0),
+            network: Some(NETWORK_NAME.into()),
+        })],
+        graft: None,
+        templates: vec![],
+        chain: PhantomData,
+        indexer_hints: None,
     };
-    SUBGRAPH_STORE.remove_subgraph(name).unwrap();
-    for detail in SUBGRAPH_STORE.record_unused_deployments().unwrap() {
-        SUBGRAPH_STORE.remove_deployment(detail.id).unwrap();
+
+    let deployment_features = manifest.deployment_features();
+
+    let locator = create_subgraph_with_manifest(subgraph_id, schema, manifest, None)
+        .await
+        .unwrap();
+
+    SUBGRAPH_STORE
+        .create_subgraph_features(deployment_features)
+        .await
+        .unwrap();
+
+    locator
+}
+
+pub async fn remove_subgraph(id: &DeploymentHash) {
+    let name = SubgraphName::new_unchecked(id.to_string());
+    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()).await.unwrap().unwrap();
+        conn.unassign_subgraph(&site).await.unwrap();
+        SUBGRAPH_STORE.remove_deployment(site.id).await.unwrap();
     }
 }
 
 /// Transact errors for this block and wait until changes have been written
+/// Takes store, deployment, block ptr to, errors, and a bool indicating whether
+/// nonFatalErrors are active
 pub async fn transact_errors(
     store: &Arc<Store>,
     deployment: &DeploymentLocator,
     block_ptr_to: BlockPtr,
     errs: Vec<SubgraphError>,
+    is_non_fatal_errors_active: bool,
 ) -> Result<(), StoreError> {
-    let metrics_registry = Arc::new(MockMetricsRegistry::new());
+    let metrics_registry = Arc::new(MetricsRegistry::mock());
     let stopwatch_metrics = StopwatchMetrics::new(
         Logger::root(slog::Discard, o!()),
         deployment.hash.clone(),
         "transact",
         metrics_registry.clone(),
+        store.subgraph_store().shard(deployment).await?.to_string(),
     );
+    let block_time = BlockTime::for_test(&block_ptr_to);
     store
         .subgraph_store()
-        .writable(LOGGER.clone(), deployment.id)
+        .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
         .await?
         .transact_block_operations(
             block_ptr_to,
+            block_time,
             FirehoseCursor::None,
             Vec::new(),
             &stopwatch_metrics,
             Vec::new(),
             errs,
             Vec::new(),
-            Vec::new(),
+            is_non_fatal_errors_active,
+            false,
         )
         .await?;
     flush(deployment).await
@@ -288,31 +363,44 @@ 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(LOGGER.clone(), deployment.id))?;
-    let mut entity_cache = EntityCache::new(Arc::new(store.clone()));
-    entity_cache.append(ops);
-    let mods = entity_cache
-        .as_modifications()
-        .expect("failed to convert to modifications")
-        .modifications;
-    let metrics_registry = Arc::new(MockMetricsRegistry::new());
+    let store = graph::futures03::executor::block_on(store.cheap_clone().writable(
+        LOGGER.clone(),
+        deployment.id,
+        Arc::new(manifest_idx_and_name),
+    ))?;
+
+    let metrics_registry = Arc::new(MetricsRegistry::mock());
     let stopwatch_metrics = StopwatchMetrics::new(
         Logger::root(slog::Discard, o!()),
         deployment.hash.clone(),
         "transact",
         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(
             block_ptr_to,
+            block_time,
             FirehoseCursor::None,
             mods,
             &stopwatch_metrics,
             data_sources,
             Vec::new(),
-            manifest_idx_and_name,
             Vec::new(),
+            false,
+            false,
         )
         .await
 }
@@ -321,7 +409,7 @@ pub async fn transact_entities_and_dynamic_data_sources(
 pub async fn revert_block(store: &Arc<Store>, deployment: &DeploymentLocator, ptr: &BlockPtr) {
     store
         .subgraph_store()
-        .writable(LOGGER.clone(), deployment.id)
+        .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
         .await
         .expect("can get writable")
         .revert_block_operations(ptr.clone(), FirehoseCursor::None)
@@ -330,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();
 }
 
@@ -350,16 +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 {
-            key: EntityKey {
-                entity_type,
-                entity_id: data.get("id").unwrap().clone().as_string().unwrap().into(),
-                causality_region: CausalityRegion::ONCHAIN,
-            },
+    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,
@@ -376,7 +463,7 @@ pub async fn insert_entities(
 pub async fn flush(deployment: &DeploymentLocator) -> Result<(), StoreError> {
     let writable = SUBGRAPH_STORE
         .cheap_clone()
-        .writable(LOGGER.clone(), deployment.id)
+        .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
         .await
         .expect("we can get a writable");
     writable.flush().await
@@ -388,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())
 }
@@ -441,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;
@@ -458,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()
+                graphql_metrics(),
+                LOAD_MANAGER.clone(),
             )
             .await
         );
-        result.append(
-            execute_query(
-                query.clone(),
-                Some(selection_set),
-                None,
-                QueryExecutionOptions {
-                    resolver,
-                    deadline,
-                    load_manager: LOAD_MANAGER.clone(),
-                    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()
@@ -528,28 +620,33 @@ 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;
 
     let config = Config::load(&LOGGER, &opt)
         .unwrap_or_else(|_| panic!("config is not valid (file={:?})", &opt.config));
-    let registry = Arc::new(MockMetricsRegistry::new());
+    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();
@@ -559,23 +656,42 @@ fn build_store() -> (Arc<Store>, ConnectionPool, Config, Arc<SubscriptionManager
                 genesis_block_hash: GENESIS_PTR.hash.clone(),
             };
 
-            (
-                builder.network_store(vec![
-                    (NETWORK_NAME.to_string(), vec![ident.clone()]),
-                    (FAKE_NETWORK_SHARED.to_string(), vec![ident]),
-                ]),
-                primary_pool,
-                config,
-                subscription_manager,
-            )
+            let store = builder
+                .network_store(
+                    vec![
+                        (NETWORK_NAME.to_string()),
+                        (FAKE_NETWORK_SHARED.to_string()),
+                    ]
+                    .into_iter()
+                    .collect(),
+                )
+                .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.rs b/store/test-store/tests/chain.rs
new file mode 100644
index 00000000000..3364791c26e
--- /dev/null
+++ b/store/test-store/tests/chain.rs
@@ -0,0 +1,5 @@
+pub mod chain {
+    pub mod ethereum {
+        pub mod manifest;
+    }
+}
diff --git a/chain/ethereum/tests/full-text.graphql b/store/test-store/tests/chain/ethereum/full-text.graphql
similarity index 79%
rename from chain/ethereum/tests/full-text.graphql
rename to store/test-store/tests/chain/ethereum/full-text.graphql
index 8fd94519ca0..e3ba2a0beb5 100644
--- a/chain/ethereum/tests/full-text.graphql
+++ b/store/test-store/tests/chain/ethereum/full-text.graphql
@@ -18,8 +18,8 @@ type Band @entity {
   name: String!
   description: String!
   bio: String
-  wallet: Address
-  labels: [Label!]!
-  discography: [Album!]!
-  members: [Musician!]!
+  wallet: String
+  labels: [String!]!
+  discography: [String!]!
+  members: [String!]!
 }
diff --git a/chain/ethereum/tests/ipfs-on-ethereum-contracts.ts b/store/test-store/tests/chain/ethereum/ipfs-on-ethereum-contracts.ts
similarity index 100%
rename from chain/ethereum/tests/ipfs-on-ethereum-contracts.ts
rename to store/test-store/tests/chain/ethereum/ipfs-on-ethereum-contracts.ts
diff --git a/chain/ethereum/tests/ipfs-on-ethereum-contracts.wasm b/store/test-store/tests/chain/ethereum/ipfs-on-ethereum-contracts.wasm
similarity index 100%
rename from chain/ethereum/tests/ipfs-on-ethereum-contracts.wasm
rename to store/test-store/tests/chain/ethereum/ipfs-on-ethereum-contracts.wasm
diff --git a/store/test-store/tests/chain/ethereum/manifest.rs b/store/test-store/tests/chain/ethereum/manifest.rs
new file mode 100644
index 00000000000..b58540679ce
--- /dev/null
+++ b/store/test-store/tests/chain/ethereum/manifest.rs
@@ -0,0 +1,1939 @@
+use std::collections::HashMap;
+use std::num::NonZeroU32;
+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::Value;
+use graph::data::store::scalar::Bytes;
+use graph::data::subgraph::schema::SubgraphError;
+use graph::data::subgraph::{
+    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::{DataSourceEnum, DataSourceTemplate};
+use graph::entity;
+use graph::env::ENV_VARS;
+use graph::prelude::alloy::primitives::B256;
+use graph::prelude::{
+    BigDecimal, BigInt, DeploymentHash, Link, SubgraphManifest, SubgraphManifestResolveError,
+    SubgraphManifestValidationError, SubgraphStore, UnvalidatedSubgraphManifest, anyhow,
+    serde_yaml,
+};
+use graph::{
+    blockchain::NodeCapabilities as _,
+    components::link_resolver::{JsonValueStream, LinkResolver, LinkResolverContext},
+    data::subgraph::SubgraphFeature,
+};
+
+use graph::semver::Version;
+use graph_chain_ethereum::{BlockHandlerFilter, Chain, NodeCapabilities};
+use test_store::LOGGER;
+
+const GQL_SCHEMA: &str = r#"
+  type Thing @entity { id: ID! }
+  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 = "{}";
+const FILE_CID: &str = "bafkreigkhuldxkyfkoaye4rgcqcwr45667vkygd45plwq6hawy7j4rbdky";
+
+#[derive(Default, Debug, Clone)]
+struct TextResolver {
+    texts: HashMap<String, Vec<u8>>,
+}
+
+impl TextResolver {
+    fn add(&mut self, link: &str, text: &impl AsRef<[u8]>) {
+        self.texts.insert(link.to_owned(), text.as_ref().to_vec());
+    }
+}
+
+#[async_trait]
+impl LinkResolver for TextResolver {
+    fn with_timeout(&self, _timeout: Duration) -> Box<dyn LinkResolver> {
+        Box::new(self.clone())
+    }
+
+    fn with_retries(&self) -> Box<dyn LinkResolver> {
+        Box::new(self.clone())
+    }
+
+    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))
+            .cloned()
+    }
+
+    async fn get_block(
+        &self,
+        _ctx: &LinkResolverContext,
+        _link: &Link,
+    ) -> Result<Vec<u8>, anyhow::Error> {
+        unimplemented!()
+    }
+
+    async fn json_stream(
+        &self,
+        _ctx: &LinkResolverContext,
+        _link: &Link,
+    ) -> Result<JsonValueStream, anyhow::Error> {
+        unimplemented!()
+    }
+}
+
+async fn try_resolve_manifest(
+    text: &str,
+    max_spec_version: Version,
+) -> Result<SubgraphManifest<graph_chain_ethereum::Chain>, anyhow::Error> {
+    let mut resolver = TextResolver::default();
+    let id = DeploymentHash::new("Qmmanifest").unwrap();
+
+    resolver.add(id.as_str(), &text);
+    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 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?)
+}
+
+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")
+}
+
+async fn resolve_unvalidated(text: &str) -> UnvalidatedSubgraphManifest<Chain> {
+    let mut resolver = TextResolver::default();
+    let id = DeploymentHash::new("Qmmanifest").unwrap();
+
+    resolver.add(id.as_str(), &text);
+    resolver.add("/ipfs/Qmschema", &GQL_SCHEMA);
+
+    let resolver: Arc<dyn LinkResolver> = Arc::new(resolver);
+
+    let raw = serde_yaml::from_str(text).unwrap();
+    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`
+
+#[graph::test]
+async fn simple_manifest() {
+    const YAML: &str = "
+dataSources: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+specVersion: 0.0.2
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
+
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+    assert!(manifest.graft.is_none());
+}
+
+#[graph::test]
+async fn ipfs_manifest() {
+    let yaml = "
+schema:
+  file:
+    /: /ipfs/Qmschema
+dataSources: []
+templates:
+  - name: IpfsSource
+    kind: file/ipfs
+    mapping:
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      entities:
+        - TestEntity
+      file:
+        /: /ipfs/Qmmapping
+      handler: handleFile
+specVersion: 0.0.7
+";
+
+    let manifest = resolve_manifest(yaml, SPEC_VERSION_0_0_7).await;
+
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+    assert_eq!(manifest.data_sources.len(), 0);
+    let data_source = match &manifest.templates[0] {
+        DataSourceTemplate::Offchain(ds) => ds,
+        DataSourceTemplate::Onchain(_) => unreachable!(),
+        DataSourceTemplate::Subgraph(_) => unreachable!(),
+    };
+    assert_eq!(data_source.kind, OffchainDataSourceKind::Ipfs);
+}
+
+#[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: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+graft:
+  base: Qmbase
+  block: 12345
+specVersion: 0.0.2
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
+
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+    let graft = manifest.graft.expect("The manifest has a graft base");
+    assert_eq!("Qmbase", graft.base.as_str());
+    assert_eq!(12345, graft.block);
+}
+
+#[graph::test]
+async fn parse_indexer_hints() {
+    const YAML: &str = "
+dataSources: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+graft:
+  base: Qmbase
+  block: 12345
+specVersion: 1.0.0
+indexerHints:
+  prune: 100
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_1_0_0).await;
+
+    assert_eq!(manifest.history_blocks(), 100);
+
+    let yaml: &str = "
+    dataSources: []
+    schema:
+      file:
+        /: /ipfs/Qmschema
+    graft:
+      base: Qmbase
+      block: 12345
+    specVersion: 1.0.0
+    indexerHints:
+      prune: auto
+    ";
+
+    let manifest = resolve_manifest(yaml, SPEC_VERSION_1_0_0).await;
+    Prune::Auto.history_blocks();
+    assert_eq!(manifest.history_blocks(), ENV_VARS.min_history_blocks);
+
+    let yaml: &str = "
+    dataSources: []
+    schema:
+      file:
+        /: /ipfs/Qmschema
+    graft:
+      base: Qmbase
+      block: 12345
+    specVersion: 1.0.0
+    indexerHints:
+      prune: never
+    ";
+
+    let manifest = resolve_manifest(yaml, SPEC_VERSION_1_0_0).await;
+
+    assert_eq!(manifest.history_blocks(), BLOCK_NUMBER_MAX);
+}
+
+#[test]
+fn graft_failed_subgraph() {
+    const YAML: &str = "
+dataSources: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+graft:
+  base: Qmbase
+  block: 0
+specVersion: 0.0.2
+";
+
+    test_store::run_test_sequentially(|store| async move {
+        let subgraph_store = store.subgraph_store();
+
+        let unvalidated = resolve_unvalidated(YAML).await;
+        let subgraph = DeploymentHash::new("Qmbase").unwrap();
+
+        // Creates base subgraph at block 0 (genesis).
+        let deployment = test_store::create_test_subgraph(&subgraph, GQL_SCHEMA).await;
+        let schema = store
+            .subgraph_store()
+            .input_schema(&deployment.hash)
+            .await
+            .unwrap();
+
+        // Adds an example entity.
+        let thing = entity! { schema => id: "datthing" };
+        test_store::insert_entities(
+            &deployment,
+            vec![(schema.entity_type("Thing").unwrap(), thing)],
+        )
+        .await
+        .unwrap();
+
+        let error = SubgraphError {
+            subgraph_id: deployment.hash.clone(),
+            message: "deterministic error".to_string(),
+            block_ptr: Some(test_store::BLOCKS[1].clone()),
+            handler: None,
+            deterministic: true,
+        };
+
+        // Fails the base subgraph at block 1 (and advances the pointer).
+        test_store::transact_errors(
+            &store,
+            &deployment,
+            test_store::BLOCKS[1].clone(),
+            vec![error],
+            false,
+        )
+        .await
+        .unwrap();
+
+        // Make sure there are no GraftBaseInvalid errors.
+        //
+        // This is allowed because:
+        // - base:  failed at block 1
+        // - graft: starts at block 0
+        //
+        // Meaning that the graft will fail just like it's parent
+        // but it started at a valid previous block.
+        assert!(
+            !unvalidated
+                .validate(subgraph_store.clone(), true)
+                .await
+                .expect_err("Validation must fail")
+                .into_iter()
+                .any(|e| matches!(&e, SubgraphManifestValidationError::GraftBaseInvalid(_))),
+            "There shouldn't be a GraftBaseInvalid error"
+        );
+
+        // Resolve the graft normally.
+        let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
+
+        assert_eq!("Qmmanifest", manifest.id.as_str());
+        let graft = manifest.graft.expect("The manifest has a graft base");
+        assert_eq!("Qmbase", graft.base.as_str());
+        assert_eq!(0, graft.block);
+    })
+}
+
+#[test]
+fn graft_invalid_manifest() {
+    const YAML: &str = "
+dataSources: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+graft:
+  base: Qmbase
+  block: 1
+specVersion: 0.0.2
+";
+
+    test_store::run_test_sequentially(|store| async move {
+        let subgraph_store = store.subgraph_store();
+
+        let unvalidated = resolve_unvalidated(YAML).await;
+        let subgraph = DeploymentHash::new("Qmbase").unwrap();
+
+        //
+        // Validation against subgraph that hasn't synced anything fails
+        //
+        let deployment = test_store::create_test_subgraph(&subgraph, GQL_SCHEMA).await;
+        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
+        // would be a bit more work; we just want to make sure that
+        // graft-related checks work
+        let msg = unvalidated
+            .validate(subgraph_store.clone(), true)
+            .await
+            .expect_err("Validation must fail")
+            .into_iter()
+            .find(|e| matches!(e, SubgraphManifestValidationError::GraftBaseInvalid(_)))
+            .expect("There must be a GraftBaseInvalid error")
+            .to_string();
+        assert_eq!(
+            "the graft base is invalid: failed to graft onto `Qmbase` since \
+            it has not processed any blocks",
+            msg
+        );
+
+        let thing = entity! { schema => id: "datthing" };
+        test_store::insert_entities(
+            &deployment,
+            vec![(schema.entity_type("Thing").unwrap(), thing)],
+        )
+        .await
+        .unwrap();
+
+        // Validation against subgraph that has not reached the graft point fails
+        let unvalidated = resolve_unvalidated(YAML).await;
+        let msg = unvalidated
+            .validate(subgraph_store.clone(), true)
+            .await
+            .expect_err("Validation must fail")
+            .into_iter()
+            .find(|e| matches!(e, SubgraphManifestValidationError::GraftBaseInvalid(_)))
+            .expect("There must be a GraftBaseInvalid error")
+            .to_string();
+        assert_eq!(
+            "the graft base is invalid: failed to graft onto `Qmbase` \
+            at block 1 since it has only processed block 0",
+            msg
+        );
+
+        let error = SubgraphError {
+            subgraph_id: deployment.hash.clone(),
+            message: "deterministic error".to_string(),
+            block_ptr: Some(test_store::BLOCKS[1].clone()),
+            handler: None,
+            deterministic: true,
+        };
+
+        test_store::transact_errors(
+            &store,
+            &deployment,
+            test_store::BLOCKS[1].clone(),
+            vec![error],
+            false,
+        )
+        .await
+        .unwrap();
+
+        // This check is bit awkward, but we just want to be sure there is a
+        // GraftBaseInvalid error.
+        //
+        // The validation error happens because:
+        // - base:  failed at block 1
+        // - graft: starts at block 1
+        //
+        // Since we start grafts at N + 1, we can't allow a graft to be created
+        // at the failed block. They (developers) should choose a previous valid
+        // block.
+        let unvalidated = resolve_unvalidated(YAML).await;
+        let msg = unvalidated
+            .validate(subgraph_store, true)
+            .await
+            .expect_err("Validation must fail")
+            .into_iter()
+            .find(|e| matches!(e, SubgraphManifestValidationError::GraftBaseInvalid(_)))
+            .expect("There must be a GraftBaseInvalid error")
+            .to_string();
+        assert_eq!(
+            "the graft base is invalid: failed to graft onto `Qmbase` \
+            at block 1 since it's not healthy. You can graft it starting at block 0 backwards",
+            msg
+        );
+    })
+}
+
+#[graph::test]
+async fn parse_data_source_context() {
+    const YAML: &str = "
+dataSources:
+  - kind: ethereum/contract
+    name: Factory
+    network: mainnet
+    context:
+      bool_example:
+        type: Bool
+        data: true
+      int8_example:
+        type: Int8
+        data: 64
+      big_decimal_example:
+        type: BigDecimal
+        data: 10.99
+      bytes_example:
+        type: Bytes
+        data: \"0x68656c6c6f\"
+      list_example:
+        type: List
+        data:
+          - type: Int
+            data: 1
+          - type: Int
+            data: 2
+          - type: Int
+            data: 3
+      big_int_example:
+        type: BigInt
+        data: \"1000000000000000000000000\"
+      string_example:
+        type: String
+        data: \"bar\"
+      int_example:
+        type: Int
+        data: 42
+    source:
+      address: \"0x0000000000000000000000000000000000000000\"
+      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
+      blockHandlers:
+        - handler: handleBlock
+schema:
+  file:
+    /: /ipfs/Qmschema
+specVersion: 0.0.8
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_8).await;
+    let data_source = manifest
+        .data_sources
+        .iter()
+        .find_map(|ds| ds.as_onchain().cloned())
+        .unwrap();
+
+    let context = data_source.context.as_ref().clone().unwrap();
+    let sorted = context.sorted();
+
+    assert_eq!(sorted.len(), 8);
+    assert_eq!(
+        sorted[0],
+        (
+            "big_decimal_example".into(),
+            Value::BigDecimal(BigDecimal::from(10.99))
+        )
+    );
+    assert_eq!(
+        sorted[1],
+        (
+            "big_int_example".into(),
+            Value::BigInt(BigInt::from_str("1000000000000000000000000").unwrap())
+        )
+    );
+    assert_eq!(sorted[2], ("bool_example".into(), Value::Bool(true)));
+    assert_eq!(
+        sorted[3],
+        (
+            "bytes_example".into(),
+            Value::Bytes(Bytes::from_str("0x68656c6c6f").unwrap())
+        )
+    );
+    assert_eq!(sorted[4], ("int8_example".into(), Value::Int8(64)));
+    assert_eq!(sorted[5], ("int_example".into(), Value::Int(42)));
+    assert_eq!(
+        sorted[6],
+        (
+            "list_example".into(),
+            Value::List(vec![Value::Int(1), Value::Int(2), Value::Int(3)])
+        )
+    );
+    assert_eq!(
+        sorted[7],
+        ("string_example".into(), Value::String("bar".into()))
+    );
+}
+
+#[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:
+  - kind: ethereum/contract
+    name: Factory
+    network: mainnet
+    source:
+      address: \"0x0000000000000000000000000000000000000000\"
+      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
+      blockHandlers:
+        - handler: handleBlock
+          filter:
+            kind: polling
+            every: 10
+schema:
+  file:
+    /: /ipfs/Qmschema
+specVersion: 0.0.8
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_8).await;
+    let onchain_data_sources = manifest
+        .data_sources
+        .iter()
+        .filter_map(|ds| ds.as_onchain().cloned())
+        .collect::<Vec<_>>();
+
+    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());
+    assert_eq!(
+        BlockHandlerFilter::Polling {
+            every: NonZeroU32::new(10).unwrap()
+        },
+        filter.unwrap()
+    );
+
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+}
+
+#[graph::test]
+async fn parse_data_source_with_end_block() {
+    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
+schema:
+  file:
+    /: /ipfs/Qmschema
+specVersion: 0.0.9
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_9).await;
+    // Check if end block is parsed correctly
+    let data_source = manifest.data_sources.first().unwrap();
+    let end_block = data_source.as_onchain().unwrap().end_block;
+
+    assert_eq!(Some(9562481), end_block);
+}
+
+#[graph::test]
+async fn parse_block_handlers_with_both_polling_and_once_filter() {
+    const YAML: &str = "
+dataSources:
+  - kind: ethereum/contract
+    name: Factory
+    network: mainnet
+    source:
+      address: \"0x0000000000000000000000000000000000000000\"
+      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
+      blockHandlers:
+        - handler: intitialize
+          filter:
+            kind: once
+        - handler: handleBlock
+          filter:
+            kind: polling
+            every: 10
+schema:
+  file:
+    /: /ipfs/Qmschema
+specVersion: 0.0.8
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_8).await;
+    let onchain_data_sources = manifest
+        .data_sources
+        .iter()
+        .filter_map(|ds| ds.as_onchain().cloned())
+        .collect::<Vec<_>>();
+
+    let data_source = onchain_data_sources.first().unwrap();
+    let validation_errors = data_source.validate(LATEST_VERSION);
+    let filters = data_source
+        .mapping
+        .block_handlers
+        .iter()
+        .map(|h| h.filter.clone())
+        .collect::<Vec<_>>();
+
+    assert_eq!(0, validation_errors.len());
+    assert_eq!(
+        vec![
+            Some(BlockHandlerFilter::Once),
+            Some(BlockHandlerFilter::Polling {
+                every: NonZeroU32::new(10).unwrap()
+            })
+        ],
+        filters
+    );
+
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+}
+
+#[graph::test]
+async fn should_not_parse_block_handlers_with_both_filtered_and_non_filtered_handlers() {
+    const YAML: &str = "
+dataSources:
+  - kind: ethereum/contract
+    name: Factory
+    network: mainnet
+    source:
+      address: \"0x0000000000000000000000000000000000000000\"
+      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
+      blockHandlers:
+        - handler: handleBlock
+        - handler: handleBlockPolling
+          filter:
+            kind: polling
+            every: 10
+schema:
+  file:
+    /: /ipfs/Qmschema
+specVersion: 0.0.8
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_8).await;
+    let onchain_data_sources = manifest
+        .data_sources
+        .iter()
+        .filter_map(|ds| ds.as_onchain().cloned())
+        .collect::<Vec<_>>();
+
+    let data_source = onchain_data_sources.first().unwrap();
+    let validation_errors = data_source.validate(LATEST_VERSION);
+    let filters = data_source
+        .mapping
+        .block_handlers
+        .iter()
+        .map(|h| h.filter.clone())
+        .collect::<Vec<_>>();
+
+    assert_eq!(1, validation_errors.len());
+    assert_eq!(
+        vec![
+            None,
+            Some(BlockHandlerFilter::Polling {
+                every: NonZeroU32::new(10).unwrap()
+            })
+        ],
+        filters
+    );
+
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+}
+
+#[graph::test]
+async fn parse_block_handlers_with_call_filter() {
+    const YAML: &str = "
+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
+      blockHandlers:
+        - handler: handleBlock
+          filter:
+            kind: call
+schema:
+  file:
+    /: /ipfs/Qmschema
+specVersion: 0.0.2
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
+    let onchain_data_sources = manifest
+        .data_sources
+        .iter()
+        .filter_map(|ds| ds.as_onchain().cloned())
+        .collect::<Vec<_>>();
+
+    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!(required_capabilities.traces);
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+}
+
+#[graph::test]
+async fn parse_block_handlers_with_once_filter() {
+    const YAML: &str = "
+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
+      blockHandlers:
+        - handler: handleBlock
+          filter:
+            kind: once
+schema:
+  file:
+    /: /ipfs/Qmschema
+specVersion: 0.0.8
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_8).await;
+    let onchain_data_sources = manifest
+        .data_sources
+        .iter()
+        .filter_map(|ds| ds.as_onchain().cloned())
+        .collect::<Vec<_>>();
+
+    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!(!required_capabilities.traces);
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+}
+
+#[graph::test]
+async fn parse_call_handlers() {
+    const YAML: &str = "
+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
+      callHandlers:
+        - function: get(address)
+          handler: handleget
+schema:
+  file:
+    /: /ipfs/Qmschema
+specVersion: 0.0.2
+";
+
+    let manifest = resolve_manifest(YAML, SPEC_VERSION_0_0_4).await;
+    let onchain_data_sources = manifest
+        .data_sources
+        .iter()
+        .filter_map(|ds| ds.as_onchain().cloned())
+        .collect::<Vec<_>>();
+    let required_capabilities = NodeCapabilities::from_data_sources(&onchain_data_sources);
+
+    assert_eq!("Qmmanifest", manifest.id.as_str());
+    assert!(required_capabilities.traces);
+}
+
+#[test]
+fn undeclared_grafting_feature_causes_feature_validation_error() {
+    const YAML: &str = "
+specVersion: 0.0.4
+dataSources: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+graft:
+  base: Qmbase
+  block: 1
+";
+    test_store::run_test_sequentially(|store| async move {
+        let store = store.subgraph_store();
+        let unvalidated = resolve_unvalidated(YAML).await;
+        let error_msg = unvalidated
+            .validate(store.clone(), true)
+            .await
+            .expect_err("Validation must fail")
+            .into_iter()
+            .find(|e| {
+                matches!(
+                    e,
+                    SubgraphManifestValidationError::FeatureValidationError(_)
+                )
+            })
+            .expect("There must be a FeatureValidation error")
+            .to_string();
+        assert_eq!(
+            "The feature `grafting` is used by the subgraph but it is not declared in the manifest.",
+            error_msg
+        )
+    })
+}
+
+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 = "
+specVersion: 0.0.4
+features:
+  - grafting
+dataSources: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+graft:
+  base: Qmbase
+  block: 1
+";
+    test_store::run_test_sequentially(|store| async move {
+        let store = store.subgraph_store();
+        let unvalidated = resolve_unvalidated(YAML).await;
+        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))
+    })
+}
+
+#[test]
+fn declared_non_fatal_errors_feature_causes_no_feature_validation_errors() {
+    const YAML: &str = "
+specVersion: 0.0.4
+features:
+  - nonFatalErrors
+dataSources: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+";
+    test_store::run_test_sequentially(|store| async move {
+        let store = store.subgraph_store();
+        let unvalidated = resolve_unvalidated(YAML).await;
+        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 declared_full_text_search_feature_causes_no_feature_validation_errors() {
+    const YAML: &str = "
+specVersion: 0.0.4
+features:
+  - fullTextSearch
+dataSources: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+";
+
+    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_FULLTEXT);
+
+            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(),
+            )
+            .await
+            .expect("Parsing simple manifest works")
+        };
+
+        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))
+    });
+}
+
+#[test]
+fn undeclared_full_text_search_feature_causes_no_feature_validation_errors() {
+    const YAML: &str = "
+specVersion: 0.0.4
+
+dataSources: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+";
+
+    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_FULLTEXT);
+
+            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(),
+            )
+            .await
+            .expect("Parsing simple manifest works")
+        };
+
+        let error_msg = unvalidated
+            .validate(store.clone(), true)
+            .await
+            .expect_err("Validation must fail")
+            .into_iter()
+            .find(|e| {
+                matches!(
+                    e,
+                    SubgraphManifestValidationError::FeatureValidationError(_)
+                )
+            })
+            .expect("There must be a FeatureValidationError")
+            .to_string();
+
+        assert_eq!(
+            "The feature `fullTextSearch` is used by the subgraph but it is not declared in the manifest.",
+            error_msg
+        );
+    });
+}
+
+#[test]
+fn undeclared_ipfs_on_ethereum_contracts_feature_causes_feature_validation_error() {
+    const YAML: &str = "
+specVersion: 0.0.4
+schema:
+  file:
+    /: /ipfs/Qmschema
+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
+      callHandlers:
+        - function: get(address)
+          handler: handleget
+";
+
+    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_0_0_4.clone(),
+            )
+            .await
+            .expect("Parsing simple manifest works")
+        };
+
+        let error_msg = unvalidated
+            .validate(store.clone(), true)
+            .await
+            .expect_err("Validation must fail")
+            .into_iter()
+            .find(|e| {
+                matches!(
+                    e,
+                    SubgraphManifestValidationError::FeatureValidationError(_)
+                )
+            })
+            .expect("There must be a FeatureValidationError")
+            .to_string();
+
+        assert_eq!(
+            "The feature `ipfsOnEthereumContracts` is used by the subgraph but it is not declared in the manifest.",
+            error_msg
+        );
+    });
+}
+
+#[test]
+fn declared_ipfs_on_ethereum_contracts_feature_causes_no_errors() {
+    const YAML: &str = "
+specVersion: 0.0.4
+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
+      callHandlers:
+        - function: get(address)
+          handler: handleget
+";
+
+    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_0_0_4.clone(),
+            )
+            .await
+            .expect("Parsing simple manifest works")
+        };
+
+        let has_error = has_feature_validation_error(unvalidated, store).await;
+        assert!(!has_error, "There must be no FeatureValidationError");
+    });
+}
+
+#[test]
+fn can_detect_features_in_subgraphs_with_spec_version_lesser_than_0_0_4() {
+    const YAML: &str = "
+specVersion: 0.0.2
+features:
+  - nonFatalErrors
+dataSources: []
+schema:
+  file:
+    /: /ipfs/Qmschema
+";
+    test_store::run_test_sequentially(|store| async move {
+        let store = store.subgraph_store();
+        let unvalidated = resolve_unvalidated(YAML).await;
+        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.rs b/store/test-store/tests/core.rs
new file mode 100644
index 00000000000..46d45977a1f
--- /dev/null
+++ b/store/test-store/tests/core.rs
@@ -0,0 +1,3 @@
+pub mod core {
+    pub mod interfaces;
+}
diff --git a/store/test-store/tests/core/fixtures/ipfs_folder/hello.txt b/store/test-store/tests/core/fixtures/ipfs_folder/hello.txt
new file mode 100644
index 00000000000..3b18e512dba
--- /dev/null
+++ b/store/test-store/tests/core/fixtures/ipfs_folder/hello.txt
@@ -0,0 +1 @@
+hello world
diff --git a/store/test-store/tests/core/fixtures/ipfs_folder/random.txt b/store/test-store/tests/core/fixtures/ipfs_folder/random.txt
new file mode 100644
index 00000000000..87332e5d5cc
--- /dev/null
+++ b/store/test-store/tests/core/fixtures/ipfs_folder/random.txt
@@ -0,0 +1 @@
+20c12d76-0e6a-428c-b6c9-b7e384ccb6fc
\ No newline at end of file
diff --git a/core/tests/interfaces.rs b/store/test-store/tests/core/interfaces.rs
similarity index 73%
rename from core/tests/interfaces.rs
rename to store/test-store/tests/core/interfaces.rs
index 2c5916ea853..6451b173501 100644
--- a/core/tests/interfaces.rs
+++ b/store/test-store/tests/core/interfaces.rs
@@ -1,8 +1,10 @@
 // Tests for graphql interfaces.
 
+use graph::entity;
+use graph::schema::InputSchema;
 use pretty_assertions::assert_eq;
 
-use graph::{components::store::EntityType, data::graphql::object};
+use graph::data::graphql::object;
 use graph::{data::query::QueryTarget, prelude::*};
 use test_store::*;
 
@@ -15,15 +17,15 @@ async fn insert_and_query(
 ) -> Result<QueryResult, StoreError> {
     let subgraph_id = DeploymentHash::new(subgraph_id).unwrap();
     let deployment = create_test_subgraph(&subgraph_id, schema).await;
-
+    let schema = InputSchema::parse_latest(schema, subgraph_id.clone()).unwrap();
     let entities = entities
         .into_iter()
-        .map(|(entity_type, data)| (EntityType::new(entity_type.to_owned()), data))
+        .map(|(entity_type, data)| (schema.entity_type(entity_type).unwrap(), data))
         .collect();
 
     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)
@@ -43,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 }
@@ -60,20 +62,18 @@ 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 schema = "interface Legged { legs: Int }
+    let document = "interface Legged { legs: Int }
                   type Animal implements Legged @entity { id: ID!, legs: Int }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
-    let entity = (
-        "Animal",
-        Entity::from(vec![("id", Value::from("1")), ("legs", Value::from(3))]),
-    );
+    let entity = ("Animal", entity! { schema => id: "1", legs: 3 });
 
     // Collection query.
     let query = "query { leggeds(first: 100) { legs } }";
-    let res = insert_and_query(subgraph_id, schema, vec![entity], query)
+    let res = insert_and_query(subgraph_id, document, vec![entity], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -82,7 +82,7 @@ async fn one_interface_one_entity() {
 
     // Query by ID.
     let query = "query { legged(id: \"1\") { legs } }";
-    let res = insert_and_query(subgraph_id, schema, vec![], query)
+    let res = insert_and_query(subgraph_id, document, vec![], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -90,20 +90,18 @@ 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 schema = "interface Legged { legs: Int }
+    let document = "interface Legged { legs: Int }
                   type Animal implements Legged @entity { id: ID!, legs: Int }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
-    let entity = (
-        "Animal",
-        Entity::from(vec![("id", Value::from("1")), ("legs", Value::from(3))]),
-    );
+    let entity = ("Animal", entity! { schema => id: "1", legs: 3 });
 
     let query = "query { leggeds(first: 100) { __typename } }";
 
-    let res = insert_and_query(subgraph_id, schema, vec![entity], query)
+    let res = insert_and_query(subgraph_id, document, vec![entity], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -111,26 +109,21 @@ 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 schema = "interface Legged { legs: Int }
+    let document = "interface Legged { legs: Int }
                   type Animal implements Legged @entity { id: ID!, legs: Int }
                   type Furniture implements Legged @entity { id: ID!, legs: Int }
                   ";
+    let schema = InputSchema::raw(document, subgraph_id);
 
-    let animal = (
-        "Animal",
-        Entity::from(vec![("id", Value::from("1")), ("legs", Value::from(3))]),
-    );
-    let furniture = (
-        "Furniture",
-        Entity::from(vec![("id", Value::from("2")), ("legs", Value::from(4))]),
-    );
+    let animal = ("Animal", entity! { schema => id: "1", legs: 3 });
+    let furniture = ("Furniture", entity! { schema => id: "2", legs: 4 });
 
     let query = "query { leggeds(first: 100, orderBy: legs) { legs } }";
 
-    let res = insert_and_query(subgraph_id, schema, vec![animal, furniture], query)
+    let res = insert_and_query(subgraph_id, document, vec![animal, furniture], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -139,7 +132,7 @@ async fn one_interface_multiple_entities() {
 
     // Test for support issue #32.
     let query = "query { legged(id: \"2\") { legs } }";
-    let res = insert_and_query(subgraph_id, schema, vec![], query)
+    let res = insert_and_query(subgraph_id, document, vec![], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -147,22 +140,20 @@ async fn one_interface_multiple_entities() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn reference_interface() {
     let subgraph_id = "ReferenceInterface";
-    let schema = "type Leg @entity { id: ID! }
+    let document = "type Leg @entity { id: ID! }
                   interface Legged { leg: Leg }
                   type Animal implements Legged @entity { id: ID!, leg: Leg }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "query { leggeds(first: 100) { leg { id } } }";
 
-    let leg = ("Leg", Entity::from(vec![("id", Value::from("1"))]));
-    let animal = (
-        "Animal",
-        Entity::from(vec![("id", Value::from("1")), ("leg", Value::from("1"))]),
-    );
+    let leg = ("Leg", entity! { schema => id: "1" });
+    let animal = ("Animal", entity! { schema => id: "1", leg: 1 });
 
-    let res = insert_and_query(subgraph_id, schema, vec![leg, animal], query)
+    let res = insert_and_query(subgraph_id, document, vec![leg, animal], query)
         .await
         .unwrap();
 
@@ -171,12 +162,12 @@ 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
     let subgraph_id = "ReferenceInterfaceDerived";
-    let schema = "
+    let document = "
     type Transaction @entity {
         id: ID!,
         buyEvent: BuyEvent!,
@@ -206,27 +197,24 @@ async fn reference_interface_derived() {
         # Store the transaction directly
         transaction: Transaction!
     }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "query { events { id transaction { id } } }";
 
-    let buy = ("BuyEvent", Entity::from(vec![("id", "buy".into())]));
-    let sell1 = ("SellEvent", Entity::from(vec![("id", "sell1".into())]));
-    let sell2 = ("SellEvent", Entity::from(vec![("id", "sell2".into())]));
+    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::from(vec![("id", "gift".into()), ("transaction", "txn".into())]),
+        entity! { schema => id: "gift", transaction: "txn" },
     );
     let txn = (
         "Transaction",
-        Entity::from(vec![
-            ("id", "txn".into()),
-            ("buyEvent", "buy".into()),
-            ("sellEvents", vec!["sell1", "sell2"].into()),
-        ]),
+        entity! { schema => id: "txn", buyEvent: "buy", sellEvents: vec!["sell1", "sell2"] },
     );
 
     let entities = vec![buy, sell1, sell2, gift, txn];
-    let res = insert_and_query(subgraph_id, schema, entities.clone(), query)
+    let res = insert_and_query(subgraph_id, document, entities.clone(), query)
         .await
         .unwrap();
 
@@ -242,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! }
@@ -275,36 +263,29 @@ async fn follow_interface_reference_invalid() {
     }
 }
 
-#[tokio::test]
+#[graph::test]
 async fn follow_interface_reference() {
     let subgraph_id = "FollowInterfaceReference";
-    let schema = "interface Legged { id: ID!, legs: Int! }
+    let document = "interface Legged { id: ID!, legs: Int! }
                   type Animal implements Legged @entity {
                     id: ID!
                     legs: Int!
                     parent: Legged
                   }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "query { legged(id: \"child\") { ... on Animal { parent { id } } } }";
 
     let parent = (
         "Animal",
-        Entity::from(vec![
-            ("id", Value::from("parent")),
-            ("legs", Value::from(4)),
-            ("parent", Value::Null),
-        ]),
+        entity! { schema => id: "parent", legs: 4, parent: Value::Null, vid: 0i64},
     );
     let child = (
         "Animal",
-        Entity::from(vec![
-            ("id", Value::from("child")),
-            ("legs", Value::from(3)),
-            ("parent", Value::String("parent".into())),
-        ]),
+        entity! { schema => id: "child", legs: 3, parent: "parent" , vid: 1i64},
     );
 
-    let res = insert_and_query(subgraph_id, schema, vec![parent, child], query)
+    let res = insert_and_query(subgraph_id, document, vec![parent, child], query)
         .await
         .unwrap();
 
@@ -315,57 +296,48 @@ async fn follow_interface_reference() {
     assert_eq!(data, exp)
 }
 
-#[tokio::test]
+#[graph::test]
 async fn conflicting_implementors_id() {
     let subgraph_id = "ConflictingImplementorsId";
-    let schema = "interface Legged { legs: Int }
+    let document = "interface Legged { legs: Int }
                   type Animal implements Legged @entity { id: ID!, legs: Int }
                   type Furniture implements Legged @entity { id: ID!, legs: Int }
                   ";
+    let schema = InputSchema::raw(document, subgraph_id);
 
-    let animal = (
-        "Animal",
-        Entity::from(vec![("id", Value::from("1")), ("legs", Value::from(3))]),
-    );
-    let furniture = (
-        "Furniture",
-        Entity::from(vec![("id", Value::from("1")), ("legs", Value::from(3))]),
-    );
+    let animal = ("Animal", entity! { schema => id: "1", legs: 3 });
+    let furniture = ("Furniture", entity! { schema => id: "1", legs: 3 });
 
     let query = "query { leggeds(first: 100) { legs } }";
 
-    let res = insert_and_query(subgraph_id, schema, vec![animal, furniture], query).await;
+    let res = insert_and_query(subgraph_id, document, vec![animal, furniture], query).await;
 
     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 schema = "interface ForestDweller { id: ID!, forest: Forest }
+    let document = "interface ForestDweller { id: ID!, forest: Forest }
                   type Animal implements ForestDweller @entity { id: ID!, forest: Forest }
                   type Forest @entity { id: ID!, dwellers: [ForestDweller]! @derivedFrom(field: \"forest\") }
                   ";
+    let schema = InputSchema::raw(document, subgraph_id);
 
-    let forest = ("Forest", Entity::from(vec![("id", Value::from("1"))]));
-    let animal = (
-        "Animal",
-        Entity::from(vec![("id", Value::from("1")), ("forest", Value::from("1"))]),
-    );
+    let forest = ("Forest", entity! { schema => id: "1" });
+    let animal = ("Animal", entity! { schema => id: "1", forest: "1" });
 
     let query = "query { forests(first: 100) { dwellers(first: 100) { id } } }";
 
-    let res = insert_and_query(subgraph_id, schema, vec![forest, animal], query)
+    let res = insert_and_query(subgraph_id, document, vec![forest, animal], query)
         .await
         .unwrap();
     let data = extract_data!(res);
@@ -375,10 +347,10 @@ async fn derived_interface_relationship() {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn two_interfaces() {
     let subgraph_id = "TwoInterfaces";
-    let schema = "interface IFoo { foo: String! }
+    let document = "interface IFoo { foo: String! }
                   interface IBar { bar: Int! }
 
                   type A implements IFoo @entity { id: ID!, foo: String! }
@@ -386,29 +358,17 @@ async fn two_interfaces() {
 
                   type AB implements IFoo & IBar @entity { id: ID!, foo: String!, bar: Int! }
                   ";
+    let schema = InputSchema::raw(document, subgraph_id);
 
-    let a = (
-        "A",
-        Entity::from(vec![("id", Value::from("1")), ("foo", Value::from("bla"))]),
-    );
-    let b = (
-        "B",
-        Entity::from(vec![("id", Value::from("1")), ("bar", Value::from(100))]),
-    );
-    let ab = (
-        "AB",
-        Entity::from(vec![
-            ("id", Value::from("2")),
-            ("foo", Value::from("ble")),
-            ("bar", Value::from(200)),
-        ]),
-    );
+    let a = ("A", entity! { schema => id: "1", foo: "bla" });
+    let b = ("B", entity! { schema => id: "1", bar: 100 });
+    let ab = ("AB", entity! { schema => id: "2", foo: "ble", bar: 200 });
 
     let query = "query {
                     ibars(first: 100, orderBy: bar) { bar }
                     ifoos(first: 100, orderBy: foo) { foo }
                 }";
-    let res = insert_and_query(subgraph_id, schema, vec![a, b, ab], query)
+    let res = insert_and_query(subgraph_id, document, vec![a, b, ab], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -419,24 +379,21 @@ async fn two_interfaces() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn interface_non_inline_fragment() {
     let subgraph_id = "interfaceNonInlineFragment";
-    let schema = "interface Legged { legs: Int }
+    let document = "interface Legged { legs: Int }
                   type Animal implements Legged @entity { id: ID!, name: String, legs: Int }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let entity = (
         "Animal",
-        Entity::from(vec![
-            ("id", Value::from("1")),
-            ("name", Value::from("cow")),
-            ("legs", Value::from(3)),
-        ]),
+        entity! { schema => id: "1", name: "cow", legs: 3 },
     );
 
     // Query only the fragment.
     let query = "query { leggeds { ...frag } } fragment frag on Animal { name }";
-    let res = insert_and_query(subgraph_id, schema, vec![entity], query)
+    let res = insert_and_query(subgraph_id, document, vec![entity], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -445,7 +402,7 @@ async fn interface_non_inline_fragment() {
 
     // Query the fragment and something else.
     let query = "query { leggeds { legs, ...frag } } fragment frag on Animal { name }";
-    let res = insert_and_query(subgraph_id, schema, vec![], query)
+    let res = insert_and_query(subgraph_id, document, vec![], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -453,33 +410,23 @@ async fn interface_non_inline_fragment() {
     assert_eq!(data, exp);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn interface_inline_fragment() {
     let subgraph_id = "interfaceInlineFragment";
-    let schema = "interface Legged { legs: Int }
+    let document = "interface Legged { legs: Int }
                   type Animal implements Legged @entity { id: ID!, name: String, legs: Int }
                   type Bird implements Legged @entity { id: ID!, airspeed: Int, legs: Int }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let animal = (
         "Animal",
-        Entity::from(vec![
-            ("id", Value::from("1")),
-            ("name", Value::from("cow")),
-            ("legs", Value::from(4)),
-        ]),
-    );
-    let bird = (
-        "Bird",
-        Entity::from(vec![
-            ("id", Value::from("2")),
-            ("airspeed", Value::from(24)),
-            ("legs", Value::from(2)),
-        ]),
+        entity! { schema => id: "1", name: "cow", legs: 4 },
     );
+    let bird = ("Bird", entity! { schema => id: "2", airspeed: 24, legs: 2 });
 
     let query =
         "query { leggeds(orderBy: legs) { ... on Animal { name } ...on Bird { airspeed } } }";
-    let res = insert_and_query(subgraph_id, schema, vec![animal, bird], query)
+    let res = insert_and_query(subgraph_id, document, vec![animal, bird], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -487,10 +434,10 @@ 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 schema = "
+    let document = "
         interface Legged { legs: Int }
         type Parent @entity {
           id: ID!
@@ -508,39 +455,24 @@ async fn interface_inline_fragment_with_subquery() {
           parent: Parent
         }
     ";
+    let schema = InputSchema::raw(document, subgraph_id);
 
-    let mama_cow = (
-        "Parent",
-        Entity::from(vec![("id", Value::from("mama_cow"))]),
-    );
+    let mama_cow = ("Parent", entity! { schema =>  id: "mama_cow", vid: 0i64 });
     let cow = (
         "Animal",
-        Entity::from(vec![
-            ("id", Value::from("1")),
-            ("name", Value::from("cow")),
-            ("legs", Value::from(4)),
-            ("parent", Value::from("mama_cow")),
-        ]),
+        entity! { schema =>  id: "1", name: "cow", legs: 4, parent: "mama_cow", vid: 0i64 },
     );
 
-    let mama_bird = (
-        "Parent",
-        Entity::from(vec![("id", Value::from("mama_bird"))]),
-    );
+    let mama_bird = ("Parent", entity! { schema =>  id: "mama_bird", vid: 1i64 });
     let bird = (
         "Bird",
-        Entity::from(vec![
-            ("id", Value::from("2")),
-            ("airspeed", Value::from(5)),
-            ("legs", Value::from(2)),
-            ("parent", Value::from("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 } } } }";
     let res = insert_and_query(
         subgraph_id,
-        schema,
+        document,
         vec![cow, mama_cow, bird, mama_bird],
         query,
     )
@@ -554,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! }
@@ -586,15 +518,16 @@ async fn invalid_fragment() {
     }
 }
 
-#[tokio::test]
+#[graph::test]
 async fn alias() {
     let subgraph_id = "Alias";
-    let schema = "interface Legged { id: ID!, legs: Int! }
+    let document = "interface Legged { id: ID!, legs: Int! }
                   type Animal implements Legged @entity {
                     id: ID!
                     legs: Int!
                     parent: Legged
                   }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "query {
                     l: legged(id: \"child\") {
@@ -610,22 +543,14 @@ async fn alias() {
 
     let parent = (
         "Animal",
-        Entity::from(vec![
-            ("id", Value::from("parent")),
-            ("legs", Value::from(4)),
-            ("parent", Value::Null),
-        ]),
+        entity! { schema =>  id: "parent", legs: 4, parent: Value::Null, vid: 0i64 },
     );
     let child = (
         "Animal",
-        Entity::from(vec![
-            ("id", Value::from("child")),
-            ("legs", Value::from(3)),
-            ("parent", Value::String("parent".into())),
-        ]),
+        entity! { schema =>  id: "child", legs: 3, parent: "parent", vid: 1i64 },
     );
 
-    let res = insert_and_query(subgraph_id, schema, vec![parent, child], query)
+    let res = insert_and_query(subgraph_id, document, vec![parent, child], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -643,10 +568,10 @@ async fn alias() {
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn fragments_dont_panic() {
     let subgraph_id = "FragmentsDontPanic";
-    let schema = "
+    let document = "
       type Parent @entity {
         id: ID!
         child: Child
@@ -656,6 +581,7 @@ async fn fragments_dont_panic() {
         id: ID!
       }
     ";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "
         query {
@@ -682,26 +608,15 @@ async fn fragments_dont_panic() {
     // The panic manifests if two parents exist.
     let parent = (
         "Parent",
-        entity!(
-            id: "p",
-            child: "c",
-        ),
+        entity! { schema => id: "p", child: "c", vid: 0i64 },
     );
     let parent2 = (
         "Parent",
-        entity!(
-            id: "p2",
-            child: Value::Null,
-        ),
-    );
-    let child = (
-        "Child",
-        entity!(
-            id:"c"
-        ),
+        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, schema, vec![parent, parent2, child], query)
+    let res = insert_and_query(subgraph_id, document, vec![parent, parent2, child], query)
         .await
         .unwrap();
 
@@ -724,10 +639,10 @@ async fn fragments_dont_panic() {
 }
 
 // See issue #1816
-#[tokio::test]
+#[graph::test]
 async fn fragments_dont_duplicate_data() {
     let subgraph_id = "FragmentsDupe";
-    let schema = "
+    let document = "
       type Parent @entity {
         id: ID!
         children: [Child!]!
@@ -737,6 +652,7 @@ async fn fragments_dont_duplicate_data() {
         id: ID!
       }
     ";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "
         query {
@@ -758,26 +674,15 @@ async fn fragments_dont_duplicate_data() {
     // This bug manifests if two parents exist.
     let parent = (
         "Parent",
-        entity!(
-            id: "p",
-            children: vec!["c"]
-        ),
+        entity! { schema => id: "p", children: vec!["c"], vid: 0i64 },
     );
     let parent2 = (
         "Parent",
-        entity!(
-            id: "b",
-            children: Vec::<String>::new()
-        ),
-    );
-    let child = (
-        "Child",
-        entity!(
-            id:"c"
-        ),
+        entity! { schema => id: "b", children: Vec::<String>::new(), vid: 1i64 },
     );
+    let child = ("Child", entity! { schema => id:"c", vid: 2i64 });
 
-    let res = insert_and_query(subgraph_id, schema, vec![parent, parent2, child], query)
+    let res = insert_and_query(subgraph_id, document, vec![parent, parent2, child], query)
         .await
         .unwrap();
 
@@ -802,14 +707,15 @@ 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 schema = "interface Legged { id: ID!, parent: Legged }
+    let document = "interface Legged { id: ID!, parent: Legged }
                   type Animal implements Legged @entity {
                     id: ID!
                     parent: Legged
                   }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "query {
                     leggeds {
@@ -822,20 +728,14 @@ async fn redundant_fields() {
 
     let parent = (
         "Animal",
-        entity!(
-            id: "parent",
-            parent: Value::Null,
-        ),
+        entity! { schema => id: "parent", parent: Value::Null, vid: 0i64 },
     );
     let child = (
         "Animal",
-        entity!(
-            id: "child",
-            parent: "parent",
-        ),
+        entity! { schema => id: "child", parent: "parent", vid: 1i64 },
     );
 
-    let res = insert_and_query(subgraph_id, schema, vec![parent, child], query)
+    let res = insert_and_query(subgraph_id, document, vec![parent, child], query)
         .await
         .unwrap();
 
@@ -857,10 +757,10 @@ async fn redundant_fields() {
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn fragments_merge_selections() {
     let subgraph_id = "FragmentsMergeSelections";
-    let schema = "
+    let document = "
       type Parent @entity {
         id: ID!
         children: [Child!]!
@@ -871,6 +771,7 @@ async fn fragments_merge_selections() {
         foo: Int!
       }
     ";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "
         query {
@@ -891,20 +792,11 @@ async fn fragments_merge_selections() {
 
     let parent = (
         "Parent",
-        entity!(
-            id: "p",
-            children: vec!["c"]
-        ),
-    );
-    let child = (
-        "Child",
-        entity!(
-            id: "c",
-            foo: 1,
-        ),
+        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, schema, vec![parent, child], query)
+    let res = insert_and_query(subgraph_id, document, vec![parent, child], query)
         .await
         .unwrap();
 
@@ -926,10 +818,10 @@ async fn fragments_merge_selections() {
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn merge_fields_not_in_interface() {
     let subgraph_id = "MergeFieldsNotInInterface";
-    let schema = "interface Iface { id: ID! }
+    let document = "interface Iface { id: ID! }
                   type Animal implements Iface @entity {
                     id: ID!
                     human: Iface!
@@ -939,6 +831,7 @@ async fn merge_fields_not_in_interface() {
                     animal: Iface!
                   }
                   ";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "query {
                     ifaces {
@@ -957,22 +850,10 @@ async fn merge_fields_not_in_interface() {
                     }
             }";
 
-    let animal = (
-        "Animal",
-        entity!(
-            id: "cow",
-            human: "fred",
-        ),
-    );
-    let human = (
-        "Human",
-        entity!(
-            id: "fred",
-            animal: "cow",
-        ),
-    );
+    let animal = ("Animal", entity! { schema => id: "cow", human: "fred" });
+    let human = ("Human", entity! { schema => id: "fred", animal: "cow" });
 
-    let res = insert_and_query(subgraph_id, schema, vec![animal, human], query)
+    let res = insert_and_query(subgraph_id, document, vec![animal, human], query)
         .await
         .unwrap();
 
@@ -998,10 +879,10 @@ async fn merge_fields_not_in_interface() {
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn nested_interface_fragments() {
     let subgraph_id = "NestedInterfaceFragments";
-    let schema = "interface I1face { id: ID!, foo1: Foo! }
+    let document = "interface I1face { id: ID!, foo1: Foo! }
                   interface I2face { id: ID!, foo2: Foo! }
                   interface I3face { id: ID!, foo3: Foo! }
                   type Foo @entity {
@@ -1022,6 +903,7 @@ async fn nested_interface_fragments() {
                     foo2: Foo!
                     foo3: Foo!
                   }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "query {
                     i1Faces {
@@ -1042,38 +924,18 @@ async fn nested_interface_fragments() {
                     }
             }";
 
-    let foo = (
-        "Foo",
-        entity!(
-            id: "foo",
-        ),
-    );
-    let one = (
-        "One",
-        entity!(
-            id: "1",
-            foo1: "foo",
-        ),
-    );
+    let foo = ("Foo", entity! { schema => id: "foo" });
+    let one = ("One", entity! { schema => id: "1", foo1: "foo" });
     let two = (
         "Two",
-        entity!(
-            id: "2",
-            foo1: "foo",
-            foo2: "foo",
-        ),
+        entity! { schema => id: "2", foo1: "foo", foo2: "foo" },
     );
     let three = (
         "Three",
-        entity!(
-            id: "3",
-            foo1: "foo",
-            foo2: "foo",
-            foo3: "foo"
-        ),
+        entity! { schema => id: "3", foo1: "foo", foo2: "foo", foo3: "foo" },
     );
 
-    let res = insert_and_query(subgraph_id, schema, vec![foo, one, two, three], query)
+    let res = insert_and_query(subgraph_id, document, vec![foo, one, two, three], query)
         .await
         .unwrap();
 
@@ -1114,10 +976,10 @@ async fn nested_interface_fragments() {
     )
 }
 
-#[tokio::test]
+#[graph::test]
 async fn nested_interface_fragments_overlapping() {
     let subgraph_id = "NestedInterfaceFragmentsOverlapping";
-    let schema = "interface I1face { id: ID!, foo1: Foo! }
+    let document = "interface I1face { id: ID!, foo1: Foo! }
                   interface I2face { id: ID!, foo1: Foo! }
                   type Foo @entity {
                       id: ID!
@@ -1130,6 +992,7 @@ async fn nested_interface_fragments_overlapping() {
                     id: ID!
                     foo1: Foo!
                   }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "query {
                     i1Faces {
@@ -1142,27 +1005,10 @@ async fn nested_interface_fragments_overlapping() {
                     }
             }";
 
-    let foo = (
-        "Foo",
-        entity!(
-            id: "foo",
-        ),
-    );
-    let one = (
-        "One",
-        entity!(
-            id: "1",
-            foo1: "foo",
-        ),
-    );
-    let two = (
-        "Two",
-        entity!(
-            id: "2",
-            foo1: "foo",
-        ),
-    );
-    let res = insert_and_query(subgraph_id, schema, vec![foo, one, two], query)
+    let foo = ("Foo", entity! { schema => id: "foo" });
+    let one = ("One", entity! { schema => id: "1", foo1: "foo" });
+    let two = ("Two", entity! { schema => id: "2", foo1: "foo" });
+    let res = insert_and_query(subgraph_id, document, vec![foo, one, two], query)
         .await
         .unwrap();
 
@@ -1198,7 +1044,7 @@ async fn nested_interface_fragments_overlapping() {
         }
     }";
 
-    let res = insert_and_query(subgraph_id, schema, vec![], query)
+    let res = insert_and_query(subgraph_id, document, vec![], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -1223,11 +1069,11 @@ async fn nested_interface_fragments_overlapping() {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn enums() {
     use r::Value::Enum;
     let subgraph_id = "enums";
-    let schema = r#"
+    let document = r#"
        enum Direction {
          NORTH
          EAST
@@ -1240,28 +1086,21 @@ async fn enums() {
          direction: Direction!
          meters: Int!
        }"#;
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let entities = vec![
         (
             "Trajectory",
-            Entity::from(vec![
-                ("id", Value::from("1")),
-                ("direction", Value::from("EAST")),
-                ("meters", Value::from(10)),
-            ]),
+            entity! { schema =>  id: "1", direction: "EAST", meters: 10, vid: 0i64 },
         ),
         (
             "Trajectory",
-            Entity::from(vec![
-                ("id", Value::from("2")),
-                ("direction", Value::from("NORTH")),
-                ("meters", Value::from(15)),
-            ]),
+            entity! { schema =>  id: "2", direction: "NORTH", meters: 15, vid: 1i64 },
         ),
     ];
     let query = "query { trajectories { id, direction, meters } }";
 
-    let res = insert_and_query(subgraph_id, schema, entities, query)
+    let res = insert_and_query(subgraph_id, document, entities, query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -1283,11 +1122,11 @@ async fn enums() {
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn enum_list_filters() {
     use r::Value::Enum;
     let subgraph_id = "enum_list_filters";
-    let schema = r#"
+    let document = r#"
        enum Direction {
          NORTH
          EAST
@@ -1300,36 +1139,25 @@ async fn enum_list_filters() {
          direction: Direction!
          meters: Int!
        }"#;
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let entities = vec![
         (
             "Trajectory",
-            Entity::from(vec![
-                ("id", Value::from("1")),
-                ("direction", Value::from("EAST")),
-                ("meters", Value::from(10)),
-            ]),
+            entity! { schema =>  id: "1", direction: "EAST", meters: 10, vid: 0i64 },
         ),
         (
             "Trajectory",
-            Entity::from(vec![
-                ("id", Value::from("2")),
-                ("direction", Value::from("NORTH")),
-                ("meters", Value::from(15)),
-            ]),
+            entity! { schema =>  id: "2", direction: "NORTH", meters: 15, vid: 1i64 },
         ),
         (
             "Trajectory",
-            Entity::from(vec![
-                ("id", Value::from("3")),
-                ("direction", Value::from("WEST")),
-                ("meters", Value::from(20)),
-            ]),
+            entity! { schema =>  id: "3", direction: "WEST", meters: 20, vid: 2i64 },
         ),
     ];
 
     let query = "query { trajectories(where: { direction_in: [NORTH, EAST] }) { id, direction } }";
-    let res = insert_and_query(subgraph_id, schema, entities, query)
+    let res = insert_and_query(subgraph_id, document, entities, query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -1349,7 +1177,7 @@ async fn enum_list_filters() {
     );
 
     let query = "query { trajectories(where: { direction_not_in: [EAST] }) { id, direction } }";
-    let res = insert_and_query(subgraph_id, schema, vec![], query)
+    let res = insert_and_query(subgraph_id, document, vec![], query)
         .await
         .unwrap();
     let data = extract_data!(res).unwrap();
@@ -1369,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
@@ -1443,18 +1271,22 @@ 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 schema = "interface Event { id: String! }
+    let document = "interface Event { id: String! }
                   type Mutable implements Event @entity { id: String!, name: String! }
                   type Immutable implements Event @entity(immutable: true) { id: String!, name: String! }";
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "query { events { id } }";
 
     let entities = vec![
-        ("Mutable", entity! { id: "mut0", name: "mut0" }),
-        ("Immutable", entity! { id: "immo0", name: "immo0" }),
+        ("Mutable", entity! { schema =>  id: "mut0", name: "mut0" }),
+        (
+            "Immutable",
+            entity! { schema =>  id: "immo0", name: "immo0" },
+        ),
     ];
 
     {
@@ -1463,9 +1295,9 @@ 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, schema, entities, query)
+    let res = insert_and_query(subgraph_id, document, entities, query)
         .await
         .unwrap();
 
@@ -1474,10 +1306,14 @@ 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())
+    }
+
     let subgraph_id = "DerivedInterfaceBytes";
-    let schema = r#" type Pool {
+    let document = r#" type Pool @entity {
         id: Bytes!,
         trades: [Trade!]! @derivedFrom(field: "pool")
       }
@@ -1495,16 +1331,17 @@ async fn derived_interface_bytes() {
        id: Bytes!
        pool: Pool!
       }"#;
+    let schema = InputSchema::raw(document, subgraph_id);
 
     let query = "query { pools { trades { id } } }";
 
     let entities = vec![
-        ("Pool", entity! { id: "0xf001" }),
-        ("Sell", entity! { id: "0xc0", pool: "0xf001"}),
-        ("Buy", entity! { id: "0xb0", pool: "0xf001"}),
+        ("Pool", entity! { schema =>  id: b("0xf001") }),
+        ("Sell", entity! { schema =>  id: b("0xc0"), pool: "0xf001" }),
+        ("Buy", entity! { schema =>  id: b("0xb0"), pool: "0xf001" }),
     ];
 
-    let res = insert_and_query(subgraph_id, schema, entities, query)
+    let res = insert_and_query(subgraph_id, document, entities, query)
         .await
         .unwrap();
 
diff --git a/store/test-store/tests/graph.rs b/store/test-store/tests/graph.rs
new file mode 100644
index 00000000000..6c8d2915540
--- /dev/null
+++ b/store/test-store/tests/graph.rs
@@ -0,0 +1,3 @@
+pub mod graph {
+    pub mod entity_cache;
+}
diff --git a/store/test-store/tests/graph/entity_cache.rs b/store/test-store/tests/graph/entity_cache.rs
new file mode 100644
index 00000000000..a4fe7b0a3bc
--- /dev/null
+++ b/store/test-store/tests/graph/entity_cache.rs
@@ -0,0 +1,1366 @@
+use async_trait::async_trait;
+use graph::blockchain::BlockTime;
+use graph::blockchain::block_stream::FirehoseCursor;
+use graph::components::store::{
+    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},
+    prelude::{DeploymentHash, Entity, EntityCache, EntityModification, Value},
+};
+use graph::{entity, prelude::*};
+use hex_literal::hex;
+
+use graph::semver::Version;
+use lazy_static::lazy_static;
+use slog::Logger;
+use std::collections::{BTreeMap, BTreeSet};
+use std::marker::PhantomData;
+use std::sync::Arc;
+
+use graph_store_postgres::SubgraphStore as DieselSubgraphStore;
+use test_store::*;
+
+lazy_static! {
+    static ref SUBGRAPH_ID: DeploymentHash = DeploymentHash::new("entity_cache").unwrap();
+    static ref DEPLOYMENT: DeploymentLocator =
+        DeploymentLocator::new(DeploymentId::new(-12), SUBGRAPH_ID.clone());
+    static ref SCHEMA: InputSchema = InputSchema::parse_latest(
+        "
+            type Band @entity {
+                id: ID!
+                name: String!
+                founded: Int
+                label: String
+            }
+            ",
+        SUBGRAPH_ID.clone(),
+    )
+    .expect("Test schema invalid");
+}
+
+struct MockStore {
+    get_many_res: BTreeMap<EntityKey, Entity>,
+}
+
+impl MockStore {
+    fn new(get_many_res: BTreeMap<EntityKey, Entity>) -> Self {
+        Self { get_many_res }
+    }
+}
+
+#[async_trait]
+impl ReadStore for MockStore {
+    async fn get(&self, key: &EntityKey) -> Result<Option<Entity>, StoreError> {
+        Ok(self.get_many_res.get(key).cloned())
+    }
+
+    async fn get_many(
+        &self,
+        _keys: BTreeSet<EntityKey>,
+    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
+        Ok(self.get_many_res.clone())
+    }
+
+    async fn get_derived(
+        &self,
+        _key: &DerivedEntityQuery,
+    ) -> Result<BTreeMap<EntityKey, Entity>, StoreError> {
+        Ok(self.get_many_res.clone())
+    }
+
+    fn input_schema(&self) -> InputSchema {
+        SCHEMA.clone()
+    }
+}
+impl DeploymentCursorTracker for MockStore {
+    fn block_ptr(&self) -> Option<BlockPtr> {
+        unimplemented!()
+    }
+
+    fn firehose_cursor(&self) -> FirehoseCursor {
+        unimplemented!()
+    }
+
+    fn input_schema(&self) -> InputSchema {
+        todo!()
+    }
+}
+
+#[async_trait]
+impl WritableStore for MockStore {
+    async fn start_subgraph_deployment(&self, _: &Logger) -> Result<(), StoreError> {
+        unimplemented!()
+    }
+
+    async fn revert_block_operations(
+        &self,
+        _: BlockPtr,
+        _: FirehoseCursor,
+    ) -> Result<(), StoreError> {
+        unimplemented!()
+    }
+
+    async fn unfail_deterministic_error(
+        &self,
+        _: &BlockPtr,
+        _: &BlockPtr,
+    ) -> Result<UnfailOutcome, StoreError> {
+        unimplemented!()
+    }
+
+    async fn unfail_non_deterministic_error(
+        &self,
+        _: &BlockPtr,
+    ) -> Result<UnfailOutcome, StoreError> {
+        unimplemented!()
+    }
+
+    async fn fail_subgraph(&self, _: SubgraphError) -> Result<(), StoreError> {
+        unimplemented!()
+    }
+
+    async fn transact_block_operations(
+        &self,
+        _: BlockPtr,
+        _: BlockTime,
+        _: FirehoseCursor,
+        _: Vec<EntityModification>,
+        _: &StopwatchMetrics,
+        _: Vec<StoredDynamicDataSource>,
+        _: Vec<SubgraphError>,
+        _: Vec<StoredDynamicDataSource>,
+        _: bool,
+        _: bool,
+    ) -> Result<(), StoreError> {
+        unimplemented!()
+    }
+
+    fn is_deployment_synced(&self) -> bool {
+        unimplemented!()
+    }
+
+    async fn pause_subgraph(&self) -> Result<(), StoreError> {
+        unimplemented!()
+    }
+
+    async fn load_dynamic_data_sources(
+        &self,
+        _manifest_idx_and_name: Vec<(u32, String)>,
+    ) -> Result<Vec<StoredDynamicDataSource>, StoreError> {
+        unimplemented!()
+    }
+
+    async fn deployment_synced(&self, _block_ptr: BlockPtr) -> Result<(), StoreError> {
+        unimplemented!()
+    }
+
+    fn shard(&self) -> &str {
+        unimplemented!()
+    }
+
+    async fn health(&self) -> Result<SubgraphHealth, StoreError> {
+        unimplemented!()
+    }
+
+    async fn create_postponed_indexes(&self) -> Result<(), StoreError> {
+        unimplemented!()
+    }
+
+    async fn flush(&self) -> Result<(), StoreError> {
+        unimplemented!()
+    }
+
+    async fn causality_region_curr_val(&self) -> Result<Option<CausalityRegion>, StoreError> {
+        unimplemented!()
+    }
+
+    async fn restart(self: Arc<Self>) -> Result<Option<Arc<dyn WritableStore>>, StoreError> {
+        unimplemented!()
+    }
+}
+
+fn make_band_key(id: &str) -> EntityKey {
+    SCHEMA.entity_type("Band").unwrap().parse_key(id).unwrap()
+}
+
+fn sort_by_entity_key(mut mods: Vec<EntityModification>) -> Vec<EntityModification> {
+    mods.sort_by_key(|m| m.key().clone());
+    mods
+}
+
+#[graph::test]
+async fn empty_cache_modifications() {
+    let store = Arc::new(MockStore::new(BTreeMap::new()));
+    let cache = EntityCache::new(store, SeqGenerator::new(0));
+    let result = cache.as_modifications(0, &STOPWATCH).await;
+    assert_eq!(result.unwrap().modifications, vec![]);
+}
+
+#[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, SeqGenerator::new(0));
+
+    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(), None)
+        .await
+        .unwrap();
+
+    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(), None)
+        .await
+        .unwrap();
+
+    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![
+            EntityModification::insert(mogwai_key, mogwai_data, 0),
+            EntityModification::insert(sigurros_key, sigurros_data, 0)
+        ])
+    );
+}
+
+fn entity_version_map(entity_type: &str, entities: Vec<Entity>) -> BTreeMap<EntityKey, Entity> {
+    let mut map = BTreeMap::new();
+    for entity in entities {
+        let key = SCHEMA.entity_type(entity_type).unwrap().key(entity.id());
+        map.insert(key, entity);
+    }
+    map
+}
+
+#[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 = {
+        let entities = vec![
+            entity! { SCHEMA => id: "mogwai", name: "Mogwai" },
+            entity! { SCHEMA => id: "sigurros", name: "Sigur Ros" },
+        ];
+        MockStore::new(entity_version_map("Band", entities))
+    };
+
+    let store = Arc::new(store);
+    let mut cache = EntityCache::new(store, SeqGenerator::new(0));
+
+    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(), None)
+        .await
+        .unwrap();
+
+    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(), None)
+        .await
+        .unwrap();
+
+    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![
+            EntityModification::overwrite(mogwai_key, mogwai_data, 0),
+            EntityModification::overwrite(sigurros_key, sigurros_data, 0)
+        ])
+    );
+}
+
+#[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 = {
+        let entities =
+            vec![entity! { SCHEMA => id: "mogwai", name: "Mogwai", label: "Chemikal Underground" }];
+
+        MockStore::new(entity_version_map("Band", entities))
+    };
+
+    let store = Arc::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, 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, 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, &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, 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!
+        name: String!
+        email: String!
+        age: Int!
+        wallets: [Wallet!]! @derivedFrom(field: \"account\")
+    }
+
+    interface Purse {
+        id: ID!
+        balance: Int!
+    }
+
+    type Wallet implements Purse @entity {
+        id: ID!
+        balance: Int!
+        account: Account!
+    }
+";
+
+const ACCOUNT: &str = "Account";
+const WALLET: &str = "Wallet";
+const PURSE: &str = "Purse";
+
+lazy_static! {
+    static ref LOAD_RELATED_ID_STRING: String = String::from("loadrelatedsubgraph");
+    static ref LOAD_RELATED_ID: DeploymentHash =
+        DeploymentHash::new(LOAD_RELATED_ID_STRING.as_str()).unwrap();
+    static ref LOAD_RELATED_SUBGRAPH: InputSchema =
+        InputSchema::parse_latest(ACCOUNT_GQL, LOAD_RELATED_ID.clone())
+            .expect("Failed to parse user schema");
+    static ref TEST_BLOCK_1_PTR: BlockPtr = (
+        B256::from(hex!(
+            "8511fa04b64657581e3f00e14543c1d522d5d7e771b54aa3060b662ade47da13"
+        )),
+        1u64
+    )
+        .into();
+    static ref WALLET_TYPE: EntityType = LOAD_RELATED_SUBGRAPH.entity_type(WALLET).unwrap();
+    static ref ACCOUNT_TYPE: EntityType = LOAD_RELATED_SUBGRAPH.entity_type(ACCOUNT).unwrap();
+    static ref PURSE_TYPE: EntityType = LOAD_RELATED_SUBGRAPH.entity_type(PURSE).unwrap();
+}
+
+fn run_store_test<R, F>(test: F)
+where
+    F: FnOnce(
+            EntityCache,
+            Arc<DieselSubgraphStore>,
+            DeploymentLocator,
+            Arc<dyn WritableStore>,
+        ) -> R
+        + Send
+        + 'static,
+    R: std::future::Future<Output = ()> + Send + 'static,
+{
+    run_test_sequentially(|store| async move {
+        let subgraph_store = store.subgraph_store();
+        // Reset state before starting
+        remove_subgraphs().await;
+
+        // Seed database with test data
+        let deployment = insert_test_data(subgraph_store.clone()).await;
+        let writable = store
+            .subgraph_store()
+            .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
+            .await
+            .expect("we can get a writable store");
+
+        // we send the information to the database
+        writable.flush().await.unwrap();
+
+        let read_store = Arc::new(writable.clone());
+
+        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;
+        writable.flush().await.unwrap();
+    });
+}
+
+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, 3, 0),
+        features: Default::default(),
+        description: None,
+        repository: None,
+        schema: LOAD_RELATED_SUBGRAPH.clone(),
+        data_sources: vec![],
+        graft: None,
+        templates: vec![],
+        chain: PhantomData,
+        indexer_hints: None,
+    };
+
+    // Create SubgraphDeploymentEntity
+    let deployment = DeploymentCreate::new(String::new(), &manifest, None);
+    let name = SubgraphName::new("test/store").unwrap();
+    let node_id = NodeId::new("test").unwrap();
+    let deployment = store
+        .create_subgraph_deployment(
+            name,
+            &LOAD_RELATED_SUBGRAPH,
+            deployment,
+            node_id,
+            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, 1);
+    let id_one = WALLET_TYPE.parse_id("1").unwrap();
+    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, 2);
+    let id_two = WALLET_TYPE.parse_id("2").unwrap();
+    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, 3);
+    transact_entity_operations(
+        &store,
+        &deployment,
+        GENESIS_PTR.clone(),
+        vec![
+            test_entity_1,
+            test_entity_2,
+            test_entity_3,
+            wallet_entity_1,
+            wallet_entity_2,
+            wallet_entity_3,
+            wallet_entity_4,
+        ],
+    )
+    .await
+    .unwrap();
+    deployment
+}
+
+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, vid: vid};
+
+    EntityOperation::Set {
+        key: ACCOUNT_TYPE.parse_key(id).unwrap(),
+        data: test_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, vid: vid}
+}
+
+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,
+    }
+}
+
+#[test]
+fn check_for_account_with_multiple_wallets() {
+    run_store_test(|mut cache, _store, _deployment, _writable| async move {
+        let account_id = ACCOUNT_TYPE.parse_id("1").unwrap();
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: account_id.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        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);
+    });
+}
+
+#[test]
+fn check_for_account_with_single_wallet() {
+    run_store_test(|mut cache, _store, _deployment, _writable| async move {
+        let account_id = ACCOUNT_TYPE.parse_id("2").unwrap();
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: account_id.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        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);
+    });
+}
+
+#[test]
+fn check_for_account_with_no_wallet() {
+    run_store_test(|mut cache, _store, _deployment, _writable| async move {
+        let account_id = ACCOUNT_TYPE.parse_id("3").unwrap();
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: account_id,
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        let result = cache.load_related(&request).await.unwrap();
+        let expeted_vec = vec![];
+
+        assert_eq!(result, expeted_vec);
+    });
+}
+
+#[test]
+fn check_for_account_that_doesnt_exist() {
+    run_store_test(|mut cache, _store, _deployment, _writable| async move {
+        let account_id = ACCOUNT_TYPE.parse_id("4").unwrap();
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: account_id,
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        let result = cache.load_related(&request).await.unwrap();
+        let expeted_vec = vec![];
+
+        assert_eq!(result, expeted_vec);
+    });
+}
+
+#[test]
+fn check_for_non_existent_field() {
+    run_store_test(|mut cache, _store, _deployment, _writable| async move {
+        let account_id = ACCOUNT_TYPE.parse_id("1").unwrap();
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "friends".into(),
+            entity_id: account_id,
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        let result = cache.load_related(&request).await.unwrap_err();
+        let expected = format!(
+            "Entity {}[{}]: unknown field `{}`",
+            request.entity_type, request.entity_id, request.entity_field,
+        );
+
+        assert_eq!(format!("{}", result), expected);
+    });
+}
+
+#[test]
+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, 12);
+        let wallet_entity_6 = create_wallet_operation("6", &account_id, 200_i32, 13);
+
+        transact_entity_operations(
+            &store,
+            &deployment,
+            TEST_BLOCK_1_PTR.clone(),
+            vec![wallet_entity_5, wallet_entity_6],
+        )
+        .await
+        .unwrap();
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: account_id.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        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);
+    });
+}
+#[test]
+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, 5);
+        let wallet_entity_6 = create_wallet_operation("6", &account_id, 200_i32, 6);
+
+        transact_entity_operations(
+            &store,
+            &deployment,
+            TEST_BLOCK_1_PTR.clone(),
+            vec![wallet_entity_5, wallet_entity_6],
+        )
+        .await
+        .unwrap();
+        let account_id = ACCOUNT_TYPE.parse_id("1").unwrap();
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: account_id.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        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);
+    });
+}
+
+#[test]
+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, 11);
+
+        let new_data = match wallet_entity_update {
+            EntityOperation::Set { ref data, .. } => data.clone(),
+            _ => unreachable!(),
+        };
+        assert_ne!(writable.get(&entity_key).await.unwrap().unwrap(), new_data);
+        // insert a new wallet
+        transact_entity_operations(
+            &store,
+            &deployment,
+            TEST_BLOCK_1_PTR.clone(),
+            vec![wallet_entity_update],
+        )
+        .await
+        .unwrap();
+
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: account_id.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        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);
+    });
+}
+
+#[test]
+fn check_for_delete_async_related() {
+    run_store_test(|mut cache, store, deployment, _writable| async move {
+        let account_id = ACCOUNT_TYPE.parse_id("1").unwrap();
+        let del_key = WALLET_TYPE.parse_key("1").unwrap();
+        // delete wallet
+        transact_entity_operations(
+            &store,
+            &deployment,
+            TEST_BLOCK_1_PTR.clone(),
+            vec![EntityOperation::Remove { key: del_key }],
+        )
+        .await
+        .unwrap();
+
+        let request = LoadRelatedRequest {
+            entity_type: ACCOUNT_TYPE.clone(),
+            entity_field: "wallets".into(),
+            entity_id: account_id.clone(),
+            causality_region: CausalityRegion::ONCHAIN,
+        };
+        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_no_vid("1", &account1, 67);
+
+        // Create a new entity that is not in the store
+        let account5 = ACCOUNT_TYPE.parse_id("5").unwrap();
+        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(), 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).await.unwrap();
+        assert_eq!(Some(&wallet5), act5.as_ref().map(|e| e.as_ref()));
+        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).await.unwrap();
+        assert_eq!(None, act1);
+        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).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(), 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()));
+    })
+}
+
+/// Entities should never contain a `__typename` or `g$parent_id` field, if
+/// they do, that can cause PoI divergences, because entities will differ
+/// depending on whether they had to be loaded from the database or stuck
+/// around in the cache where they won't have these attributes
+#[test]
+fn no_internal_keys() {
+    run_store_test(|mut cache, _, _, writable| async move {
+        #[track_caller]
+        fn check(key: &EntityKey, entity: &Entity) {
+            // Validate checks that all attributes are actually declared in
+            // the schema
+            entity.validate(key).expect("the entity is valid");
+        }
+        let key = WALLET_TYPE.parse_key("1").unwrap();
+
+        let wallet = writable.get(&key).await.unwrap().unwrap();
+        check(&key, &wallet);
+
+        let wallet = cache.get(&key, GetScope::Store).await.unwrap().unwrap();
+        check(&key, &wallet);
+    });
+}
+
+#[test]
+fn no_interface_mods() {
+    run_store_test(|mut cache, _, _, _| async move {
+        let key = PURSE_TYPE.parse_key("1").unwrap();
+
+        // This should probably be an error, but changing that would not be
+        // backwards compatible
+        assert_eq!(None, cache.get(&key, GetScope::InBlock).await.unwrap());
+
+        assert!(matches!(
+            cache.get(&key, GetScope::Store).await,
+            Err(StoreError::UnknownTable(_))
+        ));
+
+        let entity = entity! { LOAD_RELATED_SUBGRAPH => id: "1", balance: 100 };
+
+        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
new file mode 100644
index 00000000000..86ed181da39
--- /dev/null
+++ b/store/test-store/tests/graphql.rs
@@ -0,0 +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
new file mode 100644
index 00000000000..bda2cb99b31
--- /dev/null
+++ b/store/test-store/tests/graphql/introspection.rs
@@ -0,0 +1,967 @@
+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::{ObjectOrInterface, object_value};
+use graph::data::query::Trace;
+use graph::prelude::{
+    DeploymentHash, Logger, Query, QueryExecutionError, QueryResult, o, q, r, s, serde_json, slog,
+    tokio,
+};
+use graph::schema::{ApiSchema, InputSchema};
+
+use graph_graphql::prelude::{
+    ExecutionContext, Query as PreparedQuery, QueryExecutionOptions, Resolver, a, execute_query,
+};
+use test_store::graphql_metrics;
+
+/// Mock resolver used in tests that don't need a resolver.
+#[derive(Clone)]
+pub struct MockResolver;
+
+#[async_trait]
+impl Resolver for MockResolver {
+    const CACHEABLE: bool = false;
+
+    async fn prefetch(
+        &self,
+        _: &ExecutionContext<Self>,
+        _: &a::SelectionSet,
+    ) -> Result<(Option<r::Value>, Trace), Vec<QueryExecutionError>> {
+        Ok((None, Trace::None))
+    }
+
+    async fn resolve_objects(
+        &self,
+        _: Option<r::Value>,
+        _field: &a::Field,
+        _field_definition: &s::Field,
+        _object_type: ObjectOrInterface<'_>,
+    ) -> Result<r::Value, QueryExecutionError> {
+        Ok(r::Value::Null)
+    }
+
+    async fn resolve_object(
+        &self,
+        _: Option<r::Value>,
+        _field: &a::Field,
+        _field_definition: &s::Field,
+        _object_type: ObjectOrInterface<'_>,
+    ) -> Result<r::Value, QueryExecutionError> {
+        Ok(r::Value::Null)
+    }
+
+    async fn query_permit(&self) -> QueryPermit {
+        let permit = Arc::new(tokio::sync::Semaphore::new(1))
+            .acquire_owned()
+            .await
+            .unwrap();
+        QueryPermit {
+            permit,
+            wait: Duration::from_secs(0),
+        }
+    }
+}
+
+fn api_schema(raw: &str, id: &str) -> Arc<ApiSchema> {
+    let id = DeploymentHash::new(id).unwrap();
+    let schema = InputSchema::parse_latest(raw, id)
+        .unwrap()
+        .api_schema()
+        .unwrap();
+    Arc::new(schema)
+}
+
+/// Creates a basic GraphQL schema that exercies scalars, directives,
+/// enums, interfaces, input objects, object types and field arguments.
+fn mock_schema() -> Arc<ApiSchema> {
+    api_schema(
+        "
+             directive @language(
+               language: String = \"English\"
+             ) on FIELD_DEFINITION
+
+             enum Role {
+               USER
+               ADMIN
+             }
+
+             interface Node {
+               id: ID!
+             }
+
+             type User implements Node @entity {
+               id: ID!
+               name: String! @language(language: \"English\")
+               role: Role!
+             }
+             ",
+        "mockschema",
+    )
+}
+
+/// Builds the expected result for GraphiQL's introspection query that we are
+/// using for testing.
+fn expected_mock_schema_introspection() -> r::Value {
+    const JSON: &str = include_str!("mock_introspection.json");
+    serde_json::from_str::<serde_json::Value>(JSON)
+        .unwrap()
+        .into()
+}
+
+/// Execute an introspection query.
+async fn introspection_query(schema: Arc<ApiSchema>, query: &str) -> QueryResult {
+    // Create the query
+    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: 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) => {
+                let (res, _) = execute_query(query, None, None, options).await;
+                Ok(Arc::try_unwrap(res).unwrap())
+            }
+            Err(e) => Err(e),
+        };
+    QueryResult::from(result)
+}
+
+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
+        | r::Value::Timestamp(_) => {
+            if a != b {
+                different(a, b)
+            } else {
+                None
+            }
+        }
+        r::Value::List(la) => match b {
+            r::Value::List(lb) => {
+                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);
+                }
+                if lb.len() > la.len() {
+                    path.push(la.len().to_string());
+                    return different(&r::Value::Null, &lb[la.len()]);
+                }
+                None
+            }
+            _ => different(a, b),
+        },
+        r::Value::String(sa) | r::Value::Enum(sa) => match b {
+            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 different(a, b);
+                }
+                for (ka, va) in oa.iter() {
+                    match ob.get(ka) {
+                        Some(vb) => {
+                            path.push(ka.to_string());
+                            let res = compare(va, vb, path);
+                            if res.is_some() {
+                                return res;
+                            }
+                            path.pop();
+                        }
+                        None => {
+                            return different(va, &r::Value::Null);
+                        }
+                    }
+                }
+                None
+            }
+            _ => different(a, b),
+        },
+    }
+}
+
+/// 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(),
+        "
+      query IntrospectionQuery {
+        __schema {
+          queryType { name }
+          mutationType { name }
+          subscriptionType { name}
+          types {
+            kind
+            name
+            description
+            fields(includeDeprecated: true) {
+              name
+              description
+              args {
+                name
+                description
+                type {
+                  kind
+                  name
+                  ofType {
+                    kind
+                    name
+                    ofType {
+                      kind
+                      name
+                      ofType {
+                        kind
+                        name
+                        ofType {
+                          kind
+                          name
+                          ofType {
+                            kind
+                            name
+                            ofType {
+                              kind
+                              name
+                              ofType {
+                                kind
+                                name
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+                defaultValue
+              }
+              type {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                  ofType {
+                    kind
+                    name
+                    ofType {
+                      kind
+                      name
+                      ofType {
+                        kind
+                        name
+                        ofType {
+                          kind
+                          name
+                          ofType {
+                            kind
+                            name
+                            ofType {
+                              kind
+                              name
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+              isDeprecated
+              deprecationReason
+            }
+            inputFields {
+              name
+              description
+              type {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                  ofType {
+                    kind
+                    name
+                    ofType {
+                      kind
+                      name
+                      ofType {
+                        kind
+                        name
+                        ofType {
+                          kind
+                          name
+                          ofType {
+                            kind
+                            name
+                            ofType {
+                              kind
+                              name
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+              defaultValue
+            }
+            interfaces {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                  ofType {
+                    kind
+                    name
+                    ofType {
+                      kind
+                      name
+                      ofType {
+                        kind
+                        name
+                        ofType {
+                          kind
+                          name
+                          ofType {
+                            kind
+                            name
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            enumValues(includeDeprecated: true) {
+              name
+              description
+              isDeprecated
+              deprecationReason
+            }
+            possibleTypes {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                  ofType {
+                    kind
+                    name
+                    ofType {
+                      kind
+                      name
+                      ofType {
+                        kind
+                        name
+                        ofType {
+                          kind
+                          name
+                          ofType {
+                            kind
+                            name
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+           }
+          }
+          directives {
+            name
+            description
+            locations
+            args {
+              name
+              description
+              type {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                  ofType {
+                    kind
+                    name
+                    ofType {
+                      kind
+                      name
+                      ofType {
+                        kind
+                        name
+                        ofType {
+                          kind
+                          name
+                          ofType {
+                            kind
+                            name
+                            ofType {
+                              kind
+                              name
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+              defaultValue
+            }
+          }
+        }
+      }
+    ",
+    )
+    .await;
+
+    let data = result
+        .to_result()
+        .expect("Introspection query returned no result")
+        .unwrap();
+    assert!(same_value(&data, &expected_mock_schema_introspection()));
+}
+
+#[graph::test]
+async fn satisfies_graphiql_introspection_query_with_fragments() {
+    let result = introspection_query(
+        mock_schema(),
+        "
+      query IntrospectionQuery {
+        __schema {
+          queryType { name }
+          mutationType { name }
+          subscriptionType { name }
+          types {
+            ...FullType
+          }
+          directives {
+            name
+            description
+            locations
+            args {
+              ...InputValue
+            }
+          }
+        }
+      }
+
+      fragment FullType on __Type {
+        kind
+        name
+        description
+        fields(includeDeprecated: true) {
+          name
+          description
+          args {
+            ...InputValue
+          }
+          type {
+            ...TypeRef
+          }
+          isDeprecated
+          deprecationReason
+        }
+        inputFields {
+          ...InputValue
+        }
+        interfaces {
+          ...TypeRef
+        }
+        enumValues(includeDeprecated: true) {
+          name
+          description
+          isDeprecated
+          deprecationReason
+        }
+        possibleTypes {
+          ...TypeRef
+        }
+      }
+
+      fragment InputValue on __InputValue {
+        name
+        description
+        type { ...TypeRef }
+        defaultValue
+      }
+
+      fragment TypeRef on __Type {
+        kind
+        name
+        ofType {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                  ofType {
+                    kind
+                    name
+                    ofType {
+                      kind
+                      name
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    ",
+    )
+    .await;
+
+    let data = result
+        .to_result()
+        .expect("Introspection query returned no result")
+        .unwrap();
+
+    // If the data needed for expected_mock_schema_introspection() ever
+    // needs to be regenerated, uncomment this line, and save the output in
+    // mock_introspection.json
+    //
+    // println!("{}", graph::prelude::serde_json::to_string(&data).unwrap());
+    assert!(same_value(&data, &expected_mock_schema_introspection()));
+}
+
+const COMPLEX_SCHEMA: &str = "
+enum RegEntryStatus {
+  regEntry_status_challengePeriod
+  regEntry_status_commitPeriod
+  regEntry_status_revealPeriod
+  regEntry_status_blacklisted
+  regEntry_status_whitelisted
+}
+
+interface RegEntry {
+  regEntry_address: ID
+  regEntry_version: Int
+  regEntry_status: RegEntryStatus
+  regEntry_creator: User
+  regEntry_deposit: Int
+  regEntry_createdOn: String
+  regEntry_challengePeriodEnd: String
+  challenge_challenger: User
+  challenge_createdOn: String
+  challenge_comment: String
+  challenge_votingToken: String
+  challenge_rewardPool: Int
+  challenge_commitPeriodEnd: String
+  challenge_revealPeriodEnd: String
+  challenge_votesFor: Int
+  challenge_votesAgainst: Int
+  challenge_votesTotal: Int
+  challenge_claimedRewardOn: String
+  challenge_vote(vote_voter: ID!): Vote
+}
+
+enum VoteOption {
+  voteOption_noVote
+  voteOption_voteFor
+  voteOption_voteAgainst
+}
+
+type Vote @entity {
+  id: ID!
+  vote_secretHash: String
+  vote_option: VoteOption
+  vote_amount: Int
+  vote_revealedOn: String
+  vote_claimedRewardOn: String
+  vote_reward: Int
+}
+
+type Meme implements RegEntry @entity {
+  id: ID!
+  regEntry_address: ID
+  regEntry_version: Int
+  regEntry_status: RegEntryStatus
+  regEntry_creator: User
+  regEntry_deposit: Int
+  regEntry_createdOn: String
+  regEntry_challengePeriodEnd: String
+  challenge_challenger: User
+  challenge_createdOn: String
+  challenge_comment: String
+  challenge_votingToken: String
+  challenge_rewardPool: Int
+  challenge_commitPeriodEnd: String
+  challenge_revealPeriodEnd: String
+  challenge_votesFor: Int
+  challenge_votesAgainst: Int
+  challenge_votesTotal: Int
+  challenge_claimedRewardOn: String
+  challenge_vote(vote_voter: ID!): Vote
+  # Balance of voting token of a voter. This is client-side only, server doesn't return this
+  challenge_availableVoteAmount(voter: ID!): Int
+  meme_title: String
+  meme_number: Int
+  meme_metaHash: String
+  meme_imageHash: String
+  meme_totalSupply: Int
+  meme_totalMinted: Int
+  meme_tokenIdStart: Int
+  meme_totalTradeVolume: Int
+  meme_totalTradeVolumeRank: Int
+  meme_ownedMemeTokens(owner: String): [MemeToken]
+  meme_tags: [Tag]
+}
+
+type Tag  @entity {
+  id: ID!
+  tag_id: ID
+  tag_name: String
+}
+
+type MemeToken @entity {
+  id: ID!
+  memeToken_tokenId: ID
+  memeToken_number: Int
+  memeToken_owner: User
+  memeToken_meme: Meme
+}
+
+enum MemeAuctionStatus {
+  memeAuction_status_active
+  memeAuction_status_canceled
+  memeAuction_status_done
+}
+
+type MemeAuction @entity {
+  id: ID!
+  memeAuction_address: ID
+  memeAuction_seller: User
+  memeAuction_buyer: User
+  memeAuction_startPrice: Int
+  memeAuction_endPrice: Int
+  memeAuction_duration: Int
+  memeAuction_startedOn: String
+  memeAuction_boughtOn: String
+  memeAuction_status: MemeAuctionStatus
+  memeAuction_memeToken: MemeToken
+}
+
+type ParamChange implements RegEntry @entity {
+  id: ID!
+  regEntry_address: ID
+  regEntry_version: Int
+  regEntry_status: RegEntryStatus
+  regEntry_creator: User
+  regEntry_deposit: Int
+  regEntry_createdOn: String
+  regEntry_challengePeriodEnd: String
+  challenge_challenger: User
+  challenge_createdOn: String
+  challenge_comment: String
+  challenge_votingToken: String
+  challenge_rewardPool: Int
+  challenge_commitPeriodEnd: String
+  challenge_revealPeriodEnd: String
+  challenge_votesFor: Int
+  challenge_votesAgainst: Int
+  challenge_votesTotal: Int
+  challenge_claimedRewardOn: String
+  challenge_vote(vote_voter: ID!): Vote
+  # Balance of voting token of a voter. This is client-side only, server doesn't return this
+  challenge_availableVoteAmount(voter: ID!): Int
+  paramChange_db: String
+  paramChange_key: String
+  paramChange_value: Int
+  paramChange_originalValue: Int
+  paramChange_appliedOn: String
+}
+
+type User @entity {
+  id: ID!
+  # Ethereum address of an user
+  user_address: ID
+  # Total number of memes submitted by user
+  user_totalCreatedMemes: Int
+  # Total number of memes submitted by user, which successfully got into TCR
+  user_totalCreatedMemesWhitelisted: Int
+  # Largest sale creator has done with his newly minted meme
+  user_creatorLargestSale: MemeAuction
+  # Position of a creator in leaderboard according to user_totalCreatedMemesWhitelisted
+  user_creatorRank: Int
+  # Amount of meme tokenIds owned by user
+  user_totalCollectedTokenIds: Int
+  # Amount of unique memes owned by user
+  user_totalCollectedMemes: Int
+  # Largest auction user sold, in terms of price
+  user_largestSale: MemeAuction
+  # Largest auction user bought into, in terms of price
+  user_largestBuy: MemeAuction
+  # Amount of challenges user created
+  user_totalCreatedChallenges: Int
+  # Amount of challenges user created and ended up in his favor
+  user_totalCreatedChallengesSuccess: Int
+  # Total amount of DANK token user received from challenger rewards
+  user_challengerTotalEarned: Int
+  # Total amount of DANK token user received from challenger rewards
+  user_challengerRank: Int
+  # Amount of different votes user participated in
+  user_totalParticipatedVotes: Int
+  # Amount of different votes user voted for winning option
+  user_totalParticipatedVotesSuccess: Int
+  # Amount of DANK token user received for voting for winning option
+  user_voterTotalEarned: Int
+  # Position of voter in leaderboard according to user_voterTotalEarned
+  user_voterRank: Int
+  # Sum of user_challengerTotalEarned and user_voterTotalEarned
+  user_curatorTotalEarned: Int
+  # Position of curator in leaderboard according to user_curatorTotalEarned
+  user_curatorRank: Int
+}
+
+type Parameter @entity {
+  id: ID!
+  param_db: ID
+  param_key: ID
+  param_value: Int
+}
+";
+
+#[graph::test]
+async fn successfully_runs_introspection_query_against_complex_schema() {
+    let schema = api_schema(COMPLEX_SCHEMA, "complexschema");
+
+    let result = introspection_query(
+        schema,
+        "
+        query IntrospectionQuery {
+          __schema {
+            queryType { name }
+            mutationType { name }
+            subscriptionType { name }
+            types {
+              ...FullType
+            }
+            directives {
+              name
+              description
+              locations
+              args {
+                ...InputValue
+              }
+            }
+          }
+        }
+
+        fragment FullType on __Type {
+          kind
+          name
+          description
+          fields(includeDeprecated: true) {
+            name
+            description
+            args {
+              ...InputValue
+            }
+            type {
+              ...TypeRef
+            }
+            isDeprecated
+            deprecationReason
+          }
+          inputFields {
+            ...InputValue
+          }
+          interfaces {
+            ...TypeRef
+          }
+          enumValues(includeDeprecated: true) {
+            name
+            description
+            isDeprecated
+            deprecationReason
+          }
+          possibleTypes {
+            ...TypeRef
+          }
+        }
+
+        fragment InputValue on __InputValue {
+          name
+          description
+          type { ...TypeRef }
+          defaultValue
+          isDeprecated
+          deprecationReason
+        }
+
+        fragment TypeRef on __Type {
+          kind
+          name
+          ofType {
+            kind
+            name
+            ofType {
+              kind
+              name
+              ofType {
+                kind
+                name
+                ofType {
+                  kind
+                  name
+                  ofType {
+                    kind
+                    name
+                    ofType {
+                      kind
+                      name
+                      ofType {
+                        kind
+                        name
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+    ",
+    )
+    .await;
+
+    assert!(!result.has_errors(), "{:#?}", result);
+}
+
+#[graph::test]
+async fn introspection_possible_types() {
+    let schema = api_schema(COMPLEX_SCHEMA, "complexschema");
+
+    // Test "possibleTypes" introspection in interfaces
+    let response = introspection_query(
+        schema,
+        "query {
+          __type(name: \"RegEntry\") {
+              name
+              possibleTypes {
+                name
+              }
+          }
+        }",
+    )
+    .await
+    .to_result()
+    .unwrap()
+    .unwrap();
+
+    assert_eq!(
+        response,
+        object_value(vec![(
+            "__type",
+            object_value(vec![
+                ("name", r::Value::String("RegEntry".to_string())),
+                (
+                    "possibleTypes",
+                    r::Value::List(vec![
+                        object_value(vec![("name", r::Value::String("Meme".to_owned()))]),
+                        object_value(vec![("name", r::Value::String("ParamChange".to_owned()))])
+                    ])
+                )
+            ])
+        )])
+    )
+}
diff --git a/store/test-store/tests/graphql/mock_introspection.json b/store/test-store/tests/graphql/mock_introspection.json
new file mode 100644
index 00000000000..802c423bf63
--- /dev/null
+++ b/store/test-store/tests/graphql/mock_introspection.json
@@ -0,0 +1,1948 @@
+{
+  "__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
+      },
+      {
+        "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
+      },
+      {
+        "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": "Int",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "number_gte",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "Int",
+              "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",
+        "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": "ID",
+                "ofType": null
+              }
+            },
+            "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": {
+                  "kind": "SCALAR",
+                  "name": "ID",
+                  "ofType": null
+                }
+              }
+            },
+            "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
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "and",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "INPUT_OBJECT",
+                "name": "Node_filter",
+                "ofType": null
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "or",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "INPUT_OBJECT",
+                "name": "Node_filter",
+                "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
+              },
+              {
+                "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
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "users",
+            "description": null,
+            "args": [
+              {
+                "name": "skip",
+                "description": null,
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "Int",
+                  "ofType": null
+                },
+                "defaultValue": "0"
+              },
+              {
+                "name": "first",
+                "description": null,
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "Int",
+                  "ofType": null
+                },
+                "defaultValue": "100"
+              },
+              {
+                "name": "orderBy",
+                "description": null,
+                "type": {
+                  "kind": "ENUM",
+                  "name": "User_orderBy",
+                  "ofType": null
+                },
+                "defaultValue": null
+              },
+              {
+                "name": "orderDirection",
+                "description": null,
+                "type": {
+                  "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",
+                  "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",
+              "name": null,
+              "ofType": {
+                "kind": "LIST",
+                "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",
+                  "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": {
+                  "kind": "SCALAR",
+                  "name": "Int",
+                  "ofType": null
+                },
+                "defaultValue": "100"
+              },
+              {
+                "name": "orderBy",
+                "description": null,
+                "type": {
+                  "kind": "ENUM",
+                  "name": "Node_orderBy",
+                  "ofType": null
+                },
+                "defaultValue": null
+              },
+              {
+                "name": "orderDirection",
+                "description": null,
+                "type": {
+                  "kind": "ENUM",
+                  "name": "OrderDirection",
+                  "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
+              },
+              {
+                "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
+            },
+            "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
+                },
+                "defaultValue": null
+              },
+              {
+                "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
+                },
+                "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
+                },
+                "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
+                },
+                "defaultValue": null
+              },
+              {
+                "name": "first",
+                "description": "Maximum number of logs to return. Default: 100, Maximum: 1000.",
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "Int",
+                  "ofType": null
+                },
+                "defaultValue": "100"
+              },
+              {
+                "name": "skip",
+                "description": "Number of logs to skip (for pagination). Default: 0, Maximum: 10000.",
+                "type": {
+                  "kind": "SCALAR",
+                  "name": "Int",
+                  "ofType": null
+                },
+                "defaultValue": "0"
+              },
+              {
+                "name": "orderDirection",
+                "description": "Sort direction for results. Default: desc (newest first).",
+                "type": {
+                  "kind": "ENUM",
+                  "name": "OrderDirection",
+                  "ofType": null
+                },
+                "defaultValue": "desc"
+              }
+            ],
+            "type": {
+              "kind": "NON_NULL",
+              "name": null,
+              "ofType": {
+                "kind": "LIST",
+                "name": null,
+                "ofType": {
+                  "kind": "NON_NULL",
+                  "name": null,
+                  "ofType": {
+                    "kind": "OBJECT",
+                    "name": "_Log_",
+                    "ofType": null
+                  }
+                }
+              }
+            },
+            "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
+          },
+          {
+            "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": {
+                  "kind": "SCALAR",
+                  "name": "ID",
+                  "ofType": null
+                }
+              }
+            },
+            "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": {
+                  "kind": "SCALAR",
+                  "name": "String",
+                  "ofType": null
+                }
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_in",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "NON_NULL",
+                "name": null,
+                "ofType": {
+                  "kind": "SCALAR",
+                  "name": "String",
+                  "ofType": null
+                }
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_contains",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_contains_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_contains",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_contains_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_starts_with",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_starts_with_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_starts_with",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_starts_with_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_ends_with",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_ends_with_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_ends_with",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "name_not_ends_with_nocase",
+            "description": null,
+            "type": {
+              "kind": "SCALAR",
+              "name": "String",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "role",
+            "description": null,
+            "type": {
+              "kind": "ENUM",
+              "name": "Role",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "role_not",
+            "description": null,
+            "type": {
+              "kind": "ENUM",
+              "name": "Role",
+              "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": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "NON_NULL",
+                "name": null,
+                "ofType": {
+                  "kind": "ENUM",
+                  "name": "Role",
+                  "ofType": null
+                }
+              }
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "_change_block",
+            "description": "Filter for the block changed event.",
+            "type": {
+              "kind": "INPUT_OBJECT",
+              "name": "BlockChangedFilter",
+              "ofType": null
+            },
+            "defaultValue": null
+          },
+          {
+            "name": "and",
+            "description": null,
+            "type": {
+              "kind": "LIST",
+              "name": null,
+              "ofType": {
+                "kind": "INPUT_OBJECT",
+                "name": "User_filter",
+                "ofType": null
+              }
+            },
+            "defaultValue": 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": {
+              "kind": "SCALAR",
+              "name": "Bytes",
+              "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": {
+              "kind": "SCALAR",
+              "name": "Int",
+              "ofType": null
+            },
+            "isDeprecated": false,
+            "deprecationReason": null
+          },
+          {
+            "name": "parentHash",
+            "description": "The hash of the parent block",
+            "args": [],
+            "type": {
+              "kind": "SCALAR",
+              "name": "Bytes",
+              "ofType": null
+            },
+            "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
+              }
+            },
+            "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
+              }
+            },
+            "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
+              }
+            },
+            "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": "Int",
+                "ofType": null
+              }
+            },
+            "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": "Int",
+                "ofType": null
+              }
+            },
+            "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
+              }
+            },
+            "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
+              }
+            },
+            "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
+              }
+            },
+            "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": "LogLevel",
+                "ofType": null
+              }
+            },
+            "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
+              }
+            },
+            "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": "OBJECT",
+                    "name": "_LogArgument_",
+                    "ofType": null
+                  }
+                }
+              }
+            },
+            "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
+              }
+            },
+            "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
+            },
+            "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
+          }
+        ]
+      }
+    ]
+  }
+}
diff --git a/graphql/tests/query.rs b/store/test-store/tests/graphql/query.rs
similarity index 66%
rename from graphql/tests/query.rs
rename to store/test-store/tests/graphql/query.rs
index 967a494992b..d2410d62b2e 100644
--- a/graphql/tests/query.rs
+++ b/store/test-store/tests/graphql/query.rs
@@ -1,19 +1,22 @@
-#[macro_use]
-extern crate pretty_assertions;
-
-use graph::components::store::EntityKey;
+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;
-use graphql_parser::Pos;
+use graph::prelude::Value;
+use graph::schema::InputSchema;
 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,
@@ -24,39 +27,116 @@ 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, Schema, 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
+/// access through `IdType` to check results in the tests
 const NETWORK_NAME: &str = "fake_network";
 const SONGS_STRING: [&str; 5] = ["s0", "s1", "s2", "s3", "s4"];
 const SONGS_BYTES: [&str; 5] = ["0xf0", "0xf1", "0xf2", "0xf3", "0xf4"];
+const SONGS_INT: [&str; 5] = ["42", "43", "44", "45", "46"];
 const MEDIA_STRING: [&str; 7] = ["md0", "md1", "md2", "md3", "md4", "md5", "md6"];
 const MEDIA_BYTES: [&str; 7] = ["0xf0", "0xf1", "0xf2", "0xf3", "0xf4", "0xf5", "0xf6"];
+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,
+/// which is fine in tests, in order to keep test notation concise
+#[derive(Debug)]
+struct IdVal(Value);
+
+impl IdVal {
+    fn as_gql(&self, id_type: IdType) -> String {
+        match (id_type, self) {
+            (IdType::String, IdVal(Value::String(s))) => format!("\"{}\"", s),
+            (IdType::Bytes, IdVal(Value::Bytes(b))) => format!("\"{}\"", b),
+            (IdType::Int8, IdVal(Value::Int8(i))) => format!("{}", i),
+            _ => panic!(
+                "Invalid combination of id type {} and value {self:?}",
+                id_type.as_str()
+            ),
+        }
+    }
+}
+
+impl From<&IdVal> for Value {
+    fn from(id: &IdVal) -> Self {
+        id.0.clone()
+    }
+}
+
+impl graph::data::graphql::IntoValue for &IdVal {
+    fn into_value(self) -> r::Value {
+        self.0.clone().into()
+    }
+}
+
+impl std::fmt::Display for IdVal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
 
 #[derive(Clone, Copy, Debug)]
-enum IdType {
+pub enum IdType {
     String,
-    #[allow(dead_code)]
     Bytes,
+    Int8,
 }
 
 impl IdType {
-    fn songs(&self) -> &[&str] {
+    fn parse(&self, s: &str) -> IdVal {
+        let value = match self {
+            IdType::String => Value::String(s.to_string()),
+            IdType::Bytes => Value::Bytes(s.parse().unwrap()),
+            IdType::Int8 => Value::Int8(s.parse().unwrap()),
+        };
+        IdVal(value)
+    }
+
+    fn songs(&self) -> &[&IdVal] {
+        lazy_static! {
+            static ref SONGS_STRING_VAL: Vec<IdVal> = SONGS_STRING
+                .iter()
+                .map(|s| IdType::String.parse(s))
+                .collect::<Vec<_>>();
+            static ref SONGS_BYTES_VAL: Vec<IdVal> = SONGS_BYTES
+                .iter()
+                .map(|s| IdType::Bytes.parse(s))
+                .collect::<Vec<_>>();
+            static ref SONGS_INT_VAL: Vec<IdVal> = SONGS_INT
+                .iter()
+                .map(|s| IdType::Int8.parse(s))
+                .collect::<Vec<_>>();
+            static ref SONGS_STRING_REF: Vec<&'static IdVal> =
+                SONGS_STRING_VAL.iter().collect::<Vec<_>>();
+            static ref SONGS_BYTES_REF: Vec<&'static IdVal> =
+                SONGS_BYTES_VAL.iter().collect::<Vec<_>>();
+            static ref SONGS_INT_REF: Vec<&'static IdVal> =
+                SONGS_INT_VAL.iter().collect::<Vec<_>>();
+        }
         match self {
-            IdType::String => SONGS_STRING.as_slice(),
-            IdType::Bytes => SONGS_BYTES.as_slice(),
+            IdType::String => SONGS_STRING_REF.as_slice(),
+            IdType::Bytes => SONGS_BYTES_REF.as_slice(),
+            IdType::Int8 => SONGS_INT_REF.as_slice(),
         }
     }
 
@@ -64,6 +144,7 @@ impl IdType {
         match self {
             IdType::String => MEDIA_STRING.as_slice(),
             IdType::Bytes => MEDIA_BYTES.as_slice(),
+            IdType::Int8 => MEDIA_INT.as_slice(),
         }
     }
 
@@ -71,13 +152,15 @@ impl IdType {
         match self {
             IdType::String => "String",
             IdType::Bytes => "Bytes",
+            IdType::Int8 => "Int8",
         }
     }
 
-    fn deployment_id(&self) -> &str {
+    pub fn deployment_id(&self) -> &str {
         match self {
             IdType::String => "graphqlTestsQuery",
             IdType::Bytes => "graphqlTestsQueryBytes",
+            IdType::Int8 => "graphqlTestsQueryInt8",
         }
     }
 }
@@ -92,23 +175,23 @@ 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
-    fn global_init() {
+    async fn global_init() {
         lazy_static! {
             static ref STORE_CLEAN: AtomicBool = AtomicBool::new(false);
         }
         if !STORE_CLEAN.load(Ordering::SeqCst) {
-            let chain = vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_TWO];
-            block_store::set_chain(chain, NETWORK_NAME);
-            test_store::remove_subgraphs();
+            let chain = CHAIN.iter().collect();
+            block_store::set_chain(chain, NETWORK_NAME).await;
+            test_store::remove_subgraphs().await;
             STORE_CLEAN.store(true, Ordering::SeqCst);
         }
     }
@@ -122,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,
@@ -131,33 +214,52 @@ async fn setup(
             graft: None,
             templates: vec![],
             chain: PhantomData,
+            indexer_hints: None,
         };
 
         insert_test_entities(store.subgraph_store().as_ref(), manifest, id_type).await
     }
 
-    global_init();
+    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,
     }
 }
 
-fn test_schema(id: DeploymentHash, id_type: IdType) -> Schema {
+fn test_schema(id: DeploymentHash, id_type: IdType) -> InputSchema {
     const SCHEMA: &str = "
+
+    type _Schema_
+        @fulltext(
+            name: \"bandReviewSearch\"
+            language: en
+            algorithm: proximityRank
+            include: [
+                {
+                    entity: \"BandReview\"
+                    fields: [
+                        { name: \"body\" }
+                    ]
+                }
+            ]
+        )
+
     type Musician @entity {
         id: ID!
         name: String!
         mainBand: Band
         bands: [Band!]!
         writtenSongs: [Song!]! @derivedFrom(field: \"writtenBy\")
+        favoriteCount: Int8!
+        birthDate: Timestamp!
     }
 
     type Band @entity {
@@ -178,6 +280,7 @@ fn test_schema(id: DeploymentHash, id_type: IdType) -> Schema {
         reviews: [SongReview!]! @derivedFrom(field: \"song\")
         media: [Media!]!
         release: Release! @derivedFrom(field: \"songs\")
+        stats: [SongStat!]! @derivedFrom(field: \"id\")
     }
 
     type SongStat @entity {
@@ -186,7 +289,7 @@ fn test_schema(id: DeploymentHash, id_type: IdType) -> Schema {
         played: Int!
     }
 
-    type Publisher {
+    type Publisher @entity {
         id: Bytes!
     }
 
@@ -254,6 +357,9 @@ fn test_schema(id: DeploymentHash, id_type: IdType) -> Schema {
     interface Author {
         id: ID!
         name: String!
+        reviews: [Review!]!
+        bandReviews: [BandReview!]!
+        songReviews: [SongReview!]!
     }
 
     type User implements Author @entity {
@@ -272,10 +378,34 @@ fn test_schema(id: DeploymentHash, id_type: IdType) -> Schema {
         id: ID!
         name: String!
         reviews: [Review!]! @derivedFrom(field: \"author\")
+        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\")
     }
     ";
 
-    Schema::parse(&SCHEMA.replace("@ID@", id_type.as_str()), id).expect("Test schema invalid")
+    InputSchema::parse_latest(&SCHEMA.replace("@ID@", id_type.as_str()), id)
+        .expect("Test schema invalid")
 }
 
 async fn insert_test_entities(
@@ -283,6 +413,35 @@ async fn insert_test_entities(
     manifest: SubgraphManifest<graph_chain_ethereum::Chain>,
     id_type: IdType,
 ) -> DeploymentLocator {
+    fn insert_ops(
+        schema: &InputSchema,
+        entities: Vec<(&str, Vec<Entity>)>,
+    ) -> Vec<EntityOperation> {
+        entities
+            .into_iter()
+            .flat_map(|(typename, entities)| {
+                let entity_type = schema.entity_type(typename).unwrap();
+                entities.into_iter().map(move |mut data| {
+                    data.set_vid_if_empty();
+                    EntityOperation::Set {
+                        key: entity_type.key(data.id()),
+                        data,
+                    }
+                })
+            })
+            .collect()
+    }
+
+    async fn insert_at(
+        insert_ops: Vec<EntityOperation>,
+        deployment: &DeploymentLocator,
+        block_ptr: BlockPtr,
+    ) {
+        test_store::transact_and_wait(&STORE.subgraph_store(), deployment, block_ptr, insert_ops)
+            .await
+            .unwrap();
+    }
+
     let deployment = DeploymentCreate::new(String::new(), &manifest, None);
     let name = SubgraphName::new(manifest.id.as_str()).unwrap();
     let node_id = NodeId::new("test").unwrap();
@@ -295,73 +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![
-        entity! { __typename: "Musician", id: "m1", name: "John", mainBand: "b1", bands: vec!["b1", "b2"] },
-        entity! { __typename: "Musician", id: "m2", name: "Lisa", mainBand: "b1", bands: vec!["b1"] },
-        entity! { __typename: "Publisher", id: "0xb1" },
-        entity! { __typename: "Band", id: "b1", name: "The Musicians", originalSongs: vec![s[1], s[2]] },
-        entity! { __typename: "Band", id: "b2", name: "The Amateurs",  originalSongs: vec![s[1], s[3], s[4]] },
-        entity! { __typename: "Song", id: s[1], sid: "s1", title: "Cheesy Tune",  publisher: "0xb1", writtenBy: "m1", media: vec![md[1], md[2]] },
-        entity! { __typename: "Song", id: s[2], sid: "s2", title: "Rock Tune",    publisher: "0xb1", writtenBy: "m2", media: vec![md[3], md[4]] },
-        entity! { __typename: "Song", id: s[3], sid: "s3", title: "Pop Tune",     publisher: "0xb1", writtenBy: "m1", media: vec![md[5]] },
-        entity! { __typename: "Song", id: s[4], sid: "s4", title: "Folk Tune",    publisher: "0xb1", writtenBy: "m3", media: vec![md[6]] },
-        entity! { __typename: "SongStat", id: s[1], played: 10 },
-        entity! { __typename: "SongStat", id: s[2], played: 15 },
-        entity! { __typename: "BandReview", id: "r1", body: "Bad musicians",        band: "b1", author: "u1" },
-        entity! { __typename: "BandReview", id: "r2", body: "Good amateurs",        band: "b2", author: "u2" },
-        entity! { __typename: "BandReview", id: "r5", body: "Very Bad musicians",   band: "b1", author: "u3" },
-        entity! { __typename: "SongReview", id: "r3", body: "Bad",                  song: s[2], author: "u1" },
-        entity! { __typename: "SongReview", id: "r4", body: "Good",                 song: s[3], author: "u2" },
-        entity! { __typename: "SongReview", id: "r6", body: "Very Bad",             song: s[2], author: "u3" },
-        entity! { __typename: "User",           id: "u1", name: "Baden",        latestSongReview: "r3", latestBandReview: "r1", latestReview: "r1" },
-        entity! { __typename: "User",           id: "u2", name: "Goodwill",     latestSongReview: "r4", latestBandReview: "r2", latestReview: "r2" },
-        entity! { __typename: "AnonymousUser",  id: "u3", name: "Anonymous 3",  latestSongReview: "r6", latestBandReview: "r5", latestReview: "r5" },
-        entity! { __typename: "Photo", id: md[1],   title: "Cheesy Tune Single Cover",  author: "u1" },
-        entity! { __typename: "Video", id: md[2],   title: "Cheesy Tune Music Video",   author: "u2" },
-        entity! { __typename: "Photo", id: md[3],   title: "Rock Tune Single Cover",    author: "u1" },
-        entity! { __typename: "Video", id: md[4],   title: "Rock Tune Music Video",     author: "u2" },
-        entity! { __typename: "Photo", id: md[5],   title: "Pop Tune Single Cover",     author: "u1" },
-        entity! { __typename: "Video", id: md[6],   title: "Folk Tune Music Video",     author: "u2" },
-        entity! { __typename: "Album", id: "rl1",   title: "Pop and Folk",    songs: vec![s[3], s[4]] },
-        entity! { __typename: "Single", id: "rl2",  title: "Rock",           songs: vec![s[2]] },
-        entity! { __typename: "Single", id: "rl3",  title: "Cheesy",         songs: vec![s[1]] },
-    ];
-
-    let entities1 = vec![
-        entity! { __typename: "Musician", id: "m3", name: "Tom", mainBand: "b2", bands: vec!["b1", "b2"] },
-        entity! { __typename: "Musician", id: "m4", name: "Valerie", bands: Vec::<String>::new() },
+        (
+            "Musician",
+            vec![
+                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, vid: 0i64 }]),
+        (
+            "Band",
+            vec![
+                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]], 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", vid: 0i64 },
+            ],
+        ),
+        (
+            "SongStat",
+            vec![
+                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", 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", 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", 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", vid: 0i64 },
+            ],
+        ),
+        (
+            "Photo",
+            vec![
+                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", 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]], vid: 0i64 },
+            ],
+        ),
+        (
+            "Single",
+            vec![
+                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 },
+            ],
+        ),
     ];
 
-    async fn insert_at(entities: Vec<Entity>, deployment: &DeploymentLocator, block_ptr: BlockPtr) {
-        let insert_ops = entities.into_iter().map(|data| EntityOperation::Set {
-            key: EntityKey::data(
-                data.get("__typename").unwrap().clone().as_string().unwrap(),
-                data.get("id").unwrap().clone().as_string().unwrap(),
-            ),
-            data,
-        });
-
-        test_store::transact_and_wait(
-            &STORE.subgraph_store(),
-            deployment,
-            block_ptr,
-            insert_ops.collect::<Vec<_>>(),
-        )
-        .await
-        .unwrap();
-    }
-
-    insert_at(entities0, &deployment, GENESIS_PTR.clone()).await;
-    insert_at(entities1, &deployment, BLOCK_ONE.clone()).await;
+    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, 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, 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
@@ -375,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);
@@ -465,7 +703,7 @@ where
         max_complexity,
     } = args.into();
     run_test_sequentially(move |store| async move {
-        for id_type in [IdType::String, IdType::Bytes] {
+        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;
@@ -473,22 +711,22 @@ where
             let mut query = query.clone();
             for (i, id) in id_type.songs().iter().enumerate() {
                 let pat = format!("@S{i}@");
-                let repl = format!("\"{id}\"");
+                let repl = id.as_gql(id_type);
                 query = query.replace(&pat, &repl);
             }
 
             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);
@@ -505,46 +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(),
-    };
-    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 = "
@@ -554,6 +752,8 @@ fn can_query_one_to_one_relationship() {
             mainBand {
                 name
             }
+            favoriteCount
+            birthDate
         }
         songStats(first: 100, orderBy: id) {
             id
@@ -570,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" } },
-                object! { name: "Lisa", mainBand: object! { name: "The Musicians" } },
-                object! { name: "Tom",  mainBand: object! { name: "The Amateurs"} },
-                object! { name: "Valerie", mainBand: r::Value::Null }
+                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! {
@@ -589,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);
     })
 }
@@ -632,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()
+                },
             ]
         };
 
@@ -670,18 +913,68 @@ 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 ] }
+            ]
+        };
+
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
+    })
+}
+
+#[test]
+fn can_query_with_fulltext_search() {
+    const QUERY: &str = "
+    query {
+        bandReviewSearch(text: \"musicians\") {
+            id
+            body
+            author {
+                name
+            }
+        }
+    }";
+
+    run_query(QUERY, |result, _| {
+        let exp = object! {
+            bandReviewSearch: vec![
+                object! { id: "r1", body: "Bad musicians", author: object! { name: "Baden" } },
+                object! { id: "r5", body: "Very Bad musicians", author: object! { name: "Anonymous 3" } },
             ]
         };
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
+    })
+}
 
+#[test]
+fn can_query_with_fulltext_search_filter() {
+    const QUERY: &str = "
+    query {
+        bandReviewSearch(text: \"musicians\", where: { author_: { name: \"Anonymous 3\" } }) {
+            id
+            body
+            author {
+                name
+            }
+        }
+    }";
+
+    run_query(QUERY, |result, _| {
+        let exp = object! {
+            bandReviewSearch: vec![
+                object! { id: "r5", body: "Very Bad musicians", author: object! { name: "Anonymous 3" } },
+            ]
+        };
         let data = extract_data!(result).unwrap();
         assert_eq!(data, exp);
     })
@@ -711,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 },
@@ -913,7 +1208,7 @@ fn can_query_with_sorting_by_child_interface() {
 }
 
 #[test]
-fn can_not_query_interface_with_sorting_by_child_entity() {
+fn can_query_interface_with_sorting_by_child_entity() {
     const QUERY: &str = "
     query {
         desc: medias(first: 100, orderBy: author__name, orderDirection: desc) {
@@ -931,13 +1226,32 @@ fn can_not_query_interface_with_sorting_by_child_entity() {
     }";
 
     run_query(QUERY, |result, _| {
-        // Sorting an interface by child-level entity (derived) is not supported
-        assert!(result.has_errors());
+        let author1 = object! { name: "Baden" };
+        let author2 = object! { name: "Goodwill" };
+        let desc_medias = vec![
+            object! { title: "Folk Tune Music Video",       author: author2.clone() },
+            object! { title: "Rock Tune Music Video",       author: author2.clone() },
+            object! { title: "Cheesy Tune Music Video",     author: author2.clone() },
+            object! { title: "Pop Tune Single Cover",       author: author1.clone() },
+            object! { title: "Rock Tune Single Cover",      author: author1.clone() },
+            object! { title: "Cheesy Tune Single Cover",    author: author1.clone() },
+        ];
+        let mut asc_medias = desc_medias.clone();
+
+        asc_medias.reverse();
+
+        let exp = object! {
+            desc: desc_medias,
+            asc: asc_medias,
+        };
+
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
     });
 }
 
 #[test]
-fn can_not_query_interface_with_sorting_by_derived_child_entity() {
+fn can_query_interface_with_sorting_by_derived_child_entity() {
     const QUERY: &str = "
     query {
         desc: medias(first: 100, orderBy: song__title, orderDirection: desc) {
@@ -955,8 +1269,27 @@ fn can_not_query_interface_with_sorting_by_derived_child_entity() {
     }";
 
     run_query(QUERY, |result, _| {
-        // Sorting an interface by child-level entity is not supported
-        assert!(result.has_errors());
+        let exp = object! {
+            desc: vec![
+                object! { title: "Rock Tune Music Video", song : object! { title: "Rock Tune" } },
+                object! { title: "Rock Tune Single Cover", song : object! { title: "Rock Tune" } },
+                object! { title: "Pop Tune Single Cover", song : object! { title: "Pop Tune" } },
+                object! { title: "Folk Tune Music Video", song : object! { title: "Folk Tune" } },
+                object! { title: "Cheesy Tune Music Video", song : object! { title: "Cheesy Tune" } },
+                object! { title: "Cheesy Tune Single Cover", song : object! { title: "Cheesy Tune" } },
+            ],
+            asc: vec![
+                object! { title: "Cheesy Tune Single Cover", song : object! { title: "Cheesy Tune" } },
+                object! { title: "Cheesy Tune Music Video", song : object! { title: "Cheesy Tune" } },
+                object! { title: "Folk Tune Music Video", song : object! { title: "Folk Tune" } },
+                object! { title: "Pop Tune Single Cover", song : object! { title: "Pop Tune" } },
+                object! { title: "Rock Tune Single Cover", song : object! { title: "Rock Tune" } },
+                object! { title: "Rock Tune Music Video", song : object! { title: "Rock Tune" } },
+            ]
+        };
+
+        let data = extract_data!(result).unwrap();
+        assert_eq!(data, exp);
     });
 }
 
@@ -984,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 ] },
             ]
         };
 
@@ -1029,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"} }
             ]
         };
 
@@ -1340,8 +1675,8 @@ fn mixed_parent_child_id() {
     run_query(QUERY, |result, _| {
         let exp = object! {
             songs: vec![
-                object! { publisher: object! { id: "0xb1" } },
-                object! { publisher: object! { id: "0xb1" } }
+                object! { publisher: object! { id: &*PUB1 } },
+                object! { publisher: object! { id: &*PUB1 } }
             ]
         };
         let data = extract_data!(result).unwrap();
@@ -1380,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();
@@ -1396,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();
@@ -1422,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();
@@ -1431,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();
@@ -1494,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,
@@ -1623,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();
@@ -1644,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();
@@ -1687,7 +1972,7 @@ fn ambiguous_derived_from_result() {
             )) => {
                 assert_eq!(
                     pos,
-                    &Pos {
+                    &q::Pos {
                         line: 1,
                         column: 39
                     }
@@ -1721,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! {
@@ -1774,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 = "
@@ -1835,6 +2089,10 @@ fn can_use_nested_filter() {
                 object! {
                     name: "Valerie",
                     bands: Vec::<r::Value>::new(),
+                },
+                object! {
+                    name: "Paul",
+                    bands: vec![ object! { id: "b2" }]
                 }
             ]
         };
@@ -1857,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,
@@ -1898,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),
                 };
@@ -1934,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),
                 };
@@ -1963,6 +2227,7 @@ fn missing_variable() {
                 object! { id: "m2" },
                 object! { id: "m3" },
                 object! { id: "m4" },
+                object! { id: "m5" },
             ]
         };
 
@@ -1972,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.");
                 }
@@ -1993,6 +2258,7 @@ fn missing_variable() {
                 object! { id: "m2" },
                 object! { id: "m3" },
                 object! { id: "m4" },
+                object! { id: "m5" },
             ]
         };
 
@@ -2002,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.");
                 }
@@ -2072,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 };
@@ -2122,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() };
 
@@ -2130,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]
@@ -2165,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
@@ -2174,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),
@@ -2182,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;
@@ -2195,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 */
             }
@@ -2222,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_"
@@ -2272,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(
@@ -2302,7 +2584,7 @@ fn non_fatal_errors() {
             deterministic: true,
         };
 
-        transact_errors(&STORE, &deployment, BLOCK_TWO.block_ptr(), vec![err])
+        transact_errors(&STORE, &deployment, BLOCKS[3].clone(), vec![err], true)
             .await
             .unwrap();
 
@@ -2340,6 +2622,45 @@ fn non_fatal_errors() {
         });
         assert_eq!(expected, serde_json::to_value(&result).unwrap());
 
+        // Introspection queries are not affected.
+        let query =
+            "query { __schema { queryType { name } } __type(name: \"Musician\") { name }  }";
+        let result = execute_query(&deployment, query).await;
+        let expected = json!({
+            "data": {
+                "__schema": {
+                    "queryType": {
+                        "name": "Query"
+                    }
+                },
+                "__type": {
+                    "name": "Musician"
+                }
+            },
+            "errors": [
+                {
+                    "message": "indexing_error"
+                }
+            ]
+        });
+        assert_eq!(expected, serde_json::to_value(&result).unwrap());
+
+        let query = "query { __type(name: \"Musician\") { name } }";
+        let result = execute_query(&deployment, query).await;
+        let expected = json!({
+            "data": {
+                "__type": {
+                    "name": "Musician"
+                }
+            },
+            "errors": [
+                {
+                    "message": "indexing_error"
+                }
+            ]
+        });
+        assert_eq!(expected, serde_json::to_value(&result).unwrap());
+
         // With `allow`, the error remains but the data is included.
         let query = "query { musician(id: \"m1\", subgraphError: allow) { id } }";
         let result = execute_query(&deployment, query).await;
@@ -2358,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!({
@@ -2389,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(
@@ -2403,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])
-            .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 } }";
@@ -2423,6 +2750,25 @@ fn deterministic_error() {
             ]
         });
         assert_eq!(expected, serde_json::to_value(&result).unwrap());
+
+        // Introspection queries are not affected.
+        let query = "query { __schema { queryType { name } } }";
+        let result = execute_query(&deployment, query).await;
+        let expected = json!({
+            "data": {
+                "__schema": {
+                    "queryType": {
+                        "name": "Query"
+                    }
+                }
+            },
+            "errors": [
+                {
+                    "message": "indexing_error"
+                }
+            ]
+        });
+        assert_eq!(expected, serde_json::to_value(&result).unwrap());
     })
 }
 
@@ -2507,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();
@@ -2532,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();
@@ -2566,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 } }";
+
+    const QUERY2: &str = r#"
+    query {
+        m0: musicians(first: 100, block: { number: 0 }) { name }
+        m1: musicians(first: 100, block: { number: 1 }) { name }
+    }"#;
 
-        let result = execute_subgraph_query(
+    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"),
+        }
     })
 }
 
@@ -2616,3 +3024,162 @@ fn can_compare_id() {
         })
     }
 }
+
+#[test]
+fn empty_type_c() {
+    // Single `rl4` has no songs. Make sure our SQL query generation does
+    // not cause a syntax error
+    const QUERY: &str = "
+    query {
+        single(id: \"rl4\") {
+            songs { id }
+        }
+    }";
+
+    run_query(QUERY, |result, _| {
+        let exp = object! {
+            single: object! { songs: Vec::<r::Value>::new() }
+        };
+        let data = extract_data!(result).unwrap();
+        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.rs b/store/test-store/tests/postgres.rs
new file mode 100644
index 00000000000..1d5a16ba851
--- /dev/null
+++ b/store/test-store/tests/postgres.rs
@@ -0,0 +1,10 @@
+pub mod postgres {
+    pub mod aggregation;
+    pub mod chain_head;
+    pub mod graft;
+    pub mod relational;
+    pub mod relational_bytes;
+    pub mod store;
+    pub mod subgraph;
+    pub mod writable;
+}
diff --git a/store/test-store/tests/postgres/aggregation.rs b/store/test-store/tests/postgres/aggregation.rs
new file mode 100644
index 00000000000..f005a15b73d
--- /dev/null
+++ b/store/test-store/tests/postgres/aggregation.rs
@@ -0,0 +1,849 @@
+use std::collections::BTreeSet;
+use std::fmt::Write;
+use std::{future::Future, sync::Arc};
+
+use graph::{
+    blockchain::{BlockPtr, BlockTime, block_stream::FirehoseCursor},
+    components::{
+        metrics::stopwatch::StopwatchMetrics,
+        store::{
+            AggregationCurrent, AttributeNames, BlockNumber, ChildMultiplicity, DeploymentLocator,
+            EntityCache, EntityCollection, EntityFilter, EntityLink, EntityOperation, EntityQuery,
+            EntityWindow, ReadStore, SeqGenerator, StoreError, SubgraphStore as _, WindowAttribute,
+            WritableStore,
+        },
+    },
+    data::{
+        store::{
+            Entity, Id, IdList, Value,
+            scalar::{BigDecimal, Bytes, Timestamp},
+        },
+        subgraph::DeploymentHash,
+    },
+    entity,
+    prelude::lazy_static,
+    schema::InputSchema,
+};
+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 Token @entity {
+    id: Bytes!
+    name: String!
+  }
+
+  type Data @entity(timeseries: true) {
+    id: Int8!
+    timestamp: Timestamp!
+    token: Token!
+    price: BigDecimal!
+    amount: BigDecimal!
+  }
+
+  type Stats @aggregation(intervals: ["day", "hour"], source: "Data") {
+    id: Int8!
+    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")
+    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: Timestamp!
+    max: BigDecimal! @aggregate(fn: "max", arg: "price")
+  }
+  "#;
+
+fn minutes(n: u32) -> BlockTime {
+    BlockTime::since_epoch(n as i64 * 60, 0)
+}
+
+lazy_static! {
+    static ref TOKEN1: Bytes = "0xdeadbeef01".parse().unwrap();
+    static ref TOKEN2: Bytes = "0xdeadbeef02".parse().unwrap();
+    static ref TOKEN3: Bytes = "0xdeadbeef03".parse().unwrap();
+    static ref TIMES: Vec<BlockTime> = vec![minutes(30), minutes(40), minutes(65), minutes(121)];
+}
+
+const STATS_HOUR_FIELDS: &[&str] = &[
+    "id",
+    "timestamp",
+    "token",
+    "sum",
+    "sum_sq",
+    "max",
+    "first",
+    "last",
+    "value",
+    "totalValue",
+];
+
+pub async fn insert_entities(
+    store: &Arc<dyn WritableStore>,
+    deployment: &DeploymentLocator,
+    block_ptr_to: BlockPtr,
+    block_time: BlockTime,
+    typed_entities: Vec<(&str, Vec<Entity>)>,
+) -> Result<(), StoreError> {
+    let schema = ReadStore::input_schema(store);
+    let ops: Vec<EntityOperation> = typed_entities
+        .into_iter()
+        .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()),
+        SeqGenerator::new(block_ptr_to.number),
+    );
+    entity_cache.append(ops);
+    let mods = entity_cache
+        .as_modifications(block_ptr_to.number, &STOPWATCH)
+        .await
+        .expect("failed to convert to modifications")
+        .modifications;
+    let metrics_registry = METRICS_REGISTRY.clone();
+    let stopwatch_metrics = StopwatchMetrics::new(
+        LOGGER.clone(),
+        deployment.hash.clone(),
+        "transact",
+        metrics_registry.clone(),
+        store.shard().to_string(),
+    );
+    store
+        .transact_block_operations(
+            block_ptr_to,
+            block_time,
+            FirehoseCursor::None,
+            mods,
+            &stopwatch_metrics,
+            Vec::new(),
+            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);
+
+    // 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_entities(
+        &store,
+        &deployment,
+        BLOCKS[0].clone(),
+        TIMES[0],
+        vec![("Token", token_entities), ("Data", data_entities)],
+    )
+    .await
+    .unwrap();
+
+    let ts64 = TIMES[1];
+    let entities = vec![
+        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];
+    let entities = vec![
+        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];
+    let entities = vec![
+        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
+        .unwrap();
+
+    store.flush().await.unwrap();
+}
+
+fn stats_hour(schema: &InputSchema) -> Vec<Vec<Entity>> {
+    // Note that an aggregation that is marked with block N will only
+    // contain data up to block N-1 since we do the aggregation at the first
+    // 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: 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: 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
+    };
+
+    vec![vec![], vec![], block2, block3]
+}
+
+struct TestEnv {
+    store: Arc<DieselStore>,
+    writable: Arc<dyn WritableStore>,
+    deployment: DeploymentLocator,
+}
+
+impl TestEnv {
+    async fn all_entities(&self, entity_type: &str, block: BlockNumber) -> Vec<Entity> {
+        let entity_type = self
+            .writable
+            .input_schema()
+            .entity_type(entity_type)
+            .expect("we got an existing entity type");
+        let query = EntityQuery::new(
+            self.deployment.hash.clone(),
+            block,
+            EntityCollection::All(vec![(entity_type, AttributeNames::All)]),
+        );
+        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)
+where
+    F: FnOnce(TestEnv) -> R + Send + 'static,
+    R: Future<Output = ()> + Send + 'static,
+{
+    run_test_sequentially(|store| async move {
+        // Reset state before starting
+        remove_subgraphs().await;
+
+        // Seed database with test data
+        let hash = DeploymentHash::new("rollupSubgraph").unwrap();
+        let loc = create_test_subgraph(&hash, SCHEMA).await;
+        let writable = store
+            .subgraph_store()
+            .writable(LOGGER.clone(), loc.id, Arc::new(Vec::new()))
+            .await
+            .expect("we can get a writable store");
+        insert_test_data(writable.clone(), loc.clone()).await;
+
+        // Run test and wait for the background writer to finish its work so
+        // it won't conflict with the next test
+        let env = TestEnv {
+            store: store.clone(),
+            writable: writable.clone(),
+            deployment: loc.clone(),
+        };
+        test(env).await;
+        writable.flush().await.unwrap();
+    });
+}
+
+fn entity_diff(left: &[Entity], right: &[Entity]) -> Result<String, std::fmt::Error> {
+    let mut diff = String::new();
+    for (i, (l, r)) in left.iter().zip(right.iter()).enumerate() {
+        if l != r {
+            writeln!(
+                diff,
+                "entities #{}(left: {}, right: {}) differ:",
+                i,
+                l.id(),
+                r.id()
+            )?;
+            for (k, v) in l.clone().sorted() {
+                match r.get(&k) {
+                    None => writeln!(diff, "  {}: left: {} right: missing", k, v)?,
+                    Some(v2) if &v != v2 => writeln!(diff, "  {}: left: {} right: {}", k, v, v2)?,
+                    _ => (),
+                }
+            }
+            for (k, v) in r.clone().sorted() {
+                if !l.contains_key(&k) {
+                    writeln!(diff, "  {}: left: missing right: {}", k, v)?;
+                }
+            }
+        }
+    }
+    Ok(diff)
+}
+
+#[test]
+fn simple() {
+    run_test(|env| async move {
+        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).await;
+            let diff = entity_diff(&exp[i], &act).unwrap();
+            if !diff.is_empty() {
+                panic!("entities for BLOCKS[{}] differ:\n{}", i, diff);
+            }
+            assert_eq!(exp[i], act, "entities for BLOCKS[{}] are the same", i);
+        }
+    })
+}
+
+/// 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
new file mode 100644
index 00000000000..d72641b29b6
--- /dev/null
+++ b/store/test-store/tests/postgres/chain_head.rs
@@ -0,0 +1,662 @@
+//! 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::futures03::executor;
+use graph::prelude::alloy::primitives::{Address, B256};
+use std::future::Future;
+use std::sync::Arc;
+
+use graph::cheap_clone::CheapClone;
+use graph::prelude::alloy;
+use graph::prelude::{BlockNumber, QueryStoreManager, QueryTarget};
+use graph::prelude::{anyhow::Error, anyhow::anyhow};
+use graph::{components::store::BlockStore as _, prelude::DeploymentHash};
+use graph::{
+    components::store::ChainHeadStore as _, components::store::ChainStore as _,
+    prelude::EthereumCallCache as _,
+};
+use graph_store_postgres::Store as DieselStore;
+use graph_store_postgres::{ChainStore as DieselChainStore, layout_for_tests::FAKE_NETWORK_SHARED};
+
+use test_store::block_store::{
+    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::*;
+
+// The ancestor count we use for chain head updates. We keep this very small
+// to make setting up the tests easier
+const ANCESTOR_COUNT: BlockNumber = 3;
+
+/// Test harness for running database integration tests.
+fn run_test<F>(chain: FakeBlockList, test: F)
+where
+    F: Fn(Arc<DieselChainStore>, Arc<DieselStore>) -> Result<(), Error> + Send + 'static,
+{
+    run_test_sequentially(|store| async move {
+        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)
+                .await
+                .expect("chain store");
+
+            // Run test
+            test(chain_store.cheap_clone(), store.cheap_clone()).unwrap_or_else(|err| {
+                panic!(
+                    "test finishes successfully on network {} with error {}",
+                    name, err
+                )
+            });
+        }
+    });
+}
+
+fn run_test_async<R, F>(chain: FakeBlockList, test: F)
+where
+    F: Fn(Arc<DieselChainStore>, Arc<DieselStore>, Vec<(BlockPtr, BlockHash)>) -> R
+        + Send
+        + Sync
+        + 'static,
+    R: Future<Output = ()> + Send + 'static,
+{
+    run_test_sequentially(|store| async move {
+        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)
+                .await
+                .expect("chain store");
+
+            // Run test
+            test(chain_store.cheap_clone(), store.clone(), cached).await;
+        }
+    });
+}
+
+/// Check that `attempt_chain_head_update` works as expected on the given
+/// chain. After writing the blocks in `chain` to the store, call
+/// `attempt_chain_head_update` and check its result. Check that the new head
+/// is the one indicated in `head_exp`. If `missing` is not `None`, check that
+/// `attempt_chain_head_update` reports that block as missing
+fn check_chain_head_update_cache(
+    chain: FakeBlockList,
+    head_exp: Option<&'static FakeBlock>,
+    missing: Option<&'static str>,
+    cached_exp: usize,
+) {
+    let cached_exp = ENV_VARS.store.recent_blocks_cache_capacity.min(cached_exp);
+
+    run_test_async(chain, move |store, _, cached| async move {
+        let missing_act: Vec<_> = store
+            .clone()
+            .attempt_chain_head_update(ANCESTOR_COUNT)
+            .await
+            .expect("attempt_chain_head_update failed")
+            .iter()
+            .map(|h| format!("{:x}", h))
+            .collect();
+        let missing_exp: Vec<_> = missing.into_iter().collect();
+        assert_eq!(missing_exp, missing_act);
+
+        let head_hash_exp = head_exp.map(|block| block.hash.clone());
+        let head_hash_act = store
+            .chain_head_ptr()
+            .await
+            .expect("chain_head_ptr failed")
+            .map(|ebp| ebp.hash_hex());
+        assert_eq!(head_hash_exp, head_hash_act);
+
+        assert_eq!(cached_exp, cached.len());
+    })
+}
+
+fn check_chain_head_update(
+    chain: FakeBlockList,
+    head_exp: Option<&'static FakeBlock>,
+    missing: Option<&'static str>,
+) {
+    let cached_exp = chain
+        .iter()
+        .filter(|block| block.number != 0)
+        .fold((0, None), |(len, parent_hash), block| {
+            match (len, parent_hash) {
+                (0, None) => (1, Some(&block.hash)),
+                (0, Some(_)) | (_, None) => unreachable!(),
+                (len, Some(parent_hash)) => {
+                    if &block.parent_hash == parent_hash {
+                        (len + 1, Some(&block.hash))
+                    } else {
+                        (1, Some(&block.hash))
+                    }
+                }
+            }
+        })
+        .0;
+
+    check_chain_head_update_cache(chain, head_exp, missing, cached_exp);
+}
+
+#[test]
+fn genesis_only() {
+    check_chain_head_update(vec![&*GENESIS_BLOCK], Some(&GENESIS_BLOCK), None);
+}
+
+#[test]
+fn genesis_plus_one() {
+    check_chain_head_update(vec![&*GENESIS_BLOCK, &*BLOCK_ONE], Some(&BLOCK_ONE), None);
+}
+
+#[test]
+fn genesis_plus_two() {
+    check_chain_head_update(
+        vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_TWO],
+        Some(&*BLOCK_TWO),
+        None,
+    );
+}
+
+#[test]
+fn genesis_plus_one_with_sibling() {
+    // Two valid blocks at the same height should give an error, but
+    // we currently get one of them at random
+    let chain = vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_ONE_SIBLING];
+    check_chain_head_update_cache(chain, Some(&*BLOCK_ONE), None, 1);
+}
+
+#[test]
+fn short_chain_missing_parent() {
+    let chain = vec![&*BLOCK_ONE_NO_PARENT];
+    check_chain_head_update(chain, None, Some(NO_PARENT));
+}
+
+#[test]
+fn long_chain() {
+    let chain = vec![
+        &*BLOCK_ONE,
+        &*BLOCK_TWO,
+        &*BLOCK_THREE,
+        &*BLOCK_FOUR,
+        &*BLOCK_FIVE,
+    ];
+    check_chain_head_update_cache(chain, Some(&*BLOCK_FIVE), None, 5);
+}
+
+#[test]
+fn long_chain_missing_blocks_within_ancestor_count() {
+    // BLOCK_THREE does not have a parent in the store
+    let chain = vec![&*BLOCK_THREE, &*BLOCK_FOUR, &*BLOCK_FIVE];
+    check_chain_head_update(chain, None, Some(&BLOCK_THREE.parent_hash));
+}
+
+#[test]
+fn long_chain_missing_blocks_beyond_ancestor_count() {
+    // We don't mind missing blocks ANCESTOR_COUNT many blocks out, in
+    // this case BLOCK_ONE
+    let chain = vec![&*BLOCK_TWO, &*BLOCK_THREE, &*BLOCK_FOUR, &*BLOCK_FIVE];
+    check_chain_head_update(chain, Some(&*BLOCK_FIVE), None);
+}
+
+#[test]
+fn long_chain_with_uncles() {
+    let chain = vec![
+        &*BLOCK_ONE,
+        &*BLOCK_TWO,
+        &*BLOCK_TWO_NO_PARENT,
+        &*BLOCK_THREE,
+        &*BLOCK_THREE_NO_PARENT,
+        &*BLOCK_FOUR,
+    ];
+    check_chain_head_update_cache(chain, Some(&*BLOCK_FOUR), None, 4);
+}
+
+#[test]
+fn test_get_block_number() {
+    let chain = vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_TWO];
+    let subgraph = DeploymentHash::new("nonExistentSubgraph").unwrap();
+
+    run_test_async(chain, move |_, subgraph_store, _| {
+        let subgraph = subgraph.cheap_clone();
+        async move {
+            create_test_subgraph(&subgraph, "type Dummy @entity { id: ID! }").await;
+
+            let query_store = subgraph_store
+                .query_store(QueryTarget::Deployment(
+                    subgraph.cheap_clone(),
+                    Default::default(),
+                ))
+                .await
+                .unwrap();
+
+            let block = query_store
+                .block_number(&GENESIS_BLOCK.block_hash())
+                .await
+                .expect("Found genesis block");
+            assert_eq!(Some(0), block);
+
+            let block = query_store
+                .block_number(&BLOCK_ONE.block_hash())
+                .await
+                .expect("Found block 1");
+            assert_eq!(Some(1), block);
+
+            let block = query_store
+                .block_number(&BLOCK_THREE.block_hash())
+                .await
+                .expect("Looked for block 3");
+            assert!(block.is_none());
+        }
+    })
+}
+
+#[test]
+fn block_hashes_by_number() {
+    let chain = vec![
+        &*GENESIS_BLOCK,
+        &*BLOCK_ONE,
+        &*BLOCK_TWO,
+        &*BLOCK_TWO_NO_PARENT,
+    ];
+    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).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).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).await.unwrap();
+        assert_eq!(vec![BLOCK_ONE.block_hash()], hashes);
+
+        let hashes = store.block_hashes_by_block_number(2).await.unwrap();
+        assert_eq!(vec![BLOCK_TWO.block_hash()], hashes);
+    })
+}
+
+#[track_caller]
+fn check_ancestor(
+    store: &Arc<DieselChainStore>,
+    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,
+        root,
+    ))?
+    .ok_or_else(|| anyhow!("block {} has no ancestor at offset {}", child.hash, offset))?;
+
+    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 {
+        Err(anyhow!(
+            "expected hash `{}` but got `{}`",
+            exp_hash,
+            act_hash
+        ))
+    } else {
+        Ok(())
+    }
+}
+
+#[test]
+fn ancestor_block_simple() {
+    let chain = vec![
+        &*GENESIS_BLOCK,
+        &*BLOCK_ONE,
+        &*BLOCK_TWO,
+        &*BLOCK_THREE,
+        &*BLOCK_FOUR,
+        &*BLOCK_FIVE,
+    ];
+
+    run_test(chain, move |store, _| -> Result<(), Error> {
+        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,
+                None,
+            ));
+            assert!(res.is_err());
+        }
+
+        let block =
+            executor::block_on(store.ancestor_block(BLOCK_TWO_NO_PARENT.block_ptr(), 1, None))?;
+        assert!(block.is_none());
+        Ok(())
+    });
+}
+
+#[test]
+fn ancestor_block_ommers() {
+    let chain = vec![
+        &*GENESIS_BLOCK,
+        &*BLOCK_ONE,
+        &*BLOCK_ONE_SIBLING,
+        &*BLOCK_TWO,
+    ];
+
+    run_test(chain, move |store, _| -> Result<(), Error> {
+        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(())
+    });
+}
+
+#[test]
+fn eth_call_cache() {
+    let chain = vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_TWO];
+
+    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
+            .cheap_clone()
+            .set_call(
+                &logger,
+                call.cheap_clone(),
+                BLOCK_ONE.block_ptr(),
+                ccr(&return_value),
+            )
+            .await
+            .unwrap();
+
+        let ret = store
+            .get_call(&call, GENESIS_BLOCK.block_ptr())
+            .await
+            .unwrap();
+        assert!(ret.is_none());
+
+        let ret = store
+            .get_call(&call, BLOCK_ONE.block_ptr())
+            .await
+            .unwrap()
+            .unwrap()
+            .retval
+            .unwrap();
+        assert_eq!(&return_value, ret.as_slice());
+
+        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
+            .cheap_clone()
+            .set_call(
+                &logger,
+                call.cheap_clone(),
+                BLOCK_TWO.block_ptr(),
+                ccr(&new_return_value),
+            )
+            .await
+            .unwrap();
+        let ret = store
+            .get_call(&call, BLOCK_TWO.block_ptr())
+            .await
+            .unwrap()
+            .unwrap()
+            .retval
+            .unwrap();
+        assert_eq!(&new_return_value, ret.as_slice());
+
+        // 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(&B256::ZERO)
+            .await
+            .unwrap();
+        assert!(receipts.is_empty())
+    })
+}
diff --git a/store/postgres/tests/graft.rs b/store/test-store/tests/postgres/graft.rs
similarity index 61%
rename from store/postgres/tests/graft.rs
rename to store/test-store/tests/postgres/graft.rs
index 35f98364411..6536fc3e06c 100644
--- a/store/postgres/tests/graft.rs
+++ b/store/test-store/tests/postgres/graft.rs
@@ -1,17 +1,19 @@
 use graph::blockchain::block_stream::FirehoseCursor;
+use graph::schema::InputSchema;
 use graph_store_postgres::command_support::OnSync;
 use lazy_static::lazy_static;
 use std::{marker::PhantomData, str::FromStr};
 use test_store::*;
 
 use graph::components::store::{
-    DeploymentLocator, EntityKey, EntityOrder, EntityQuery, EntityType, PruneReporter,
+    DeploymentLocator, EntityOrder, EntityQuery, PruneReporter, PruneRequest, PruningStrategy,
+    VersionStats,
 };
-use graph::data::store::scalar;
+use graph::data::store::{Id, scalar};
 use graph::data::subgraph::schema::*;
 use graph::data::subgraph::*;
-use graph::prelude::*;
 use graph::semver::Version;
+use graph::{entity, prelude::*};
 use graph_store_postgres::{Shard, SubgraphStore as DieselSubgraphStore};
 
 const USER_GQL: &str = "
@@ -75,9 +77,10 @@ const USER: &str = "User";
 
 lazy_static! {
     static ref TEST_SUBGRAPH_ID: DeploymentHash = DeploymentHash::new("testsubgraph").unwrap();
-    static ref TEST_SUBGRAPH_SCHEMA: Schema =
-        Schema::parse(USER_GQL, TEST_SUBGRAPH_ID.clone()).expect("Failed to parse user schema");
-    static ref BLOCKS: Vec<BlockPtr> = vec![
+    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> = [
         "bd34884280958002c51d3f7b5f853e6febeba33de0f40d15b0363006533c924f",
         "8511fa04b64657581e3f00e14543c1d522d5d7e771b54aa3060b662ade47da13",
         "b98fb783b49de5652097a989414c767824dff7e7fd765a63b493772511db81c1",
@@ -103,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;
@@ -117,7 +120,7 @@ where
 
         store
             .cheap_clone()
-            .writable(LOGGER.clone(), deployment.id)
+            .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
             .await
             .unwrap()
             .flush()
@@ -133,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,
@@ -142,6 +145,7 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
         graft: None,
         templates: vec![],
         chain: PhantomData,
+        indexer_hints: None,
     };
 
     // Create SubgraphDeploymentEntity
@@ -160,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(
@@ -171,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
@@ -185,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",
@@ -195,6 +202,7 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
         111.7,
         false,
         Some("blue"),
+        2,
     );
     transact_entity_operations(
         &store,
@@ -214,6 +222,7 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
         111.7,
         false,
         None,
+        3,
     );
     transact_entity_operations(
         &store,
@@ -237,41 +246,29 @@ fn create_test_entity(
     weight: f64,
     coffee: bool,
     favorite_color: Option<&str>,
+    vid: i64,
 ) -> EntityOperation {
-    let mut test_entity = Entity::new();
-
-    test_entity.insert("id".to_owned(), Value::String(id.to_owned()));
-    test_entity.insert("name".to_owned(), Value::String(name.to_owned()));
     let bin_name = scalar::Bytes::from_str(&hex::encode(name)).unwrap();
-    test_entity.insert("bin_name".to_owned(), Value::Bytes(bin_name));
-    test_entity.insert("email".to_owned(), Value::String(email.to_owned()));
-    test_entity.insert("age".to_owned(), Value::Int(age));
-    test_entity.insert(
-        "seconds_age".to_owned(),
-        Value::BigInt(BigInt::from(age) * 31557600.into()),
-    );
-    test_entity.insert("weight".to_owned(), Value::BigDecimal(weight.into()));
-    test_entity.insert("coffee".to_owned(), Value::Bool(coffee));
-    test_entity.insert(
-        "favorite_color".to_owned(),
-        favorite_color
-            .map(|s| Value::String(s.to_owned()))
-            .unwrap_or(Value::Null),
-    );
+    let test_entity = entity! { TEST_SUBGRAPH_SCHEMA =>
+        id: id,
+        name: name,
+        bin_name: bin_name,
+        email: email,
+        age: age,
+        seconds_age: age * 31557600,
+        weight: Value::BigDecimal(weight.into()),
+        coffee: coffee,
+        favorite_color: favorite_color,
+        vid: vid,
+    };
 
+    let entity_type = TEST_SUBGRAPH_SCHEMA.entity_type(entity_type).unwrap();
     EntityOperation::Set {
-        key: EntityKey::data(entity_type.to_string(), id),
+        key: entity_type.parse_key(id).unwrap(),
         data: 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,
@@ -282,14 +279,15 @@ 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<String>) {
+) -> (Vec<Entity>, Vec<Id>) {
+    let entity_type = TEST_SUBGRAPH_SCHEMA.entity_type(USER).unwrap();
     let query = EntityQuery::new(
         deployment.hash.clone(),
         BLOCK_NUMBER_MAX,
-        EntityCollection::All(vec![(EntityType::from(USER), AttributeNames::All)]),
+        EntityCollection::All(vec![(entity_type, AttributeNames::All)]),
     )
     .order(EntityOrder::Descending(
         "name".to_string(),
@@ -298,11 +296,12 @@ fn find_entities(
 
     let entities = store
         .find(query)
+        .await
         .expect("store.find failed to execute query");
 
     let ids = entities
         .iter()
-        .map(|entity| entity.id().unwrap())
+        .map(|entity| entity.id())
         .collect::<Vec<_>>();
     (entities, ids)
 }
@@ -311,26 +310,33 @@ 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;
 
-    assert_eq!(vec!["3", "1", "2"], ids);
+    let ids_str = ids.iter().map(|id| id.to_string()).collect::<Vec<_>>();
+    assert_eq!(vec!["3", "1", "2"], ids_str);
 
     // Make sure we caught Shaqueeena at block 1, before the change in
     // email address
     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");
+    shaq.set("email", "shaq@gmail.com").unwrap();
+    let _ = shaq.set_vid(3);
     let op = EntityOperation::Set {
-        key: EntityKey::data(USER.to_owned(), "3"),
+        key: user_type.parse_key("3").unwrap(),
         data: shaq,
     };
     transact_and_wait(&store, &deployment, BLOCKS[2].clone(), vec![op])
         .await
         .unwrap();
 
-    let writable = store.writable(LOGGER.clone(), deployment.id).await?;
+    let writable = store
+        .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
+        .await?;
     writable
         .revert_block_operations(BLOCKS[1].clone(), FirehoseCursor::None)
         .await
@@ -399,19 +405,20 @@ fn graft() {
         .await
         .expect("grafting onto block 0 works");
 
-        let (entities, ids) = find_entities(store.as_ref(), &deployment);
-        assert_eq!(vec!["1"], ids);
+        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();
         assert_eq!(Some(&Value::from("tonofjohn@email.com")), shaq.get("email"));
         Ok(())
     })
 }
 
-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()
@@ -431,23 +438,25 @@ 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()
-                .writable(LOGGER.clone(), deployment.id)
+                .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
                 .await?
                 .start_subgraph_deployment(&LOGGER)
                 .await?;
 
-            store.activate(&deployment)?;
+            store.activate(&deployment).await?;
 
             check_graft(store, deployment).await?;
         }
@@ -462,25 +471,24 @@ 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().writable(LOGGER.clone(), dst.id).await?;
+                let writable = store
+                    .cheap_clone()
+                    .writable(LOGGER.clone(), dst.id, Arc::new(Vec::new()))
+                    .await?;
 
-                writable.start_subgraph_deployment(&*LOGGER).await?;
-                writable.deployment_synced()?;
+                writable.start_subgraph_deployment(&LOGGER).await?;
+                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 {
@@ -508,27 +516,32 @@ 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().writable(LOGGER.clone(), dst.id).await?;
+            let writable = store
+                .cheap_clone()
+                .writable(LOGGER.clone(), dst.id, Arc::new(Vec::new()))
+                .await?;
 
             // Perform the copy
-            writable.start_subgraph_deployment(&*LOGGER).await?;
+            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(())
@@ -537,96 +550,123 @@ fn on_sync() {
 
 #[test]
 fn prune() {
-    fn check_at_block(
+    struct Progress;
+    impl PruneReporter for Progress {}
+
+    async fn check_at_block(
         store: &DieselSubgraphStore,
         src: &DeploymentLocator,
+        strategy: PruningStrategy,
         block: BlockNumber,
         exp: Vec<&str>,
     ) {
+        let user_type = TEST_SUBGRAPH_SCHEMA.entity_type("User").unwrap();
         let query = EntityQuery::new(
             src.hash.clone(),
             block,
-            EntityCollection::All(vec![(
-                EntityType::new("User".to_string()),
-                AttributeNames::All,
-            )]),
+            EntityCollection::All(vec![(user_type.clone(), AttributeNames::All)]),
         );
 
+        let exp = exp
+            .into_iter()
+            .map(|id| user_type.parse_id(id).unwrap())
+            .collect::<Vec<_>>();
         let act: Vec<_> = store
             .find(query)
+            .await
             .unwrap()
             .into_iter()
-            .map(|entity| entity.id().unwrap())
+            .map(|entity| entity.id())
             .collect();
-        assert_eq!(act, exp);
+        assert_eq!(
+            act, exp,
+            "different users visible at block {block} with {strategy}"
+        );
     }
 
-    async fn prune(
-        store: &DieselSubgraphStore,
-        src: &DeploymentLocator,
-        earliest_block: BlockNumber,
-    ) -> Result<(), StoreError> {
-        struct Progress;
-        impl PruneReporter for Progress {}
-        let reporter = Box::new(Progress);
+    for strategy in [PruningStrategy::Rebuild, PruningStrategy::Delete] {
+        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
-            .prune(reporter, src, earliest_block, 1, 1.1)
-            .await
-            .map(|_| ())
+            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
+            let user2 = create_test_entity(
+                "2",
+                USER,
+                "Cindini",
+                "dinici@email.com",
+                44_i32,
+                157.1,
+                true,
+                Some("red"),
+                4,
+            );
+            transact_and_wait(&store, &src, BLOCKS[5].clone(), vec![user2])
+                .await
+                .unwrap();
+
+            // Setup and the above addition create these user versions:
+            // id | versions
+            // ---+---------
+            //  1 | [0,)
+            //  2 | [1,5) [5,)
+            //  3 | [1,2) [2,)
+
+            // Forward block ptr to block 6
+            transact_and_wait(&store, &src, BLOCKS[6].clone(), vec![])
+                .await
+                .unwrap();
+
+            // Prune to 3 blocks of history, with a reorg threshold of 1 where
+            // we have blocks from [0, 6]. That should only remove the [1,2)
+            // version of user 3
+            let mut req = PruneRequest::new(&src, 3, 1, 0, 6)?;
+            // Change the thresholds so that we select the desired strategy
+            match strategy {
+                PruningStrategy::Rebuild => {
+                    req.rebuild_threshold = 0.0;
+                    req.delete_threshold = 0.0;
+                }
+                PruningStrategy::Delete => {
+                    req.rebuild_threshold = 1.0;
+                    req.delete_threshold = 0.0;
+                }
+            }
+            // We have 5 versions for 3 entities
+            let stats = VersionStats {
+                entities: 3,
+                versions: 5,
+                tablename: USER.to_ascii_lowercase(),
+                ratio: 3.0 / 5.0,
+                last_pruned_block: None,
+                block_range_upper: vec![],
+            };
+            assert_eq!(
+                Some(strategy),
+                req.strategy(&stats),
+                "changing thresholds didn't yield desired strategy"
+            );
+            store
+                .prune(Box::new(Progress), &src, req)
+                .await
+                .expect("pruning works");
+
+            // 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"]).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"]).await;
+            }
+            Ok(())
+        })
     }
-
-    run_test(|store, src| async move {
-        // The setup sets the subgraph pointer to block 2, we try to set
-        // earliest block to 5
-        prune(&store, &src, 5)
-            .await
-            .expect_err("setting earliest block later than latest does not work");
-
-        // Latest block 2 minus reorg threshold 1 means we need to copy
-        // final blocks from block 1, but want earliest as block 2, i.e. no
-        // final blocks which won't work
-        prune(&store, &src, 2)
-            .await
-            .expect_err("setting earliest block after last final block fails");
-
-        // Add another version for user 2 at block 4
-        let user2 = create_test_entity(
-            "2",
-            USER,
-            "Cindini",
-            "dinici@email.com",
-            44_i32,
-            157.1,
-            true,
-            Some("red"),
-        );
-        transact_and_wait(&store, &src, BLOCKS[5].clone(), vec![user2])
-            .await
-            .unwrap();
-
-        // Setup and the above addition create these user versions:
-        // id | versions
-        // ---+---------
-        //  1 | [0,)
-        //  2 | [1,5) [5,)
-        //  3 | [1,2) [2,)
-
-        // Forward block ptr to block 5
-        transact_and_wait(&store, &src, BLOCKS[6].clone(), vec![])
-            .await
-            .unwrap();
-        // Pruning only removes the [1,2) version of user 3
-        prune(&store, &src, 3).await.expect("pruning works");
-
-        // 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, 0, vec!["1"]);
-        check_at_block(&store, &src, 1, vec!["1", "2"]);
-        for block in 2..=5 {
-            check_at_block(&store, &src, block, vec!["1", "2", "3"]);
-        }
-        Ok(())
-    })
 }
diff --git a/store/postgres/tests/relational.rs b/store/test-store/tests/postgres/relational.rs
similarity index 57%
rename from store/postgres/tests/relational.rs
rename to store/test-store/tests/postgres/relational.rs
index 6f861a3027b..c4946b408c5 100644
--- a/store/postgres/tests/relational.rs
+++ b/store/test-store/tests/postgres/relational.rs
@@ -1,21 +1,21 @@
 //! Test mapping of GraphQL schema to a relational schema
-use diesel::connection::SimpleConnection as _;
-use diesel::pg::PgConnection;
-use graph::components::store::EntityKey;
+use diesel_async::SimpleAsyncConnection;
+use graph::components::store::write::{EntityModification, RowGroup};
 use graph::data::store::scalar;
 use graph::entity;
-use graph::prelude::BlockNumber;
+use graph::prelude::alloy::primitives::B256;
 use graph::prelude::{
-    o, slog, tokio, web3::types::H256, DeploymentHash, Entity, EntityCollection, EntityFilter,
-    EntityOrder, EntityQuery, Logger, Schema, StopwatchMetrics, Value, ValueType, BLOCK_NUMBER_MAX,
+    BLOCK_NUMBER_MAX, DeploymentHash, Entity, EntityCollection, EntityFilter, EntityOrder,
+    EntityQuery, Logger, StopwatchMetrics, Value, ValueType, o, slog,
 };
-use graph_mock::MockMetricsRegistry;
-use graph_store_postgres::layout_for_tests::set_account_like;
+use graph::prelude::{BlockNumber, MetricsRegistry};
+use graph::schema::{EntityKey, EntityType, InputSchema};
+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::borrow::Cow;
 use std::collections::BTreeSet;
 use std::panic;
 use std::str::FromStr;
@@ -24,8 +24,8 @@ use std::thread::sleep;
 use std::time::Duration;
 
 use graph::{
-    components::store::{AttributeNames, EntityType},
-    data::store::scalar::{BigDecimal, BigInt, Bytes},
+    components::store::AttributeNames,
+    data::store::scalar::{BigDecimal, BigInt, Bytes, Timestamp},
 };
 use graph_store_postgres::{
     layout_for_tests::make_dummy_site,
@@ -34,6 +34,8 @@ use graph_store_postgres::{
 
 use test_store::*;
 
+use crate::postgres::relational_bytes::{row_group_delete, row_group_insert, row_group_update};
+
 const THINGS_GQL: &str = r#"
     type _Schema_ @fulltext(
         name: "userSearch"
@@ -48,6 +50,19 @@ const THINGS_GQL: &str = r#"
                 ]
             }
         ]
+    ) @fulltext(
+        name: "userSearch2"
+        language: en
+        algorithm: rank
+        include: [
+            {
+                entity: "User",
+                fields: [
+                    { name: "name"},
+                    { name: "email"},
+                ]
+            }
+        ]
     ) @fulltext(
         name: "nullableStringsSearch"
         language: en
@@ -84,6 +99,8 @@ const THINGS_GQL: &str = r#"
         bigInt: BigInt,
         bigIntArray: [BigInt!]!
         color: Color,
+        int8: Int8,
+        timestamp: Timestamp
     }
 
     interface Pet {
@@ -111,12 +128,18 @@ 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!,
         bin_name: Bytes!,
         email: String!,
         age: Int!,
+        visits: Int8!
         seconds_age: BigInt!,
         weight: BigDecimal!,
         coffee: Boolean!,
@@ -150,30 +173,42 @@ 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! {
     static ref THINGS_SUBGRAPH_ID: DeploymentHash = DeploymentHash::new("things").unwrap();
+    static ref THINGS_SCHEMA: InputSchema =
+        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);
+    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 = {
         let decimal = (*LARGE_DECIMAL).clone();
         let big_int = (*LARGE_INT).clone();
-        entity! {
+        entity! { THINGS_SCHEMA =>
             id: "one",
             bool: true,
-            int: std::i32::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",
@@ -183,112 +218,120 @@ 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! {
+        entity! { THINGS_SCHEMA =>
             id: "one",
+            vid: 0i64,
         }
     };
-    static ref SCALAR: EntityType = EntityType::from("Scalar");
-    static ref NO_ENTITY: EntityType = EntityType::from("NoEntity");
-    static ref NULLABLE_STRINGS: EntityType = EntityType::from("NullableStrings");
+    static ref SCALAR_TYPE: EntityType = THINGS_SCHEMA.entity_type("Scalar").unwrap();
+    static ref USER_TYPE: EntityType = THINGS_SCHEMA.entity_type("User").unwrap();
+    static ref DOG_TYPE: EntityType = THINGS_SCHEMA.entity_type("Dog").unwrap();
+    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();
     static ref MOCK_STOPWATCH: StopwatchMetrics = StopwatchMetrics::new(
         Logger::root(slog::Discard, o!()),
         THINGS_SUBGRAPH_ID.clone(),
         "test",
-        Arc::new(MockMetricsRegistry::new()),
+        Arc::new(MetricsRegistry::mock()),
+        "test_shard".to_string()
     );
 }
 
 /// 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: &str,
+    entity_type: &EntityType,
     mut entities: Vec<Entity>,
     block: BlockNumber,
 ) {
     let entities_with_keys_owned = entities
         .drain(..)
         .map(|entity| {
-            let key = EntityKey::data(entity_type.to_owned(), entity.id().unwrap());
+            let key = entity_type.key(entity.id());
             (key, entity)
         })
         .collect::<Vec<(EntityKey, Entity)>>();
-    let mut entities_with_keys: Vec<_> = entities_with_keys_owned
+    let entities_with_keys: Vec<_> = entities_with_keys_owned
         .iter()
-        .map(|(key, entity)| (key, Cow::from(entity)))
+        .map(|(key, entity)| (key, entity))
         .collect();
-    let entity_type = EntityType::from(entity_type);
     let errmsg = format!(
         "Failed to insert entities {}[{:?}]",
         entity_type, entities_with_keys
     );
-    let inserted = layout
-        .insert(
-            conn,
-            &entity_type,
-            &mut entities_with_keys,
-            block,
-            &MOCK_STOPWATCH,
-        )
+    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!(inserted, entities_with_keys_owned.len());
+    assert_eq!(
+        group.entity_count_change(),
+        entities_with_keys_owned.len() as i32
+    );
 }
 
-fn insert_entity(conn: &PgConnection, layout: &Layout, entity_type: &str, entities: Vec<Entity>) {
-    insert_entity_at(conn, layout, entity_type, entities, 0);
+async fn insert_entity(
+    conn: &mut AsyncPgConnection,
+    layout: &Layout,
+    entity_type: &EntityType,
+    entities: Vec<Entity>,
+) {
+    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: &str,
+    entity_type: &EntityType,
     mut entities: Vec<Entity>,
     block: BlockNumber,
 ) {
     let entities_with_keys_owned: Vec<(EntityKey, Entity)> = entities
         .drain(..)
         .map(|entity| {
-            let key = EntityKey::data(entity_type.to_owned(), entity.id().unwrap());
+            let key = entity_type.key(entity.id());
             (key, entity)
         })
         .collect();
-    let mut entities_with_keys: Vec<_> = entities_with_keys_owned
+    let entities_with_keys: Vec<_> = entities_with_keys_owned
         .iter()
-        .map(|(key, entity)| (key, Cow::from(entity)))
+        .map(|(key, entity)| (key, entity))
         .collect();
 
-    let entity_type = EntityType::from(entity_type);
     let errmsg = format!(
         "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,
-            &entity_type,
-            &mut entities_with_keys,
-            block,
-            &MOCK_STOPWATCH,
-        )
+        .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: &str,
+    entity_type: &EntityType,
     name: &str,
     email: &str,
     age: i32,
@@ -296,14 +339,29 @@ fn insert_user_entity(
     coffee: bool,
     favorite_color: Option<&str>,
     drinks: Option<Vec<&str>>,
+    visits: i64,
     block: BlockNumber,
+    vid: i64,
 ) {
-    let user = make_user(id, name, email, age, weight, coffee, favorite_color, drinks);
+    let user = make_user(
+        &layout.input_schema,
+        id,
+        name,
+        email,
+        age,
+        weight,
+        coffee,
+        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(
+    schema: &InputSchema,
     id: &str,
     name: &str,
     email: &str,
@@ -312,12 +370,14 @@ fn make_user(
     coffee: bool,
     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()))
         .unwrap_or(Value::Null);
     let bin_name = Bytes::from_str(&hex::encode(name)).unwrap();
-    let mut user = entity! {
+    let mut user = entity! { schema =>
         id: id,
         name: name,
         bin_name: bin_name,
@@ -326,20 +386,22 @@ fn make_user(
         seconds_age: BigInt::from(age) * BigInt::from(31557600_u64),
         weight: BigDecimal::from(weight),
         coffee: coffee,
-        favorite_color: favorite_color
+        favorite_color: favorite_color,
+        visits: visits,
+        vid: vid,
     };
     if let Some(drinks) = drinks {
-        user.insert("drinks".to_owned(), drinks.into());
+        user.insert("drinks", drinks.into()).unwrap();
     }
     user
 }
 
-fn insert_users(conn: &PgConnection, layout: &Layout) {
+async fn insert_users(conn: &mut AsyncPgConnection, layout: &Layout) {
     insert_user_entity(
         conn,
         layout,
         "1",
-        "User",
+        &USER_TYPE,
         "Johnton",
         "tonofjohn@email.com",
         67_i32,
@@ -347,13 +409,16 @@ fn insert_users(conn: &PgConnection, layout: &Layout) {
         false,
         Some("yellow"),
         None,
+        60,
         0,
-    );
+        0,
+    )
+    .await;
     insert_user_entity(
         conn,
         layout,
         "2",
-        "User",
+        &USER_TYPE,
         "Cindini",
         "dinici@email.com",
         43_i32,
@@ -361,13 +426,16 @@ fn insert_users(conn: &PgConnection, layout: &Layout) {
         true,
         Some("red"),
         Some(vec!["beer", "wine"]),
+        50,
         0,
-    );
+        1,
+    )
+    .await;
     insert_user_entity(
         conn,
         layout,
         "3",
-        "User",
+        &USER_TYPE,
         "Shaqueeena",
         "teeko@email.com",
         28_i32,
@@ -375,15 +443,18 @@ fn insert_users(conn: &PgConnection, layout: &Layout) {
         false,
         None,
         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: &str,
+    entity_type: &EntityType,
     name: &str,
     email: &str,
     age: i32,
@@ -391,51 +462,66 @@ fn update_user_entity(
     coffee: bool,
     favorite_color: Option<&str>,
     drinks: Option<Vec<&str>>,
+    visits: i64,
     block: BlockNumber,
+    vid: i64,
 ) {
-    let user = make_user(id, name, email, age, weight, coffee, favorite_color, drinks);
-    update_entity_at(conn, layout, entity_type, vec![user], block);
+    let user = make_user(
+        &layout.input_schema,
+        id,
+        name,
+        email,
+        age,
+        weight,
+        coffee,
+        favorite_color,
+        drinks,
+        visits,
+        vid,
+    );
+    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: &str,
+    entity_type: &EntityType,
     id: &str,
     name: &str,
     block: BlockNumber,
+    vid: i64,
 ) {
-    let pet = entity! {
+    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", "pluto", "Pluto", 0);
-    insert_pet(conn, layout, "Cat", "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 {
-    let schema = Schema::parse(THINGS_GQL, THINGS_SUBGRAPH_ID.clone()).unwrap();
+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(),
         NAMESPACE.clone(),
         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")
 }
 
 fn scrub(entity: &Entity) -> Entity {
-    let mut scrubbed = Entity::new();
-    // merge_remove_null_fields has the side-effect of removing any attribute
-    // that is Value::Null
-    scrubbed.merge_remove_null_fields(entity.clone());
+    let mut scrubbed = entity.clone();
+    scrubbed.remove_null_fields();
     scrubbed
 }
 
@@ -472,34 +558,36 @@ 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", 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
             .find(
                 conn,
-                &EntityKey::data(SCALAR.as_str(), "one"),
+                &SCALAR_TYPE.parse_key("one").unwrap(),
                 BLOCK_NUMBER_MAX,
             )
+            .await
             .expect("Failed to read Scalar[one]")
             .unwrap();
         assert_entity_eq!(scrub(&SCALAR_ENTITY), entity);
@@ -508,141 +596,217 @@ fn find() {
         let entity = layout
             .find(
                 conn,
-                &EntityKey::data(SCALAR.as_str(), "noone"),
+                &SCALAR_TYPE.parse_key("noone").unwrap(),
                 BLOCK_NUMBER_MAX,
             )
+            .await
             .expect("Failed to read Scalar[noone]");
         assert!(entity.is_none());
-
-        // Find for non-existing entity type
-        let err = layout.find(
-            conn,
-            &EntityKey::data(NO_ENTITY.as_str(), "one"),
-            BLOCK_NUMBER_MAX,
-        );
-        match err {
-            Err(e) => assert_eq!("unknown table 'NoEntity'", e.to_string()),
-            _ => {
-                println!("{:?}", err);
-                assert!(false)
-            }
-        }
-    });
+    })
+    .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,
-            "NullableStrings",
+            &NULLABLE_STRINGS_TYPE,
             vec![EMPTY_NULLABLESTRINGS_ENTITY.clone()],
-        );
+        )
+        .await;
 
         // Find entity with null string values
         let entity = layout
             .find(
                 conn,
-                &EntityKey::data(NULLABLE_STRINGS.as_str(), "one"),
+                &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", 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");
+        entity.set("string", "updated").unwrap();
         entity.remove("strings");
-        entity.set("bool", Value::Null);
-        let key = EntityKey::data("Scalar".to_owned(), entity.id().unwrap());
+        entity.set("bool", Value::Null).unwrap();
+        entity.set("vid", 1i64).unwrap();
+        let key = SCALAR_TYPE.key(entity.id());
 
-        let entity_type = EntityType::from("Scalar");
-        let mut entities = vec![(&key, Cow::from(&entity))];
+        let entity_type = layout.input_schema.entity_type("Scalar").unwrap();
+        let entities = vec![(key, entity.clone())];
+        let group = row_group_update(&entity_type, 0, entities);
         layout
-            .update(conn, &entity_type, &mut entities, 0, &MOCK_STOPWATCH)
+            .update(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to update");
 
         let actual = layout
             .find(
                 conn,
-                &EntityKey::data(SCALAR.as_str(), "one"),
+                &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");
+        two.set("id", "two").unwrap();
+        two.set("vid", 1i64).unwrap();
         let mut three = SCALAR_ENTITY.clone();
-        three.set("id", "three");
+        three.set("id", "three").unwrap();
+        three.set("vid", 2i64).unwrap();
         insert_entity(
             conn,
             layout,
-            "Scalar",
+            &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");
+        one.set("string", "updated").unwrap();
         one.remove("strings");
 
-        two.set("string", "updated too");
-        two.set("bool", false);
+        two.set("string", "updated too").unwrap();
+        two.set("bool", false).unwrap();
 
-        three.set("string", "updated in a different way");
+        three.set("string", "updated in a different way").unwrap();
         three.remove("strings");
-        three.set("color", "red");
+        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 = EntityType::from("Scalar");
+        let entity_type = layout.input_schema.entity_type("Scalar").unwrap();
         let keys: Vec<EntityKey> = ["one", "two", "three"]
             .iter()
-            .map(|id| EntityKey::data("Scalar".to_owned(), String::from(*id)))
+            .map(|id| SCALAR_TYPE.parse_key(*id).unwrap())
             .collect();
 
         let entities_vec = vec![one, two, three];
-        let mut entities: Vec<(&EntityKey, Cow<'_, Entity>)> = keys
-            .iter()
-            .zip(entities_vec.iter().map(Cow::Borrowed))
-            .collect();
-
+        let entities: Vec<_> = keys.into_iter().zip(entities_vec.into_iter()).collect();
+        let group = row_group_update(&entity_type, 0, entities);
         layout
-            .update(conn, &entity_type, &mut entities, 0, &MOCK_STOPWATCH)
+            .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,
-                        &EntityKey::data(SCALAR.as_str(), id),
-                        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];
@@ -674,269 +838,351 @@ 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", 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);
+            entity.set("bigDecimal", d).unwrap();
+            entity.set("vid", vid).unwrap();
 
-            let key = EntityKey::data("Scalar".to_owned(), entity.id().unwrap().clone());
-            let entity_type = EntityType::from("Scalar");
-            let mut entities = vec![(&key, Cow::Borrowed(&entity))];
+            let key = SCALAR_TYPE.key(entity.id());
+            let entity_type = layout.input_schema.entity_type("Scalar").unwrap();
+            let entities = vec![(key, entity.clone())];
+            let group = row_group_update(&entity_type, 0, entities);
             layout
-                .update(
-                    conn,
-                    &entity_type,
-                    entities.as_mut_slice(),
-                    0,
-                    &MOCK_STOPWATCH,
-                )
+                .update(conn, &group, &MOCK_STOPWATCH)
+                .await
                 .expect("Failed to update");
 
             let actual = layout
                 .find(
                     conn,
-                    &EntityKey::data(SCALAR.as_str(), "one"),
+                    &SCALAR_TYPE.parse_key("one").unwrap(),
                     BLOCK_NUMBER_MAX,
                 )
+                .await
                 .expect("Failed to read Scalar[one]")
                 .unwrap();
             assert_entity_eq!(entity, actual);
         }
-    });
+    })
+    .await;
 }
 
-fn count_scalar_entities(conn: &PgConnection, layout: &Layout) -> usize {
+#[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
+}
+
+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()),
     ]);
-    let collection = EntityCollection::All(vec![(SCALAR.to_owned(), AttributeNames::All)]);
+    let collection = EntityCollection::All(vec![(SCALAR_TYPE.to_owned(), AttributeNames::All)]);
     let mut query = EntityQuery::new(layout.site.deployment.clone(), BLOCK_NUMBER_MAX, collection)
         .filter(filter);
     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", 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");
-        insert_entity(conn, layout, "Scalar", vec![two]);
+        two.set("id", "two").unwrap();
+        two.set("vid", 1i64).unwrap();
+        insert_entity(conn, layout, &SCALAR_TYPE, vec![two]).await;
 
         // Delete where nothing is getting deleted
-        let key = EntityKey::data("Scalar".to_owned(), "no such entity".to_owned());
-        let entity_type = EntityType::from("Scalar");
-        let mut entity_keys = vec![key.entity_id.as_str()];
+        let key = SCALAR_TYPE.parse_key("no such entity").unwrap();
+        let entity_type = layout.input_schema.entity_type("Scalar").unwrap();
+        let mut entity_keys = vec![key];
+        let group = row_group_delete(&entity_type, 1, entity_keys.clone());
         let count = layout
-            .delete(conn, &entity_type, &entity_keys, 1, &MOCK_STOPWATCH)
+            .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
             .get_mut(0)
-            .map(|key| *key = "two")
+            .map(|key| key.entity_id = SCALAR_TYPE.parse_id("two").unwrap())
             .expect("Failed to update key");
 
+        let group = row_group_delete(&entity_type, 1, entity_keys);
         let count = layout
-            .delete(conn, &entity_type, &entity_keys, 1, &MOCK_STOPWATCH)
+            .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");
+        two.set("id", "two").unwrap();
+        two.set("vid", 1i64).unwrap();
         let mut three = SCALAR_ENTITY.clone();
-        three.set("id", "three");
-        insert_entity(conn, layout, "Scalar", vec![one, two, three]);
+        three.set("id", "three").unwrap();
+        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_type = EntityType::from("Scalar");
-        let entity_keys = vec!["two", "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 num_removed = layout
-            .delete(conn, &entity_type, &entity_keys, 1, &MOCK_STOPWATCH)
+            .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 cat = EntityType::from(cat);
-        let dog = EntityType::from(dog);
-        let ferret = EntityType::from(ferret);
+    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 mut fred = Entity::new();
-        fred.set("id", id.clone());
-        fred.set("name", Value::String(id.to_string()));
-        insert_entity(conn, layout, cat.as_str(), 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 = layout
-            .conflicting_entity(conn, &id.to_string(), vec![cat.clone(), ferret.clone()])
+        let conflict = conflicting(conn, &dog_type, vec![&cat_type, &ferret_type])
+            .await
             .unwrap();
-        assert_eq!(Some(cat.to_string()), conflict);
+        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 = layout
-            .conflicting_entity(conn, &id.to_string(), vec![dog.clone(), ferret.clone()])
+        let conflict = conflicting(conn, &cat_type, vec![&dog_type, &ferret_type])
+            .await
             .unwrap();
         assert_eq!(None, conflict);
-
-        // Chairs are not pets
-        let chair = EntityType::from("Chair");
-        let result = layout.conflicting_entity(conn, &id.to_string(), vec![dog, ferret, chair]);
-        assert!(result.is_err());
-        assert_eq!("unknown table 'Chair'", result.err().unwrap().to_string());
     }
 
-    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 fred = entity! {
+        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", vec![fred], block);
+                insert_entity_at(conn, layout, &CAT_TYPE, vec![fred], block).await;
             } else {
-                update_entity_at(conn, layout, "Cat", 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, &EntityKey::data("Cat", id), BLOCK_NUMBER_MAX)
+                .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! {
+                let marty = entity! { layout.input_schema =>
                     id: id,
                     order: block,
+                    vid: (block + 10) as i64
                 };
-                insert_entity_at(conn, layout, "Mink", 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![(EntityType::from("Mink"), AttributeNames::All)]);
+            let collection = EntityCollection::All(vec![(MINK_TYPE.clone(), AttributeNames::All)]);
             let filter = EntityFilter::StartsWith("id".to_string(), Value::from("marty"));
             let query = EntityQuery::new(id, BLOCK_NUMBER_MAX, collection)
                 .filter(filter)
@@ -944,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");
 
@@ -960,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",
+            &USER_TYPE,
             "Jono",
             "achangedemail@email.com",
             67_i32,
@@ -1004,20 +1254,24 @@ impl<'a> QueryChecker<'a> {
             false,
             Some("yellow"),
             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;
 
@@ -1043,21 +1297,21 @@ impl<'a> QueryChecker<'a> {
     }
 }
 
-fn query(entity_types: Vec<&str>) -> EntityQuery {
+fn query(entity_types: &[&EntityType]) -> EntityQuery {
     EntityQuery::new(
         THINGS_SUBGRAPH_ID.clone(),
         BLOCK_NUMBER_MAX,
         EntityCollection::All(
             entity_types
-                .into_iter()
-                .map(|entity_type| (EntityType::from(entity_type), AttributeNames::All))
+                .iter()
+                .map(|entity_type| ((*entity_type).clone(), AttributeNames::All))
                 .collect(),
         ),
     )
 }
 
 fn user_query() -> EntityQuery {
-    query(vec!["User"])
+    query(&[&*USER_TYPE])
 }
 
 trait EasyOrder {
@@ -1082,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",
+            &USER_TYPE,
             "Johnton",
             "tonofjohn@email.com",
             67_i32,
@@ -1112,8 +1373,11 @@ fn check_block_finds() {
             false,
             Some("yellow"),
             None,
+            55,
             1,
-        );
+            4,
+        )
+        .await;
 
         checker
             // Max block, we should get nothing
@@ -1121,61 +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)
-            .check(vec!["garfield", "pluto"], query(vec!["Cat", "Dog"]))
-            .check(
-                vec!["pluto", "garfield"],
-                query(vec!["Cat", "Dog"]).desc("name"),
-            )
+            .await
+            .check(vec!["garfield", "pluto"], query(&types))
+            .await
+            .check(vec!["pluto", "garfield"], query(&types).desc("name"))
+            .await
             .check(
                 vec!["garfield"],
-                query(vec!["Cat", "Dog"])
+                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"))
+            .await
+            .check(vec!["garfield", "pluto"], query(&types).unordered())
+            .await;
+
+        // fulltext
+        let checker = checker
             .check(
-                vec!["pluto", "garfield"],
-                query(vec!["Cat", "Dog"]).desc("id"),
+                vec!["3"],
+                user_query().filter(EntityFilter::Fulltext("userSearch".into(), "Shaq:*".into())),
             )
+            .await
             .check(
-                vec!["garfield", "pluto"],
-                query(vec!["Cat", "Dog"]).asc("id"),
+                vec!["1"],
+                user_query().filter(EntityFilter::Fulltext(
+                    "userSearch".into(),
+                    "Jono & achangedemail@email.com".into(),
+                )),
             )
-            .check(
-                vec!["garfield", "pluto"],
-                query(vec!["Cat", "Dog"]).unordered(),
-            );
-
-        // fulltext
+            .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("userSearch".into(), "Shaq:*".into())),
+                user_query().filter(EntityFilter::Fulltext(
+                    "userSearch2".into(),
+                    "Shaq:*".into(),
+                )),
             )
+            .await
             .check(
                 vec!["1"],
-                user_query().filter(EntityFilter::Equal(
-                    "userSearch".into(),
+                user_query().filter(EntityFilter::Fulltext(
+                    "userSearch2".into(),
                     "Jono & achangedemail@email.com".into(),
                 )),
-            );
+            )
+            .await;
 
         // list contains
         fn drinks_query(v: Vec<&str>) -> EntityQuery {
@@ -1185,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
@@ -1201,6 +1491,7 @@ fn check_find() {
                     vec!["beer"].into(),
                 )),
             )
+            .await
             // Users 2 do not have "tea" on its drinks list.
             .check(
                 vec!["2"],
@@ -1208,7 +1499,8 @@ fn check_find() {
                     "drinks".into(),
                     vec!["tea"].into(),
                 )),
-            );
+            )
+            .await;
 
         // string attributes
         let checker = checker
@@ -1216,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"],
@@ -1227,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()
@@ -1257,6 +1556,7 @@ fn check_find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -1266,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()
@@ -1287,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()
@@ -1299,7 +1604,8 @@ fn check_find() {
                         vec!["Shaqueeena".into()],
                     ))
                     .desc("name"),
-            );
+            )
+            .await;
         // float attributes
         let checker = checker
             .check(
@@ -1309,6 +1615,7 @@ fn check_find() {
                     Value::BigDecimal(184.4.into()),
                 )),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
@@ -1318,6 +1625,7 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query().filter(EntityFilter::GreaterThan(
@@ -1325,6 +1633,7 @@ fn check_find() {
                     Value::BigDecimal(160.0.into()),
                 )),
             )
+            .await
             .check(
                 vec!["2", "3"],
                 user_query()
@@ -1334,6 +1643,7 @@ fn check_find() {
                     ))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
@@ -1343,6 +1653,7 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -1354,6 +1665,7 @@ fn check_find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -1367,6 +1679,7 @@ fn check_find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -1379,7 +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"),
+            )
+            .await;
 
         // int attributes
         let checker = checker
@@ -1389,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(
@@ -1402,6 +1728,7 @@ fn check_find() {
                     Value::Int(43_i32),
                 )),
             )
+            .await
             .check(
                 vec!["2", "1"],
                 user_query()
@@ -1411,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()
@@ -1426,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()
@@ -1440,6 +1771,7 @@ fn check_find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -1450,6 +1782,7 @@ fn check_find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["3"],
                 user_query()
@@ -1459,7 +1792,8 @@ fn check_find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
 
         // bool attributes
         let checker = checker
@@ -1469,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()
@@ -1485,6 +1821,7 @@ fn check_find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -1494,7 +1831,8 @@ fn check_find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
         // misc tests
         let checker = checker
             .check(
@@ -1506,6 +1844,7 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["3"],
                 user_query()
@@ -1515,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()
@@ -1530,6 +1871,7 @@ fn check_find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -1539,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()
@@ -1557,7 +1910,8 @@ fn check_find() {
                         EntityFilter::Equal("id".to_owned(), Value::from("2")),
                     ])]))
                     .asc("id"),
-            );
+            )
+            .await;
 
         // enum attributes
         let checker = checker
@@ -1570,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()
@@ -1586,6 +1942,7 @@ fn check_find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query()
@@ -1595,7 +1952,8 @@ fn check_find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
 
         // empty and / or
 
@@ -1609,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
@@ -1634,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", "a1", &a1, 0);
-        insert_pet(conn, layout, "Ferret", "a2", &a2, 0);
-        insert_pet(conn, layout, "Ferret", "a2b", &a2b, 0);
-        insert_pet(conn, layout, "Ferret", "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"]).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;
 
@@ -1675,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 {
@@ -1727,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",
-            vec![entity! {
+            &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/postgres/tests/relational_bytes.rs b/store/test-store/tests/postgres/relational_bytes.rs
similarity index 51%
rename from store/postgres/tests/relational_bytes.rs
rename to store/test-store/tests/postgres/relational_bytes.rs
index 9c2c70d7e9f..1d608114eac 100644
--- a/store/postgres/tests/relational_bytes.rs
+++ b/store/test-store/tests/postgres/relational_bytes.rs
@@ -1,26 +1,25 @@
 //! Test relational schemas that use `Bytes` to store ids
-use diesel::connection::SimpleConnection as _;
-use diesel::pg::PgConnection;
-use graph::components::store::EntityKey;
+use diesel_async::SimpleAsyncConnection;
+
+use graph::components::store::write::RowGroup;
 use graph::data::store::scalar;
 use graph::data_source::CausalityRegion;
-use graph::prelude::EntityQuery;
-use graph_mock::MockMetricsRegistry;
+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::borrow::Cow;
 use std::collections::BTreeSet;
 use std::str::FromStr;
 use std::{collections::BTreeMap, sync::Arc};
 
+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, Schema, StopwatchMetrics,
-    Value, WindowAttribute, BLOCK_NUMBER_MAX,
-};
-use graph::{
-    components::store::EntityType,
-    data::store::scalar::{BigDecimal, BigInt},
+    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,
@@ -39,90 +38,132 @@ const THINGS_GQL: &str = "
     }
 ";
 
-macro_rules! entity {
-    ($($name:ident: $value:expr,)*) => {
-        {
-            let mut result = ::graph::prelude::Entity::new();
-            $(
-                result.insert(stringify!($name).to_string(), Value::from($value));
-            )*
-            result
-        }
-    };
-    ($($name:ident: $value:expr),*) => {
-        entity! {$($name: $value,)*}
-    };
-}
-
 lazy_static! {
     static ref THINGS_SUBGRAPH_ID: DeploymentHash = DeploymentHash::new("things").unwrap();
-    static ref LARGE_INT: BigInt = BigInt::from(std::i64::MAX).pow(17);
+    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(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! {
+    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: EntityType = EntityType::from("Thing");
+    static ref THING_TYPE: EntityType = THINGS_SCHEMA.entity_type("Thing").unwrap();
     static ref MOCK_STOPWATCH: StopwatchMetrics = StopwatchMetrics::new(
         Logger::root(slog::Discard, o!()),
         THINGS_SUBGRAPH_ID.clone(),
         "test",
-        Arc::new(MockMetricsRegistry::new()),
+        Arc::new(MetricsRegistry::mock()),
+        "test_shard".to_string()
     );
 }
 
 /// 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");
 }
 
-fn insert_entity(conn: &PgConnection, layout: &Layout, entity_type: &str, entity: Entity) {
-    let key = EntityKey::data(entity_type.to_owned(), entity.id().unwrap());
+pub fn 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
+}
+
+pub fn row_group_insert(
+    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::insert(key, data, block), block)
+            .unwrap();
+    }
+    group
+}
+
+pub fn 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
+}
 
-    let entity_type = EntityType::from(entity_type);
-    let mut entities = vec![(&key, Cow::from(&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,
-            &entity_type,
-            entities.as_mut_slice(),
-            0,
-            &MOCK_STOPWATCH,
-        )
+        .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! {
+        entity! { layout.input_schema =>
             id: id,
-            name: name
+            name: name,
+            vid: vid,
         },
-    );
+    )
+    .await;
 }
 
-fn create_schema(conn: &PgConnection) -> Layout {
-    let schema = Schema::parse(THINGS_GQL, THINGS_SUBGRAPH_ID.clone()).unwrap();
+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(),
@@ -130,17 +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::new();
-    // merge has the sideffect of removing any attribute
-    // that is Value::Null
-    scrubbed.merge(entity.clone());
-    scrubbed
-}
-
 macro_rules! assert_entity_eq {
     ($left:expr, $right:expr) => {{
         let (left, right) = (&($left), &($right));
@@ -173,195 +207,198 @@ 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| {
+#[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).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 = layout.find(
-            conn,
-            &EntityKey::data(THING.as_str(), "bad"),
-            BLOCK_NUMBER_MAX,
-        );
+        let res = find(conn, layout, "bad").await;
         assert!(res.is_err());
         assert_eq!(
-            "store error: Odd number of digits",
+            "store error: can not convert `bad` to Id::Bytes: Odd number of digits",
             res.err().unwrap().to_string()
         );
 
         // We do not allow the `\x` prefix that Postgres uses
-        let res = layout.find(
-            conn,
-            &EntityKey::data(THING.as_str(), "\\xbadd"),
-            BLOCK_NUMBER_MAX,
-        );
+        let res = find(conn, layout, "\\xbadd").await;
         assert!(res.is_err());
         assert_eq!(
-            "store error: Invalid character \'\\\\\' at position 0",
+            "store error: can not convert `\\xbadd` to Id::Bytes: Invalid character '\\\\' at position 0",
             res.err().unwrap().to_string()
         );
 
         // Having the '0x' prefix is ok
-        let res = layout.find(
-            conn,
-            &EntityKey::data(THING.as_str(), "0xbadd"),
-            BLOCK_NUMBER_MAX,
-        );
+        let res = find(conn, layout, "0xbadd").await;
         assert!(res.is_ok());
 
         // Using non-hex characters is also bad
-        let res = layout.find(
-            conn,
-            &EntityKey::data(THING.as_str(), "nope"),
-            BLOCK_NUMBER_MAX,
-        );
+        let res = find(conn, layout, "nope").await;
         assert!(res.is_err());
         assert_eq!(
-            "store error: Invalid character \'n\' at position 0",
+            "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| {
+#[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)
+                .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 = layout
-            .find(conn, &EntityKey::data(THING.as_str(), ID), BLOCK_NUMBER_MAX)
-            .expect("Failed to read Thing[deadbeef]")
-            .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 = layout
-            .find(
-                conn,
-                &EntityKey::data(THING.as_str(), "badd"),
-                BLOCK_NUMBER_MAX,
-            )
-            .expect("Failed to read Thing[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();
-        id_map.insert(
-            (THING.clone(), CausalityRegion::ONCHAIN),
-            vec![ID.to_string(), ID2.to_string(), "badd".to_string()],
-        );
+        let ids = IdList::try_from_iter(
+            THING_TYPE.id_type().unwrap(),
+            vec![ID, ID2, "badd"]
+                .into_iter()
+                .map(|id| THING_TYPE.parse_id(id).unwrap()),
+        )
+        .unwrap();
+        id_map.insert((THING_TYPE.clone(), CausalityRegion::ONCHAIN), ids);
 
         let entities = layout
             .find_many(conn, &id_map, BLOCK_NUMBER_MAX)
+            .await
             .expect("Failed to read many things");
         assert_eq!(2, entities.len());
 
-        let id_key = EntityKey {
-            entity_id: ID.into(),
-            entity_type: THING.clone(),
-            causality_region: CausalityRegion::ONCHAIN,
-        };
-        let id2_key = EntityKey {
-            entity_id: ID2.into(),
-            entity_type: THING.clone(),
-            causality_region: CausalityRegion::ONCHAIN,
-        };
+        let id_key = THING_TYPE.parse_key(ID).unwrap();
+        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");
-        let key = EntityKey::data("Thing".to_owned(), entity.id().unwrap());
+        entity.set("name", "Moo").unwrap();
+        entity.set("vid", 1i64).unwrap();
+        let key = THING_TYPE.key(entity.id());
 
-        let entity_id = entity.id().unwrap();
+        let entity_id = entity.id();
         let entity_type = key.entity_type.clone();
-        let mut entities = vec![(&key, Cow::from(&entity))];
+        let entities = vec![(key, entity.clone())];
+        let group = row_group_update(&entity_type, 1, entities);
         layout
-            .update(conn, &entity_type, &mut entities, 1, &MOCK_STOPWATCH)
+            .update(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to update");
 
         let actual = layout
-            .find(
-                conn,
-                &EntityKey::data(THING.as_str(), entity_id),
-                BLOCK_NUMBER_MAX,
-            )
+            .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);
-        insert_entity(conn, layout, "Thing", two);
+        two.set("id", TWO_ID).unwrap();
+        two.set("vid", 1i64).unwrap();
+        insert_entity(conn, layout, "Thing", two).await;
 
         // Delete where nothing is getting deleted
-        let key = EntityKey::data("Thing".to_owned(), "ffff".to_owned());
+        let key = THING_TYPE.parse_key("ffff").unwrap();
         let entity_type = key.entity_type.clone();
-        let mut entity_keys = vec![key.entity_id.as_str()];
+        let mut entity_keys = vec![key.clone()];
+        let group = row_group_delete(&entity_type, 1, entity_keys.clone());
         let count = layout
-            .delete(conn, &entity_type, &entity_keys, 1, &MOCK_STOPWATCH)
+            .delete(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to delete");
         assert_eq!(0, count);
 
         // Delete entity two
         entity_keys
             .get_mut(0)
-            .map(|key| *key = TWO_ID)
+            .map(|key| key.entity_id = entity_type.parse_id(TWO_ID).unwrap())
             .expect("Failed to update entity types");
+        let group = row_group_delete(&entity_type, 1, entity_keys);
         let count = layout
-            .delete(conn, &entity_type, &entity_keys, 1, &MOCK_STOPWATCH)
+            .delete(conn, &group, &MOCK_STOPWATCH)
+            .await
             .expect("Failed to delete");
         assert_eq!(1, count);
-    });
+    })
+    .await;
 }
 
 //
@@ -382,158 +419,174 @@ const GRANDCHILD2: &str = "0xfafa02";
 ///     +- child2
 ///          +- grandchild2
 ///
-fn make_thing_tree(conn: &PgConnection, layout: &Layout) -> (Entity, Entity, Entity) {
-    let root = 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! {
+    let child1 = entity! { layout.input_schema =>
         id: CHILD1,
         name: "child1",
         parent: "dead00",
-        children: vec![GRANDCHILD1]
+        children: vec![GRANDCHILD1],
+        vid: 1i64,
     };
-    let child2 = entity! {
+    let child2 = entity! { layout.input_schema =>
         id: CHILD2,
         name: "child2",
         parent: "dead00",
-        children: vec![GRANDCHILD1]
+        children: vec![GRANDCHILD1],
+        vid: 2i64,
     };
-    let grand_child1 = entity! {
+    let grand_child1 = entity! { layout.input_schema =>
         id: GRANDCHILD1,
         name: "grandchild1",
-        parent: CHILD1
+        parent: CHILD1,
+        vid: 3i64,
     };
-    let grand_child2 = entity! {
+    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()
-            .map(|e| e.id().expect("entities have an id"))
+            .map(|e| e.id().to_string())
             .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.clone(), AttributeNames::All)]);
-        let things = fetch(conn, layout, coll);
+        let coll = EntityCollection::All(vec![(THING_TYPE.clone(), AttributeNames::All)]);
+        let things = fetch(conn, layout, coll).await;
         assert_eq!(vec![CHILD1, CHILD2, ROOT, GRANDCHILD1, GRANDCHILD2], things);
 
         // EntityCollection::Window, type A, many
         //   things(where: { children_contains: [CHILD1] }) { id }
         let coll = EntityCollection::Window(vec![EntityWindow {
-            child_type: THING.clone(),
-            ids: vec![CHILD1.to_owned()],
+            child_type: THING_TYPE.clone(),
+            ids: THING_TYPE.parse_ids(vec![CHILD1]).unwrap(),
             link: EntityLink::Direct(
                 WindowAttribute::List("children".to_string()),
                 ChildMultiplicity::Many,
             ),
             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
         //   things(where: { children_contains: [GRANDCHILD1, GRANDCHILD2] }) { id }
         let coll = EntityCollection::Window(vec![EntityWindow {
-            child_type: THING.clone(),
-            ids: vec![GRANDCHILD1.to_owned(), GRANDCHILD2.to_owned()],
+            child_type: THING_TYPE.clone(),
+            ids: THING_TYPE
+                .parse_ids(vec![GRANDCHILD1, GRANDCHILD2])
+                .unwrap(),
             link: EntityLink::Direct(
                 WindowAttribute::List("children".to_string()),
                 ChildMultiplicity::Single,
             ),
             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
         //   things(where: { parent: [ROOT] }) { id }
         let coll = EntityCollection::Window(vec![EntityWindow {
-            child_type: THING.clone(),
-            ids: vec![ROOT.to_owned()],
+            child_type: THING_TYPE.clone(),
+            ids: THING_TYPE.parse_ids(vec![ROOT]).unwrap(),
             link: EntityLink::Direct(
                 WindowAttribute::Scalar("parent".to_string()),
                 ChildMultiplicity::Many,
             ),
             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
         //   things(where: { parent: [CHILD1, CHILD2] }) { id }
         let coll = EntityCollection::Window(vec![EntityWindow {
-            child_type: THING.clone(),
-            ids: vec![CHILD1.to_owned(), CHILD2.to_owned()],
+            child_type: THING_TYPE.clone(),
+            ids: THING_TYPE.parse_ids(vec![CHILD1, CHILD2]).unwrap(),
             link: EntityLink::Direct(
                 WindowAttribute::Scalar("parent".to_string()),
                 ChildMultiplicity::Single,
             ),
             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
         //   things { children { id } }
         // This is the inner 'children' query
         let coll = EntityCollection::Window(vec![EntityWindow {
-            child_type: THING.clone(),
-            ids: vec![ROOT.to_owned()],
+            child_type: THING_TYPE.clone(),
+            ids: THING_TYPE.parse_ids(vec![ROOT]).unwrap(),
             link: EntityLink::Parent(
-                THING.clone(),
-                ParentLink::List(vec![vec![CHILD1.to_owned(), CHILD2.to_owned()]]),
+                THING_TYPE.clone(),
+                ParentLink::List(vec![THING_TYPE.parse_ids(vec![CHILD1, CHILD2]).unwrap()]),
             ),
             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
         //   things { parent { id } }
         // This is the inner 'parent' query
         let coll = EntityCollection::Window(vec![EntityWindow {
-            child_type: THING.clone(),
-            ids: vec![CHILD1.to_owned(), CHILD2.to_owned()],
+            child_type: THING_TYPE.clone(),
+            ids: THING_TYPE.parse_ids(vec![CHILD1, CHILD2]).unwrap(),
             link: EntityLink::Parent(
-                THING.clone(),
-                ParentLink::Scalar(vec![ROOT.to_owned(), ROOT.to_owned()]),
+                THING_TYPE.clone(),
+                ParentLink::Scalar(THING_TYPE.parse_ids(vec![ROOT, ROOT]).unwrap()),
             ),
             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/postgres/tests/store.rs b/store/test-store/tests/postgres/store.rs
similarity index 70%
rename from store/postgres/tests/store.rs
rename to store/test-store/tests/postgres/store.rs
index 14d0e3b6115..f6365d292b3 100644
--- a/store/postgres/tests/store.rs
+++ b/store/test-store/tests/postgres/store.rs
@@ -1,31 +1,26 @@
+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_chain_ethereum::{Mapping, MappingABI};
-use graph_mock::MockMetricsRegistry;
+use graph::data_source::common::MappingABI;
+use graph::prelude::alloy::primitives::{Address, B256};
+use graph::schema::{EntityType, InputSchema};
+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::*;
 
-use graph::components::store::{DeploymentLocator, EntityKey, WritableStore};
+use graph::components::store::{DeploymentLocator, ReadStore, WritableStore};
 use graph::data::subgraph::*;
-use graph::prelude::*;
 use graph::{
     blockchain::DataSource,
-    components::store::{
-        BlockStore as _, EntityFilter, EntityOrder, EntityQuery, EntityType, 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 {
@@ -65,64 +60,67 @@ lazy_static! {
     static ref TEST_SUBGRAPH_ID_STRING: String = String::from("testsubgraph");
     static ref TEST_SUBGRAPH_ID: DeploymentHash =
         DeploymentHash::new(TEST_SUBGRAPH_ID_STRING.as_str()).unwrap();
-    static ref TEST_SUBGRAPH_SCHEMA: Schema =
-        Schema::parse(USER_GQL, TEST_SUBGRAPH_ID.clone()).expect("Failed to parse user schema");
+    static ref TEST_SUBGRAPH_SCHEMA: InputSchema =
+        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
     )
         .into();
+    static ref USER_TYPE: EntityType = TEST_SUBGRAPH_SCHEMA.entity_type(USER).unwrap();
+    static ref PERSON_TYPE: EntityType = TEST_SUBGRAPH_SCHEMA.entity_type("Person").unwrap();
 }
 
 /// Test harness for running database integration tests.
@@ -134,13 +132,13 @@ 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;
         let writable = store
             .subgraph_store()
-            .writable(LOGGER.clone(), deployment.id)
+            .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
             .await
             .expect("we can get a writable store");
 
@@ -158,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,
@@ -167,6 +165,7 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
         graft: None,
         templates: vec![],
         chain: PhantomData,
+        indexer_hints: None,
     };
 
     // Create SubgraphDeploymentEntity
@@ -182,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,
+        &USER_TYPE,
         "Johnton",
         "tonofjohn@email.com",
         67_i32,
         184.4,
         false,
         None,
+        0,
     );
     transact_entity_operations(
         &store,
@@ -205,23 +206,25 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
 
     let test_entity_2 = create_test_entity(
         "2",
-        USER,
+        &USER_TYPE,
         "Cindini",
         "dinici@email.com",
         43_i32,
         159.1,
         true,
         Some("red"),
+        1,
     );
     let test_entity_3_1 = create_test_entity(
         "3",
-        USER,
+        &USER_TYPE,
         "Shaqueeena",
         "queensha@email.com",
         28_i32,
         111.7,
         false,
         Some("blue"),
+        2,
     );
     transact_entity_operations(
         &store,
@@ -234,13 +237,14 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
 
     let test_entity_3_2 = create_test_entity(
         "3",
-        USER,
+        &USER_TYPE,
         "Shaqueeena",
         "teeko@email.com",
         28_i32,
         111.7,
         false,
         None,
+        3,
     );
     transact_and_wait(
         &store,
@@ -257,51 +261,39 @@ async fn insert_test_data(store: Arc<DieselSubgraphStore>) -> DeploymentLocator
 /// Creates a test entity.
 fn create_test_entity(
     id: &str,
-    entity_type: &str,
+    entity_type: &EntityType,
     name: &str,
     email: &str,
     age: i32,
     weight: f64,
     coffee: bool,
     favorite_color: Option<&str>,
+    vid: i64,
 ) -> EntityOperation {
-    let mut test_entity = Entity::new();
-
-    test_entity.insert("id".to_owned(), Value::String(id.to_owned()));
-    test_entity.insert("name".to_owned(), Value::String(name.to_owned()));
     let bin_name = scalar::Bytes::from_str(&hex::encode(name)).unwrap();
-    test_entity.insert("bin_name".to_owned(), Value::Bytes(bin_name));
-    test_entity.insert("email".to_owned(), Value::String(email.to_owned()));
-    test_entity.insert("age".to_owned(), Value::Int(age));
-    test_entity.insert(
-        "seconds_age".to_owned(),
-        Value::BigInt(BigInt::from(age) * 31557600.into()),
-    );
-    test_entity.insert("weight".to_owned(), Value::BigDecimal(weight.into()));
-    test_entity.insert("coffee".to_owned(), Value::Bool(coffee));
-    test_entity.insert(
-        "favorite_color".to_owned(),
-        favorite_color
-            .map(|s| Value::String(s.to_owned()))
-            .unwrap_or(Value::Null),
-    );
+    let test_entity = entity! { TEST_SUBGRAPH_SCHEMA =>
+        id: id,
+        name: name,
+        bin_name: bin_name,
+        email: email,
+        age: age,
+        seconds_age: Value::BigInt(BigInt::from(age) * 31557600.into()),
+        weight: Value::BigDecimal(weight.into()),
+        coffee: coffee,
+        favorite_color: favorite_color,
+        vid: vid,
+    };
 
     EntityOperation::Set {
-        key: EntityKey::data(entity_type.to_owned(), id.to_owned()),
+        key: entity_type.parse_key(id).unwrap(),
         data: 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,12 +302,12 @@ fn get_entity_count(store: Arc<DieselStore>, subgraph_id: &DeploymentHash) -> u6
 #[test]
 fn delete_entity() {
     run_test(|store, writable, deployment| async move {
-        let entity_key = EntityKey::data(USER.to_owned(), "3".to_owned());
+        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,
@@ -326,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,25 +332,23 @@ fn delete_entity() {
 #[test]
 fn get_entity_1() {
     run_test(|_, writable, _| async move {
-        let key = EntityKey::data(USER.to_owned(), "1".to_owned());
-        let result = writable.get(&key).unwrap();
-
-        let mut expected_entity = Entity::new();
-
-        expected_entity.insert("id".to_owned(), "1".into());
-        expected_entity.insert("name".to_owned(), "Johnton".into());
-        expected_entity.insert(
-            "bin_name".to_owned(),
-            Value::Bytes("Johnton".as_bytes().into()),
-        );
-        expected_entity.insert("email".to_owned(), "tonofjohn@email.com".into());
-        expected_entity.insert("age".to_owned(), Value::Int(67_i32));
-        expected_entity.insert(
-            "seconds_age".to_owned(),
-            Value::BigInt(BigInt::from(2114359200)),
-        );
-        expected_entity.insert("weight".to_owned(), Value::BigDecimal(184.4.into()));
-        expected_entity.insert("coffee".to_owned(), Value::Bool(false));
+        let schema = ReadStore::input_schema(&writable);
+
+        let key = USER_TYPE.parse_key("1").unwrap();
+        let result = writable.get(&key).await.unwrap();
+
+        let bin_name = Value::Bytes("Johnton".as_bytes().into());
+        let expected_entity = entity! { schema =>
+            id: "1",
+            name: "Johnton",
+            bin_name: bin_name,
+            email: "tonofjohn@email.com",
+            age: 67_i32,
+            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
 
         // Check that the expected entity was returned
@@ -367,25 +360,21 @@ fn get_entity_1() {
 #[test]
 fn get_entity_3() {
     run_test(|_, writable, _| async move {
-        let key = EntityKey::data(USER.to_owned(), "3".to_owned());
-        let result = writable.get(&key).unwrap();
-
-        let mut expected_entity = Entity::new();
-
-        expected_entity.insert("id".to_owned(), "3".into());
-        expected_entity.insert("name".to_owned(), "Shaqueeena".into());
-        expected_entity.insert(
-            "bin_name".to_owned(),
-            Value::Bytes("Shaqueeena".as_bytes().into()),
-        );
-        expected_entity.insert("email".to_owned(), "teeko@email.com".into());
-        expected_entity.insert("age".to_owned(), Value::Int(28_i32));
-        expected_entity.insert(
-            "seconds_age".to_owned(),
-            Value::BigInt(BigInt::from(883612800)),
-        );
-        expected_entity.insert("weight".to_owned(), Value::BigDecimal(111.7.into()));
-        expected_entity.insert("coffee".to_owned(), Value::Bool(false));
+        let schema = ReadStore::input_schema(&writable);
+        let key = USER_TYPE.parse_key("3").unwrap();
+        let result = writable.get(&key).await.unwrap();
+
+        let expected_entity = entity! { schema =>
+           id: "3",
+           name: "Shaqueeena",
+           bin_name: Value::Bytes("Shaqueeena".as_bytes().into()),
+           email: "teeko@email.com",
+           age: 28_i32,
+           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
 
         // Check that the expected entity was returned
@@ -396,18 +385,19 @@ fn get_entity_3() {
 #[test]
 fn insert_entity() {
     run_test(|store, writable, deployment| async move {
-        let entity_key = EntityKey::data(USER.to_owned(), "7".to_owned());
+        let entity_key = USER_TYPE.parse_key("7").unwrap();
         let test_entity = create_test_entity(
             "7",
-            USER,
+            &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,
@@ -416,27 +406,31 @@ 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();
     })
 }
 
 #[test]
 fn update_existing() {
     run_test(|store, writable, deployment| async move {
-        let entity_key = EntityKey::data(USER.to_owned(), "1".to_owned());
+        let entity_key = USER_TYPE.parse_key("1").unwrap();
 
         let op = create_test_entity(
             "1",
-            USER,
+            &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(),
@@ -444,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,
@@ -456,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") {
@@ -464,24 +461,23 @@ fn update_existing() {
             _ => unreachable!(),
         };
 
-        new_data.insert("bin_name".to_owned(), Value::Bytes(bin_name));
-        assert_eq!(writable.get(&entity_key).unwrap(), Some(new_data));
+        new_data.insert("bin_name", Value::Bytes(bin_name)).unwrap();
+        assert_eq!(writable.get(&entity_key).await.unwrap(), Some(new_data));
     })
 }
 
 #[test]
 fn partially_update_existing() {
     run_test(|store, writable, deployment| async move {
-        let entity_key = EntityKey::data(USER.to_owned(), "1".to_owned());
+        let entity_key = USER_TYPE.parse_key("1").unwrap();
+        let schema = writable.input_schema();
 
-        let partial_entity = Entity::from(vec![
-            ("id", Value::from("1")),
-            ("name", Value::from("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");
 
@@ -501,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");
 
@@ -526,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();
 
@@ -534,6 +531,7 @@ impl QueryChecker {
             .store
             .subgraph_store()
             .find(query)
+            .await
             .expect("store.find failed to execute query");
 
         let entity_ids: Vec<_> = entities
@@ -554,7 +552,7 @@ fn user_query() -> EntityQuery {
     EntityQuery::new(
         TEST_SUBGRAPH_ID.clone(),
         BLOCK_NUMBER_MAX,
-        EntityCollection::All(vec![(EntityType::from(USER), AttributeNames::All)]),
+        EntityCollection::All(vec![(USER_TYPE.clone(), AttributeNames::All)]),
     )
 }
 
@@ -584,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()
@@ -618,6 +622,7 @@ fn find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -627,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()
@@ -653,7 +662,8 @@ fn find() {
                         vec!["Shaqueeena".into()],
                     ))
                     .desc("name"),
-            );
+            )
+            .await;
 
         // Filter tests with float attributes
         QueryChecker::new(store.clone())
@@ -664,6 +674,7 @@ fn find() {
                     Value::BigDecimal(184.4.into()),
                 )),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
@@ -673,6 +684,7 @@ fn find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["1"],
                 user_query().filter(EntityFilter::GreaterThan(
@@ -680,6 +692,7 @@ fn find() {
                     Value::BigDecimal(160.0.into()),
                 )),
             )
+            .await
             .check(
                 vec!["2", "3"],
                 user_query()
@@ -689,6 +702,7 @@ fn find() {
                     ))
                     .asc("name"),
             )
+            .await
             .check(
                 vec!["3", "2"],
                 user_query()
@@ -698,6 +712,7 @@ fn find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -709,6 +724,7 @@ fn find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -722,6 +738,7 @@ fn find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["2"],
                 user_query()
@@ -734,7 +751,8 @@ fn find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
         // Filter tests with int attributes
         QueryChecker::new(store.clone())
             .check(
@@ -743,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(
@@ -756,6 +776,7 @@ fn find() {
                     Value::Int(43_i32),
                 )),
             )
+            .await
             .check(
                 vec!["2", "1"],
                 user_query()
@@ -765,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()
@@ -780,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()
@@ -794,6 +819,7 @@ fn find() {
                     .first(1)
                     .skip(1),
             )
+            .await
             .check(
                 vec!["1", "2"],
                 user_query()
@@ -804,6 +830,7 @@ fn find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["3"],
                 user_query()
@@ -813,7 +840,8 @@ fn find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
         // Filter tests with bool attributes
         QueryChecker::new(store.clone())
             .check(
@@ -822,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()
@@ -838,6 +868,7 @@ fn find() {
                     .desc("name")
                     .first(5),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -847,7 +878,8 @@ fn find() {
                     ))
                     .desc("name")
                     .first(5),
-            );
+            )
+            .await;
         // Misc filter tests
         QueryChecker::new(store)
             .check(
@@ -859,6 +891,7 @@ fn find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -868,6 +901,7 @@ fn find() {
                     ))
                     .desc("name"),
             )
+            .await
             .check(
                 vec!["3", "1"],
                 user_query()
@@ -877,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()
@@ -892,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()
@@ -908,82 +953,12 @@ fn find() {
                         EntityFilter::Equal("id".to_owned(), Value::from("2")),
                     ])]))
                     .asc("id"),
-            );
-    });
-}
-
-fn make_entity_change(entity_type: &str) -> EntityChange {
-    EntityChange::Data {
-        subgraph_id: TEST_SUBGRAPH_ID.clone(),
-        entity_type: EntityType::new(entity_type.to_owned()),
-    }
-}
-
-// 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: &str,
-) -> StoreEventStream<impl Stream<Item = Arc<StoreEvent>, Error = ()> + Send> {
-    let subscription =
-        SUBSCRIPTION_MANAGER.subscribe(FromIterator::from_iter([SubscriptionFilter::Entities(
-            subgraph.clone(),
-            EntityType::new(entity_type.to_owned()),
-        )]));
-
-    StoreEventStream::new(subscription)
+            .await;
+    });
 }
 
-async fn check_basic_revert(
-    store: Arc<DieselStore>,
-    expected: StoreEvent,
-    deployment: &DeploymentLocator,
-    entity_type: &str,
-) {
+async fn check_basic_revert(store: Arc<DieselStore>, deployment: &DeploymentLocator) {
     let this_query = user_query()
         .filter(EntityFilter::Equal(
             "name".to_owned(),
@@ -991,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);
 
@@ -1001,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
@@ -1014,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)]);
-
-        let count = get_entity_count(store.clone(), &deployment.hash);
-        check_basic_revert(store.clone(), expected, &deployment, USER).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
+        );
     })
 }
 
@@ -1040,7 +1014,7 @@ fn revert_block_with_delete() {
             .desc("name");
 
         // Delete entity with id=2
-        let del_key = EntityKey::data(USER.to_owned(), "2".to_owned());
+        let del_key = USER_TYPE.parse_key("2").unwrap();
 
         // Process deletion
         transact_and_wait(
@@ -1052,17 +1026,19 @@ fn revert_block_with_delete() {
         .await
         .unwrap();
 
-        let subscription = subscribe(&deployment.hash, USER);
-
         // 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
@@ -1073,27 +1049,23 @@ 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)]);
-
-        // The last event is the one for the reversion
-        check_events(subscription, vec![expected]).await
     })
 }
 
 #[test]
 fn revert_block_with_partial_update() {
     run_test(|store, writable, deployment| async move {
-        let entity_key = EntityKey::data(USER.to_owned(), "1".to_owned());
+        let entity_key = USER_TYPE.parse_key("1").unwrap();
+        let schema = writable.input_schema();
 
-        let partial_entity = Entity::from(vec![
-            ("id", Value::from("1")),
-            ("name", Value::from("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(
@@ -1102,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);
-
         // 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)]);
-
-        check_events(subscription, vec![expected]).await
     })
 }
 
@@ -1136,6 +1108,7 @@ fn mock_data_source() -> graph_chain_ethereum::DataSource {
         network: Some(String::from("mainnet")),
         address: Some(Address::from_str("0123123123012312312301231231230123123123").unwrap()),
         start_block: 0,
+        end_block: None,
         mapping: Mapping {
             kind: String::from("ethereum/events"),
             api_version: Version::parse("0.1.0").unwrap(),
@@ -1159,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(),
     }
@@ -1181,17 +1153,19 @@ fn mock_abi() -> MappingABI {
 fn revert_block_with_dynamic_data_source_operations() {
     run_test(|store, writable, deployment| async move {
         let subgraph_store = store.subgraph_store();
+        let schema = writable.input_schema();
 
         // Create operations to add a user
-        let user_key = EntityKey::data(USER.to_owned(), "1".to_owned());
-        let partial_entity = Entity::from(vec![
-            ("id", Value::from("1")),
-            ("name", Value::from("Johnny Boy")),
-            ("email", Value::Null),
-        ]);
+        let user_key = USER_TYPE.parse_key("1").unwrap();
+        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();
@@ -1217,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
         );
 
@@ -1232,14 +1210,16 @@ fn revert_block_with_dynamic_data_source_operations() {
             **loaded_dds[0].param.as_ref().unwrap()
         );
 
-        let subscription = subscribe(&deployment.hash, USER);
-
         // 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
         );
 
@@ -1249,236 +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: EntityType::new(USER.into()),
-                }]
-                .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 =
-            Schema::parse(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,
-        };
-
-        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);
-
-        // Add two entities to the store
-        let added_entities = vec![
-            (
-                "1".to_owned(),
-                Entity::from(vec![
-                    ("id", Value::from("1")),
-                    ("name", Value::from("Johnny Boy")),
-                ]),
-            ),
-            (
-                "2".to_owned(),
-                Entity::from(vec![
-                    ("id", Value::from("2")),
-                    ("name", Value::from("Tessa")),
-                ]),
-            ),
-        ];
-        transact_entity_operations(
-            &store.subgraph_store(),
-            &deployment,
-            TEST_BLOCK_1_PTR.clone(),
-            added_entities
-                .iter()
-                .map(|(id, data)| EntityOperation::Set {
-                    key: EntityKey::data(USER.to_owned(), id.clone()),
-                    data: data.clone(),
-                })
-                .collect(),
-        )
-        .await
-        .unwrap();
-
-        // Update an entity in the store
-        let updated_entity = Entity::from(vec![
-            ("id", Value::from("1")),
-            ("name", Value::from("Johnny")),
-        ]);
-        let update_op = EntityOperation::Set {
-            key: EntityKey::data(USER.to_owned(), "1".to_owned()),
-            data: updated_entity.clone(),
-        };
-
-        // Delete an entity in the store
-        let delete_op = EntityOperation::Remove {
-            key: EntityKey::data(USER.to_owned(), "2".to_owned()),
-        };
-
-        // Commit update & delete ops
-        transact_entity_operations(
-            &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 user_type = EntityType::new(USER.to_owned());
-        let expected = vec![
-            StoreEvent::new(vec![
-                EntityChange::Data {
-                    subgraph_id: subgraph_id.clone(),
-                    entity_type: user_type.clone(),
-                },
-                EntityChange::Data {
-                    subgraph_id: subgraph_id.clone(),
-                    entity_type: user_type.clone(),
-                },
-            ]),
-            StoreEvent::new(vec![
-                EntityChange::Data {
-                    subgraph_id: subgraph_id.clone(),
-                    entity_type: user_type.clone(),
-                },
-                EntityChange::Data {
-                    subgraph_id: subgraph_id.clone(),
-                    entity_type: user_type.clone(),
-                },
-            ]),
-        ];
-
-        check_events(subscription, expected).await
-    })
-}
-
-#[test]
-fn throttle_subscription_delivers() {
-    run_test(|store, _, deployment| async move {
-        let subscription = subscribe(&deployment.hash, USER)
-            .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,
-            "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)]);
-
-        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)
-            .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,
-            "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());
     })
 }
 
@@ -1488,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()
@@ -1528,17 +1279,23 @@ fn handle_large_string_with_index() {
     const ONE: &str = "large_string_one";
     const TWO: &str = "large_string_two";
 
-    fn make_insert_op(id: &str, name: &str) -> EntityModification {
-        let mut data = Entity::new();
-        data.set("id", id);
-        data.set(NAME, name);
+    fn make_insert_op(
+        id: &str,
+        name: &str,
+        schema: &InputSchema,
+        block: BlockNumber,
+        vid: i64,
+    ) -> EntityModification {
+        let data = entity! { schema => id: id, name: name, vid: vid };
 
-        let key = EntityKey::data(USER.to_owned(), id.to_owned());
+        let key = USER_TYPE.parse_key(id).unwrap();
 
-        EntityModification::Insert { key, data }
+        EntityModification::insert(key, data, block)
     }
 
     run_test(|store, writable, deployment| async move {
+        let schema = writable.input_schema();
+
         // We have to produce a massive string (1_000_000 chars) because
         // the repeated text compresses so well. This leads to an error
         // 'index row requires 11488 bytes, maximum size is 8191' if
@@ -1546,30 +1303,35 @@ fn handle_large_string_with_index() {
         let long_text = "Quo usque tandem".repeat(62500);
         let other_text = long_text.clone() + "X";
 
-        let metrics_registry = Arc::new(MockMetricsRegistry::new());
+        let metrics_registry = Arc::new(MetricsRegistry::mock());
         let stopwatch_metrics = StopwatchMetrics::new(
             Logger::root(slog::Discard, o!()),
             deployment.hash.clone(),
             "test",
             metrics_registry.clone(),
+            "test_shard".to_string(),
         );
 
+        let block = TEST_BLOCK_3_PTR.number;
         writable
             .transact_block_operations(
                 TEST_BLOCK_3_PTR.clone(),
+                BlockTime::for_test(&TEST_BLOCK_3_PTR),
                 FirehoseCursor::None,
                 vec![
-                    make_insert_op(ONE, &long_text),
-                    make_insert_op(TWO, &other_text),
+                    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(),
-                Vec::new(),
+                false,
+                false,
             )
             .await
             .expect("Failed to insert large text");
+
         writable.flush().await.unwrap();
 
         let query = user_query()
@@ -1580,16 +1342,16 @@ fn handle_large_string_with_index() {
             ))
             .asc(NAME);
 
-        let ids = store
+        let ids: Vec<_> = store
             .subgraph_store()
             .find(query)
+            .await
             .expect("Could not find entity")
             .iter()
             .map(|e| e.id())
-            .collect::<Result<Vec<_>, _>>()
-            .expect("Found entities without an id");
-
-        assert_eq!(vec![ONE], ids);
+            .collect();
+        let exp = USER_TYPE.parse_ids(vec![ONE]).unwrap().as_ids();
+        assert_eq!(exp, ids);
 
         // Make sure we check the full string and not just a prefix
         let mut prefix = long_text.clone();
@@ -1599,17 +1361,18 @@ fn handle_large_string_with_index() {
             .filter(EntityFilter::LessOrEqual(NAME.to_owned(), prefix.into()))
             .asc(NAME);
 
-        let ids = store
+        let ids: Vec<_> = store
             .subgraph_store()
             .find(query)
+            .await
             .expect("Could not find entity")
             .iter()
             .map(|e| e.id())
-            .collect::<Result<Vec<_>, _>>()
-            .expect("Found entities without an id");
+            .collect();
 
         // Users with name 'Cindini' and 'Johnton'
-        assert_eq!(vec!["2", "1"], ids);
+        let exp = USER_TYPE.parse_ids(vec!["2", "1"]).unwrap().as_ids();
+        assert_eq!(exp, ids);
     })
 }
 
@@ -1619,17 +1382,23 @@ fn handle_large_bytea_with_index() {
     const ONE: &str = "large_string_one";
     const TWO: &str = "large_string_two";
 
-    fn make_insert_op(id: &str, name: &[u8]) -> EntityModification {
-        let mut data = Entity::new();
-        data.set("id", id);
-        data.set(NAME, scalar::Bytes::from(name));
+    fn make_insert_op(
+        id: &str,
+        name: &[u8],
+        schema: &InputSchema,
+        block: BlockNumber,
+        vid: i64,
+    ) -> EntityModification {
+        let data = entity! { schema => id: id, bin_name: scalar::Bytes::from(name), vid: vid };
 
-        let key = EntityKey::data(USER.to_owned(), id.to_owned());
+        let key = USER_TYPE.parse_key(id).unwrap();
 
-        EntityModification::Insert { key, data }
+        EntityModification::insert(key, data, block)
     }
 
     run_test(|store, writable, deployment| async move {
+        let schema = writable.input_schema();
+
         // We have to produce a massive bytea (240_000 bytes) because the
         // repeated text compresses so well. This leads to an error 'index
         // row size 2784 exceeds btree version 4 maximum 2704' if used with
@@ -1642,27 +1411,31 @@ fn handle_large_bytea_with_index() {
         };
         let long_bytea = scalar::Bytes::from(long_bytea.as_slice());
 
-        let metrics_registry = Arc::new(MockMetricsRegistry::new());
+        let metrics_registry = Arc::new(MetricsRegistry::mock());
         let stopwatch_metrics = StopwatchMetrics::new(
             Logger::root(slog::Discard, o!()),
             deployment.hash.clone(),
             "test",
             metrics_registry.clone(),
+            "test_shard".to_string(),
         );
 
+        let block = TEST_BLOCK_3_PTR.number;
         writable
             .transact_block_operations(
                 TEST_BLOCK_3_PTR.clone(),
+                BlockTime::for_test(&TEST_BLOCK_3_PTR),
                 FirehoseCursor::None,
                 vec![
-                    make_insert_op(ONE, &long_bytea),
-                    make_insert_op(TWO, &other_bytea),
+                    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(),
-                Vec::new(),
+                false,
+                false,
             )
             .await
             .expect("Failed to insert large text");
@@ -1676,16 +1449,17 @@ fn handle_large_bytea_with_index() {
             ))
             .asc(NAME);
 
-        let ids = store
+        let ids: Vec<_> = store
             .subgraph_store()
             .find(query)
+            .await
             .expect("Could not find entity")
             .iter()
             .map(|e| e.id())
-            .collect::<Result<Vec<_>, _>>()
-            .expect("Found entities without an id");
+            .collect();
 
-        assert_eq!(vec![ONE], ids);
+        let exp = USER_TYPE.parse_ids(vec![ONE]).unwrap().as_ids();
+        assert_eq!(exp, ids);
 
         // Make sure we check the full string and not just a prefix
         let prefix = scalar::Bytes::from(&long_bytea.as_slice()[..64]);
@@ -1694,17 +1468,18 @@ fn handle_large_bytea_with_index() {
             .filter(EntityFilter::LessOrEqual(NAME.to_owned(), prefix.into()))
             .asc(NAME);
 
-        let ids = store
+        let ids: Vec<_> = store
             .subgraph_store()
             .find(query)
+            .await
             .expect("Could not find entity")
             .iter()
             .map(|e| e.id())
-            .collect::<Result<Vec<_>, _>>()
-            .expect("Found entities without an id");
+            .collect();
 
         // Users with name 'Cindini' and 'Johnton'
-        assert_eq!(vec!["2", "1"], ids);
+        let exp = USER_TYPE.parse_ids(vec!["2", "1"]).unwrap().as_ids();
+        assert_eq!(exp, ids);
     })
 }
 
@@ -1734,10 +1509,9 @@ impl WindowQuery {
             .map(|(child_type, column_names)| {
                 let attribute = WindowAttribute::Scalar("favorite_color".to_owned());
                 let link = EntityLink::Direct(attribute, ChildMultiplicity::Many);
-                let ids = vec!["red", "green", "yellow", "blue"]
-                    .into_iter()
-                    .map(String::from)
-                    .collect();
+                let ids = child_type
+                    .parse_ids(vec!["red", "green", "yellow", "blue"])
+                    .unwrap();
                 EntityWindow {
                     child_type,
                     ids,
@@ -1789,18 +1563,19 @@ impl WindowQuery {
     fn against_color_and_age(self) -> Self {
         let mut query = self.0;
         query.collection = EntityCollection::All(vec![
-            (EntityType::from(USER), AttributeNames::All),
-            (EntityType::from("Person"), AttributeNames::All),
+            (USER_TYPE.clone(), AttributeNames::All),
+            (PERSON_TYPE.clone(), AttributeNames::All),
         ]);
         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") {
@@ -1819,37 +1594,41 @@ impl WindowQuery {
 
 #[test]
 fn window() {
-    fn make_color_end_age(entity_type: &str, id: &str, color: &str, age: i32) -> EntityOperation {
-        let mut entity = Entity::new();
+    fn make_color_and_age(
+        entity_type: &EntityType,
+        id: &str,
+        color: &str,
+        age: i32,
+        vid: i64,
+    ) -> EntityOperation {
+        let entity =
+            entity! { TEST_SUBGRAPH_SCHEMA => id: id, age: age, favorite_color: color, vid: vid };
 
-        entity.set("id", id.to_owned());
-        entity.set("age", age);
-        entity.set("favorite_color", color);
         EntityOperation::Set {
-            key: EntityKey::data(entity_type.to_owned(), id.to_owned()),
+            key: entity_type.parse_key(id).unwrap(),
             data: entity,
         }
     }
 
-    fn make_user(id: &str, color: &str, age: i32) -> EntityOperation {
-        make_color_end_age(USER, 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_end_age("Person", 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 {
@@ -1865,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)
@@ -1902,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()
@@ -1918,7 +1705,8 @@ fn window() {
             .expect(
                 vec!["10", "11", "2", "4", "5", "6", "7", "8", "9", "p2"],
                 "q9",
-            );
+            )
+            .await;
     });
 }
 
@@ -1934,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());
@@ -1964,13 +1753,16 @@ fn cleanup_cached_blocks() {
         block_store::set_chain(
             vec![&*GENESIS_BLOCK, &*BLOCK_ONE, &*BLOCK_TWO, &*BLOCK_THREE],
             NETWORK_NAME,
-        );
+        )
+        .await;
         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);
     })
@@ -1995,13 +1787,15 @@ fn parse_timestamp() {
                 &*BLOCK_THREE_TIMESTAMP,
             ],
             NETWORK_NAME,
-        );
+        )
+        .await;
         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")
@@ -2028,13 +1822,15 @@ fn parse_timestamp_firehose() {
                 &*BLOCK_THREE_TIMESTAMP_FIREHOSE,
             ],
             NETWORK_NAME,
-        );
+        )
+        .await;
         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")
@@ -2061,19 +1857,21 @@ fn parse_null_timestamp() {
                 &*BLOCK_THREE_NO_TIMESTAMP,
             ],
             NETWORK_NAME,
-        );
+        )
+        .await;
         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]
@@ -2083,16 +1881,18 @@ fn reorg_tracking() {
         deployment: &DeploymentLocator,
         age: i32,
         block: &BlockPtr,
+        vid: i64,
     ) {
         let test_entity_1 = create_test_entity(
             "1",
-            USER,
+            &USER_TYPE,
             "Johnton",
             "tonofjohn@email.com",
             age,
             184.4,
             false,
             None,
+            vid,
         );
         transact_and_wait(store, deployment, block.clone(), vec![test_entity_1])
             .await
@@ -2143,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/postgres/tests/subgraph.rs b/store/test-store/tests/postgres/subgraph.rs
similarity index 63%
rename from store/postgres/tests/subgraph.rs
rename to store/test-store/tests/postgres/subgraph.rs
index a2ea1a5932f..5dd3c273160 100644
--- a/store/postgres/tests/subgraph.rs
+++ b/store/test-store/tests/postgres/subgraph.rs
@@ -3,24 +3,23 @@ use graph::{
         server::index_node::VersionInfo,
         store::{DeploymentId, DeploymentLocator, StatusStore},
     },
-    data::query::QueryTarget,
-    data::subgraph::schema::SubgraphHealth,
-    data::subgraph::schema::{DeploymentCreate, SubgraphError},
-    prelude::BlockPtr,
-    prelude::EntityChange,
-    prelude::EntityChangeOperation,
-    prelude::QueryStoreManager,
-    prelude::Schema,
-    prelude::SubgraphManifest,
-    prelude::SubgraphName,
-    prelude::SubgraphVersionSwitchingMode,
-    prelude::UnfailOutcome,
-    prelude::{futures03, StoreEvent},
-    prelude::{CheapClone, DeploymentHash, NodeId, SubgraphStore as _},
+    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,
+    },
+    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::*;
 
@@ -31,31 +30,54 @@ 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
+    }
+
+    type User2 @entity(immutable: true) {
+        id: Bytes!,
+        name: String
     }
-}
 
-fn unassigned(deployment: &DeploymentLocator) -> EntityChange {
-    EntityChange::Assignment {
-        deployment: deployment.clone(),
-        operation: EntityChangeOperation::Removed,
+    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()
+}
+
+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 {
     store
         .subgraph_store()
-        .writable(LOGGER.clone(), deployment_id)
+        .writable(LOGGER.clone(), deployment_id, Arc::new(Vec::new()))
         .await
         .expect("can get writable")
         .block_ptr()
@@ -66,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())
     }
@@ -82,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
@@ -99,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);
         }
@@ -112,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 = Schema::parse(SUBGRAPH_GQL, id.clone()).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,
@@ -146,11 +183,12 @@ fn create_subgraph() {
             graft: None,
             templates: vec![],
             chain: PhantomData,
+            indexer_hints: None,
         };
         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,
@@ -160,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())
@@ -169,22 +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))
+    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()
+            .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;
@@ -192,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;
@@ -244,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());
 
@@ -307,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());
     })
@@ -335,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
@@ -351,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()
@@ -368,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();
@@ -376,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();
@@ -384,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());
 
@@ -402,6 +461,7 @@ fn status() {
                 "notASubgraph".to_string(),
                 true,
             ))
+            .await
             .unwrap();
         assert_eq!(0, infos.len());
 
@@ -416,16 +476,17 @@ fn status() {
 
         store
             .subgraph_store()
-            .writable(LOGGER.clone(), deployment.id)
+            .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
             .await
             .expect("can get writable")
             .fail_subgraph(error)
             .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();
@@ -444,8 +505,8 @@ fn version_info() {
 
     async fn setup() -> DeploymentLocator {
         let id = DeploymentHash::new(NAME).unwrap();
-        remove_subgraphs();
-        block_store::set_chain(vec![], NETWORK_NAME);
+        remove_subgraphs().await;
+        block_store::set_chain(vec![], NETWORK_NAME).await;
         create_test_subgraph(&id, SUBGRAPH_GQL).await
     }
 
@@ -460,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()
@@ -472,7 +533,7 @@ fn version_info() {
             Some("repo for versionInfoSubgraph"),
             vi.repository.as_deref()
         );
-        assert_eq!(NAME, vi.schema.id.as_str());
+        assert_eq!(NAME, vi.schema.id().as_str());
         assert_eq!(Some(1), vi.latest_ethereum_block_number);
         assert_eq!(NETWORK_NAME, vi.network.as_str());
         // We set the head for the network to null in the test framework
@@ -480,16 +541,70 @@ fn version_info() {
     })
 }
 
+#[test]
+fn subgraph_features() {
+    run_test_sequentially(|_store| async move {
+        const NAME: &str = "subgraph_features";
+        let id = DeploymentHash::new(NAME).unwrap();
+
+        remove_subgraphs().await;
+        block_store::set_chain(vec![], NETWORK_NAME).await;
+        create_test_subgraph_with_features(&id, SUBGRAPH_FEATURES_GQL).await;
+
+        let DeploymentFeatures {
+            id: subgraph_id,
+            spec_version,
+            api_version,
+            features,
+            data_source_kinds,
+            network,
+            handler_kinds,
+            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.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(),
+            ],
+            features
+        );
+        assert_eq!(1, data_source_kinds.len());
+        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).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());
+    })
+}
+
 #[test]
 fn subgraph_error() {
     test_store::run_test_sequentially(|store| async move {
         let subgraph_id = DeploymentHash::new("testSubgraph").unwrap();
         let deployment =
-            test_store::create_test_subgraph(&subgraph_id, "type Foo { id: ID! }").await;
+            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 {
@@ -500,12 +615,12 @@ fn subgraph_error() {
             deterministic: false,
         };
 
-        assert!(count() == 0);
+        assert!(count().await == 0);
 
-        transact_errors(&store, &deployment, BLOCKS[1].clone(), vec![error])
+        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(),
@@ -516,10 +631,10 @@ fn subgraph_error() {
         };
 
         // Inserting the same error is allowed but ignored.
-        transact_errors(&store, &deployment, BLOCKS[2].clone(), vec![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(),
@@ -529,12 +644,70 @@ fn subgraph_error() {
             deterministic: false,
         };
 
-        transact_errors(&store, &deployment, BLOCKS[3].clone(), vec![error2])
+        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;
+    })
+}
+
+#[test]
+fn subgraph_non_fatal_error() {
+    test_store::run_test_sequentially(|store| async move {
+        let subgraph_store = store.subgraph_store();
+        let subgraph_id = DeploymentHash::new("subgraph_non_fatal_error").unwrap();
+        let deployment =
+            test_store::create_test_subgraph(&subgraph_id, "type Foo @entity { id: ID! }").await;
+
+        let count = async || -> usize {
+            let store = store.subgraph_store();
+            let count = store.error_count(&subgraph_id).await.unwrap();
+            println!("count: {}", count);
+            count
+        };
+
+        let error = SubgraphError {
+            subgraph_id: subgraph_id.clone(),
+            message: "test".to_string(),
+            block_ptr: Some(BLOCKS[1].clone()),
+            handler: None,
+            deterministic: true,
+        };
+
+        assert!(count().await == 0);
+
+        transact_errors(&store, &deployment, BLOCKS[1].clone(), vec![error], true)
+            .await
+            .unwrap();
+        assert!(count().await == 1);
+
+        let info = subgraph_store.status_for_id(deployment.id).await;
+
+        assert!(info.non_fatal_errors.len() == 1);
+        assert!(info.health == SubgraphHealth::Unhealthy);
+
+        let error2 = SubgraphError {
+            subgraph_id: subgraph_id.clone(),
+            message: "test2".to_string(),
+            block_ptr: None,
+            handler: None,
+            deterministic: false,
+        };
+
+        // Inserting non deterministic errors will increase error count but not count of non fatal errors
+        transact_errors(&store, &deployment, BLOCKS[2].clone(), vec![error2], false)
+            .await
+            .unwrap();
+        assert!(count().await == 2);
+
+        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).await;
     })
 }
 
@@ -542,17 +715,17 @@ fn subgraph_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();
 
@@ -576,26 +749,23 @@ fn fatal_vs_non_fatal() {
 
         store
             .subgraph_store()
-            .writable(LOGGER.clone(), deployment.id)
+            .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
             .await
             .expect("can get writable")
             .fail_subgraph(error())
             .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();
 
-        transact_errors(&store, &deployment, BLOCKS[1].clone(), vec![error()])
+        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));
     })
 }
 
@@ -605,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
     }
 
@@ -613,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();
 
@@ -631,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.
@@ -651,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 {
@@ -670,7 +836,7 @@ fn fail_unfail_deterministic_error() {
 
         let writable = store
             .subgraph_store()
-            .writable(LOGGER.clone(), deployment.id)
+            .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
             .await
             .expect("can get writable");
 
@@ -678,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.
@@ -695,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;
     })
 }
 
@@ -714,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.
@@ -737,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.
@@ -754,15 +916,15 @@ 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
             .subgraph_store()
-            .writable(LOGGER.clone(), deployment.id)
+            .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
             .await
             .expect("can get writable");
 
@@ -774,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 {
@@ -792,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.
@@ -807,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 {
@@ -834,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;
     })
 }
 
@@ -850,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.
@@ -873,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 {
@@ -889,7 +1051,7 @@ fn fail_unfail_non_deterministic_error() {
 
         let writable = store
             .subgraph_store()
-            .writable(LOGGER.clone(), deployment.id)
+            .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
             .await
             .expect("can get writable");
 
@@ -897,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.
@@ -914,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;
     })
 }
 
@@ -941,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.
@@ -964,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.
@@ -981,27 +1146,30 @@ 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
             .subgraph_store()
-            .writable(LOGGER.clone(), deployment.id)
+            .writable(LOGGER.clone(), deployment.id, Arc::new(Vec::new()))
             .await
             .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 {
@@ -1016,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 {
@@ -1044,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
new file mode 100644
index 00000000000..7c17e8f201f
--- /dev/null
+++ b/store/test-store/tests/postgres/writable.rs
@@ -0,0 +1,528 @@
+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::{BTreeMap, BTreeSet};
+use std::future::Future;
+use std::marker::PhantomData;
+use std::ops::Range;
+use test_store::*;
+
+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};
+
+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");
+    static ref TEST_SUBGRAPH_ID: DeploymentHash =
+        DeploymentHash::new(TEST_SUBGRAPH_ID_STRING.as_str()).unwrap();
+    static ref TEST_SUBGRAPH_SCHEMA: InputSchema =
+        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.
+///
+/// Create a new empty subgraph with schema `SCHEMA_GQL`
+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, 3, 0),
+        features: Default::default(),
+        description: None,
+        repository: None,
+        schema: TEST_SUBGRAPH_SCHEMA.clone(),
+        data_sources: vec![],
+        graft: None,
+        templates: vec![],
+        chain: PhantomData,
+        indexer_hints: None,
+    };
+
+    // Create SubgraphDeploymentEntity
+    let deployment = DeploymentCreate::new(String::new(), &manifest, None);
+    let name = SubgraphName::new("test/writable").unwrap();
+    let node_id = NodeId::new("test").unwrap();
+
+    store
+        .create_subgraph_deployment(
+            name,
+            &TEST_SUBGRAPH_SCHEMA,
+            deployment,
+            node_id,
+            NETWORK_NAME.to_string(),
+            SubgraphVersionSwitchingMode::Instant,
+        )
+        .await
+        .unwrap()
+}
+
+/// Test harness for running database integration tests.
+fn run_test<R, F>(test: F)
+where
+    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_subgraphs().await;
+
+        // Seed database with test data
+        let deployment = insert_test_data(subgraph_store.clone()).await;
+        let writable = store
+            .subgraph_store()
+            .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, sourceable, deployment).await;
+    });
+}
+
+fn block_pointer(number: u8) -> BlockPtr {
+    let hash = B256::from([number; 32]);
+    BlockPtr::from((hash, number as BlockNumber))
+}
+
+fn count_key(id: &str) -> EntityKey {
+    COUNTER_TYPE.parse_key(id).unwrap()
+}
+
+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,
+        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 mut ops = if immutable_only {
+        vec![]
+    } else {
+        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();
+}
+
+async fn pause_writer(deployment: &DeploymentLocator) {
+    flush(deployment).await.unwrap();
+    writable::allow_steps(deployment, 0).await;
+}
+
+/// Test that looking up entities when several changes to the same entity
+/// are queued works. When `batch` is true, the changes all reside in one
+/// batch. If it is false, each change is in its own batch.
+///
+/// `read_count` lets us look up entities in different ways to exercise
+/// different methods in `WritableStore`
+fn get_with_pending<R, F>(batch: bool, read_count: F)
+where
+    F: Send + Fn(Arc<dyn WritableStore>) -> R + Sync + 'static,
+    R: Future<Output = i32> + Send + 'static,
+{
+    run_test(move |store, writable, _, deployment| async move {
+        let subgraph_store = store.subgraph_store();
+
+        let read_count = || read_count(writable.cheap_clone());
+
+        if !batch {
+            writable.deployment_synced(block_pointer(0)).await.unwrap();
+        }
+
+        for count in 1..4 {
+            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, count, false).await;
+        }
+        assert_eq!(6, read_count().await);
+
+        writable.flush().await.unwrap();
+        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, count, false).await;
+        }
+        writable
+            .revert_block_operations(block_pointer(2), FirehoseCursor::None)
+            .await
+            .unwrap();
+
+        assert_eq!(2, read_count().await);
+
+        writable.flush().await.unwrap();
+        assert_eq!(2, read_count().await);
+    })
+}
+
+/// Get the count using `WritableStore::get_many`
+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)
+        .await
+        .unwrap()
+        .get(&key)
+        .unwrap()
+        .clone();
+    counter.get("count").unwrap().as_int().unwrap()
+}
+
+/// Get the count using `WritableStore::get`
+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()
+}
+
+async fn count_get_derived(writable: Arc<dyn WritableStore>) -> i32 {
+    let key = count_key("1");
+    let query = DerivedEntityQuery {
+        entity_type: key.entity_type.clone(),
+        entity_field: Word::from("id"),
+        value: key.entity_id.clone(),
+        causality_region: CausalityRegion::ONCHAIN,
+    };
+    let map = writable.get_derived(&query).await.unwrap();
+    let counter = map.get(&key).unwrap();
+    counter.get("count").unwrap().as_int().unwrap()
+}
+
+#[test]
+fn get_batch() {
+    get_with_pending(true, count_get);
+}
+
+#[test]
+fn get_nobatch() {
+    get_with_pending(false, count_get);
+}
+
+#[test]
+fn get_many_batch() {
+    get_with_pending(true, count_get_many);
+}
+
+#[test]
+fn get_many_nobatch() {
+    get_with_pending(false, count_get_many);
+}
+
+#[test]
+fn get_derived_batch() {
+    get_with_pending(true, count_get_derived);
+}
+
+#[test]
+fn get_derived_nobatch() {
+    get_with_pending(false, count_get_derived);
+}
+
+#[test]
+fn restart() {
+    run_test(|store, writable, _, deployment| async move {
+        let subgraph_store = store.subgraph_store();
+        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", vid: 0i64},
+        }];
+        transact_entity_operations(
+            &subgraph_store,
+            &deployment,
+            block_pointer(1),
+            entity_ops.clone(),
+        )
+        .await
+        .unwrap();
+        // flush checks for errors and therefore fails
+        writable
+            .flush()
+            .await
+            .expect_err("writing with missing non-nullable field should fail");
+
+        // We now have a poisoned store. Restarting it gives us a new store
+        // that works again
+        let writable = writable.restart().await.unwrap().unwrap();
+        writable.flush().await.unwrap();
+
+        // Retry our write with correct data
+        let entity_ops = vec![EntityOperation::Set {
+            key: count_key("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
+        // `writable` directly
+        transact_entity_operations(
+            &subgraph_store,
+            &deployment,
+            block_pointer(1),
+            entity_ops.clone(),
+        )
+        .await
+        .unwrap();
+        // Look, no errors
+        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/tests/.gitignore b/tests/.gitignore
new file mode 100644
index 00000000000..b6f5b85637c
--- /dev/null
+++ b/tests/.gitignore
@@ -0,0 +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 09586768bd0..547466909a5 100644
--- a/tests/Cargo.toml
+++ b/tests/Cargo.toml
@@ -6,31 +6,27 @@ edition.workspace = true
 [dependencies]
 anyhow = "1.0"
 assert-json-diff = "2.0.2"
-async-stream = "0.3.4"
-bollard = "0.10"
-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-node = { path = "../node" }
 graph-core = { path = "../core" }
-graph-mock = { path = "../mock" }
 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.8"
-slog = { version = "2.7.0", features = ["release_max_level_trace", "max_level_trace"] }
-tokio = { version = "1.16.1", features = ["rt", "macros", "process"] }
-uuid = { version = "1.3.0", features = ["v4"] }
+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.69"
-bollard = "0.10"
-lazy_static = "1.4.0"
+anyhow = "1.0.102"
 tokio-stream = "0.1"
-serde_yaml = "0.8"
-cid = "0.10.1"
-graph-chain-near = { path = "../chain/near" }
+
+[lints]
+workspace = true
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 00000000000..c9ffd9b6a8e
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,67 @@
+# Full system tests
+
+This directory contains tests that run the full system. There are two tests
+currently: `tests/integration-tests.rs` and `tests/runner-tests.rs`.
+
+## Integration tests
+
+The tests require that an IPFS node, a Postgres database, and an Ethereum
+RPC client are already running on specific ports. For local testing, these
+services can be started using the `docker-compose.yml` file in this
+directory. The ports are defined in the `docker-compose.yml` file and in
+`src/config.rs`
+
+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`
+- `pnpm` must be installed and on the `PATH`
+
+Once these prerequisites are in place, the tests can be run using:
+
+```
+cargo test -p graph-tests --test integration_tests -- --nocapture
+```
+
+The test harness will clear out the database before each run so that it is
+possible to keep the same database running across multiple test runs.
+Similarly, test contracts will be deployed to the Ethereum client before
+each run unless they are already present from previous runs. By keeping the
+services running after the test run, it is possible to inspect the database
+and the other services to investigate test failures.
+
+The harness starts `graph-node` by itself; it also prints the command line
+that was used to start `graph-node`. That makes it possible to run
+`graph-node` again, for example, to query it, when a test has failed. The
+log output from `graph-node` can be found in the file
+`integration-tests/graph-node.log`.
+
+The `subgraph.yaml` file should not reference contracts by their address;
+instead they should reference them with `@<NAME>@`, for example,
+`@SimpleContract@`. The test harness replaces these placeholders with the
+actual contract addresses before deploying the subgraph.
+
+### Adding/changing test contracts
+
+All test contracts are in the `tests/contracts/src` directory. Compiled
+versions in `tests/contracts/out` are checked into git, too. When changes to
+the contracts are necessary, the contracts need to be recompiled by running
+`foundry build` in `tests/contracts`. For that, the tools from
+[Foundry](https://getfoundry.sh/) must be installed locally.
+
+When you change anything about the contract setup, you will also need to
+adjust the test data in `CONTRACTS` in `src/contract.rs`. On initial setup,
+the tests print the address of the deployed contracts to the console. You
+can copy these addresses into the `CONTRACTS` array.
+
+When you add a new contract note that contracts must be called the same as
+the file they are stored in: the contract stored in `src/FooContract.sol`
+must be declared as `contract FooContract` in the Solidity source.
+
+### Testing different version of Graph CLI
+
+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`.
+
+The integration tests runner will always run the binary/executable under `{TEST_DIR}/node_modules/.bin/graph`.
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/foundry.toml b/tests/contracts/foundry.toml
new file mode 100644
index 00000000000..25b918f9c9a
--- /dev/null
+++ b/tests/contracts/foundry.toml
@@ -0,0 +1,6 @@
+[profile.default]
+src = "src"
+out = "out"
+libs = ["lib"]
+
+# See more config options https://github.com/foundry-rs/foundry/blob/master/crates/config/README.md#all-options
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":"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","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
new file mode 100644
index 00000000000..bb294ec8664
--- /dev/null
+++ b/tests/contracts/out/LimitedContract.sol/LimitedContract.json
@@ -0,0 +1 @@
+{"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
new file mode 100644
index 00000000000..c0d7d2f52a0
--- /dev/null
+++ b/tests/contracts/out/OverloadedContract.sol/OverloadedContract.json
@@ -0,0 +1 @@
+{"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
new file mode 100644
index 00000000000..3fd74e0aa28
--- /dev/null
+++ b/tests/contracts/out/RevertingContract.sol/RevertingContract.json
@@ -0,0 +1 @@
+{"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
new file mode 100644
index 00000000000..21deecd6fe9
--- /dev/null
+++ b/tests/contracts/out/SimpleContract.sol/SimpleContract.json
@@ -0,0 +1 @@
+{"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/integration-tests/ganache-reverts/contracts/Contract.sol b/tests/contracts/src/LimitedContract.sol
similarity index 74%
rename from tests/integration-tests/ganache-reverts/contracts/Contract.sol
rename to tests/contracts/src/LimitedContract.sol
index 9fd9c531254..3fa999b07fe 100644
--- a/tests/integration-tests/ganache-reverts/contracts/Contract.sol
+++ b/tests/contracts/src/LimitedContract.sol
@@ -1,10 +1,10 @@
+// SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-
-contract Contract {
+contract LimitedContract {
     event Trigger();
 
-    constructor() public {
+    constructor() {
         emit Trigger();
     }
 
diff --git a/tests/contracts/src/OverloadedContract.sol b/tests/contracts/src/OverloadedContract.sol
new file mode 100644
index 00000000000..9ac87fbfaab
--- /dev/null
+++ b/tests/contracts/src/OverloadedContract.sol
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract OverloadedContract {
+    event Trigger();
+
+    constructor() {
+        emit Trigger();
+    }
+
+    function exampleFunction(
+        string memory
+    ) public pure returns (string memory) {
+        return "string -> string";
+    }
+
+    function exampleFunction(uint256) public pure returns (string memory) {
+        return "uint256 -> string";
+    }
+
+    function exampleFunction(bytes32) public pure returns (uint256) {
+        return 256;
+    }
+}
diff --git a/tests/contracts/src/RevertingContract.sol b/tests/contracts/src/RevertingContract.sol
new file mode 100644
index 00000000000..a6d1cb97e52
--- /dev/null
+++ b/tests/contracts/src/RevertingContract.sol
@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract RevertingContract {
+    event Trigger();
+
+    constructor() {
+        emit Trigger();
+    }
+
+    function inc(uint256 value) public pure returns (uint256) {
+        require(value < 10, "can only handle values < 10");
+        return value + 1;
+    }
+}
diff --git a/tests/contracts/src/SimpleContract.sol b/tests/contracts/src/SimpleContract.sol
new file mode 100644
index 00000000000..998688bba23
--- /dev/null
+++ b/tests/contracts/src/SimpleContract.sol
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+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);
+    }
+
+    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
new file mode 100644
index 00000000000..8bf5f4c62be
--- /dev/null
+++ b/tests/docker-compose.yml
@@ -0,0 +1,34 @@
+version: '3'
+services:
+  ipfs:
+    image: docker.io/ipfs/kubo:v0.34.1
+    ports:
+      - '127.0.0.1:3001:5001'
+  postgres:
+    image: postgres:14
+    ports:
+      - '127.0.0.1:3011:5432'
+    command:
+      [
+        "postgres",
+        "-cshared_preload_libraries=pg_stat_statements",
+        "-clog_statement=all"
+      ]
+    environment:
+      POSTGRES_USER: graph-node
+      POSTGRES_PASSWORD: let-me-in
+      POSTGRES_DB: graph-node
+      POSTGRES_INITDB_ARGS: "-E UTF8 --locale=C"
+  anvil:
+    # 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 --timestamp 1743944919 --mnemonic \"test test test test test test test test test test test junk\"'"
+
+# graph-node ports:
+#   json-rpc: 8020
+#   http:     8000
+#   index:    8030
+#   metrics:  8040
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 4fae4144853..00000000000
--- a/tests/integration-tests/api-version-v0-0-4/package.json
+++ /dev/null
@@ -1,25 +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"
-  },
-  "devDependencies": {
-    "@graphprotocol/graph-cli": "https://github.com/graphprotocol/graph-cli#v0.21.1",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#v0.21.1",
-    "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/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/abis/Contract.abi b/tests/integration-tests/block-handlers/abis/Contract.abi
new file mode 100644
index 00000000000..02da1a9e7f3
--- /dev/null
+++ b/tests/integration-tests/block-handlers/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/block-handlers/package.json b/tests/integration-tests/block-handlers/package.json
new file mode 100644
index 00000000000..1914ac70dcb
--- /dev/null
+++ b/tests/integration-tests/block-handlers/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "block-handlers",
+  "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.34.0"
+  }
+}
diff --git a/tests/integration-tests/block-handlers/schema.graphql b/tests/integration-tests/block-handlers/schema.graphql
new file mode 100644
index 00000000000..a9cab275269
--- /dev/null
+++ b/tests/integration-tests/block-handlers/schema.graphql
@@ -0,0 +1,27 @@
+type Foo @entity {
+  id: ID!
+  value: Int8!
+}
+
+type Initialize @entity {
+  id: ID!
+  block: BigInt!
+}
+
+type Block @entity {
+  id: ID!
+  number: BigInt!
+  hash: Bytes!
+}
+
+type BlockFromPollingHandler @entity {
+  id: ID!
+  number: BigInt!
+  hash: Bytes!
+}
+
+type BlockFromOtherPollingHandler @entity {
+  id: ID!
+  number: BigInt!
+  hash: Bytes!
+}
\ No newline at end of file
diff --git a/tests/integration-tests/block-handlers/src/mapping.ts b/tests/integration-tests/block-handlers/src/mapping.ts
new file mode 100644
index 00000000000..0104fea6632
--- /dev/null
+++ b/tests/integration-tests/block-handlers/src/mapping.ts
@@ -0,0 +1,80 @@
+import { Address, BigInt, ethereum, log } from '@graphprotocol/graph-ts';
+import { Contract, Trigger } from '../generated/Contract/Contract';
+import {
+  BlockFromOtherPollingHandler,
+  BlockFromPollingHandler,
+  Block,
+  Foo,
+  Initialize,
+} from '../generated/schema';
+import { ContractTemplate } from '../generated/templates';
+
+export function handleBlock(block: ethereum.Block): void {
+  log.info('handleBlock {}', [block.number.toString()]);
+  let blockEntity = new Block(block.number.toString());
+  blockEntity.number = block.number;
+  blockEntity.hash = block.hash;
+  blockEntity.save();
+
+  if (block.number == BigInt.fromI32(2)) {
+    ContractTemplate.create(
+      Address.fromString('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
+    );
+  }
+}
+
+export function handleBlockPolling(block: ethereum.Block): void {
+  log.info('handleBlockPolling {}', [block.number.toString()]);
+  let blockEntity = new BlockFromPollingHandler(block.number.toString());
+  blockEntity.number = block.number;
+  blockEntity.hash = block.hash;
+  blockEntity.save();
+}
+
+export function handleBlockPollingFromTemplate(block: ethereum.Block): void {
+  log.info('===> handleBlockPollingFromTemplate {}', [block.number.toString()]);
+  let blockEntity = new BlockFromOtherPollingHandler(block.number.toString());
+  blockEntity.number = block.number;
+  blockEntity.hash = block.hash;
+  blockEntity.save();
+}
+
+export function handleTrigger(event: Trigger): void {
+  // We set the value to 0 to test that the subgraph
+  // runs initialization handler before all other handlers
+  if (event.params.x == 1) {
+    let entity = Foo.load('initialize');
+
+    // If the intialization handler is called first
+    // this would set the value to -1 for Foo entity with id 0
+    // If it is not called first then the value would be 0
+    if (entity != null) {
+      entity.value = -1;
+      entity.id = 'initialize';
+      entity.save();
+    }
+  }
+
+  let obj = new Foo(event.params.x.toString());
+  obj.id = event.params.x.toString();
+  obj.value = event.params.x as i64;
+
+  obj.save();
+}
+
+export function initialize(block: ethereum.Block): void {
+  log.info('initialize called at block', [block.number.toString()]);
+  let entity = new Initialize(block.number.toString());
+  entity.id = block.number.toString();
+  entity.block = block.number;
+  entity.save();
+
+  // If initialization handler is called then this would set
+  // the value to 0 for Foo entity with id 0
+  // This is to test that initialization handler is called
+  // before all other handlers
+  let foo = new Foo('initialize');
+  foo.id = 'initialize';
+  foo.value = 0;
+  foo.save();
+}
diff --git a/tests/integration-tests/block-handlers/subgraph.yaml b/tests/integration-tests/block-handlers/subgraph.yaml
new file mode 100644
index 00000000000..622042b412f
--- /dev/null
+++ b/tests/integration-tests/block-handlers/subgraph.yaml
@@ -0,0 +1,72 @@
+specVersion: 0.0.8
+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.7
+      language: wasm/assemblyscript
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      entities:
+        - Call
+      eventHandlers:
+        - event: Trigger(uint16)
+          handler: handleTrigger
+      blockHandlers:
+        - handler: handleBlockPolling
+          filter:
+            kind: polling
+            every: 3
+        - handler: initialize
+          filter:
+            kind: once
+      file: ./src/mapping.ts
+  - 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
+templates:
+  - kind: ethereum/contract
+    name: ContractTemplate
+    network: test
+    source:
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - Gravatar
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlockPollingFromTemplate
+          filter:
+            kind: polling
+            every: 2
+      file: ./src/mapping.ts
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/contracts/Migrations.sol b/tests/integration-tests/ganache-reverts/contracts/Migrations.sol
deleted file mode 100644
index 71f0defaaa5..00000000000
--- a/tests/integration-tests/ganache-reverts/contracts/Migrations.sol
+++ /dev/null
@@ -1,24 +0,0 @@
-pragma solidity ^0.8.0;
-
-
-contract Migrations {
-    address public owner;
-    uint256 public last_completed_migration;
-
-    constructor() public {
-        owner = msg.sender;
-    }
-
-    modifier restricted() {
-        if (msg.sender == owner) _;
-    }
-
-    function setCompleted(uint256 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/integration-tests/ganache-reverts/migrations/1_initial_migration.js b/tests/integration-tests/ganache-reverts/migrations/1_initial_migration.js
deleted file mode 100644
index 1eb6f9daf69..00000000000
--- a/tests/integration-tests/ganache-reverts/migrations/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/integration-tests/ganache-reverts/migrations/2_deploy_contracts.js b/tests/integration-tests/ganache-reverts/migrations/2_deploy_contracts.js
deleted file mode 100644
index ffe0359c95a..00000000000
--- a/tests/integration-tests/ganache-reverts/migrations/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/integration-tests/ganache-reverts/package.json b/tests/integration-tests/ganache-reverts/package.json
deleted file mode 100644
index fdc5f9119d5..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": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main",
-    "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/ganache-reverts/test/test.js b/tests/integration-tests/ganache-reverts/test/test.js
deleted file mode 100644
index 2f3ad687970..00000000000
--- a/tests/integration-tests/ganache-reverts/test/test.js
+++ /dev/null
@@ -1,104 +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 httpPort = process.env.GRAPH_NODE_HTTP_PORT || 18000;
-const indexPort = process.env.GRAPH_NODE_INDEX_PORT || 18030;
-
-const fetchSubgraphs = createApolloFetch({
-  uri: `http://localhost:${indexPort}/graphql`
-})
-const fetchSubgraph = createApolloFetch({
-  uri: `http://localhost:${httpPort}/subgraphs/name/test/ganache-reverts`
-})
-
-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 } }`
-        })
-
-        if (
-          JSON.stringify(result) ===
-          JSON.stringify({ data: { indexingStatuses: [{ synced: true }] } })
-        ) {
-          resolve()
-        } 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`)
-
-    // Wait for the subgraph to be indexed
-    await waitForSubgraphToBeSynced()
-  })
-
-  it('all overloads of the contract function are called', async () => {
-    let result = await fetchSubgraph({
-      query: `{ calls(orderBy: id) { id reverted returnValue } }`
-    })
-
-    expect(result.errors).to.be.undefined
-    expect(result.data).to.deep.equal({
-      calls: [
-        {
-          id: '100',
-          reverted: true,
-          returnValue: null
-        },
-        {
-          id: '9',
-          reverted: false,
-          returnValue: '10'
-        }
-      ]
-    })
-  })
-})
diff --git a/tests/integration-tests/ganache-reverts/truffle.js b/tests/integration-tests/ganache-reverts/truffle.js
deleted file mode 100644
index b9e17f8c4b9..00000000000
--- a/tests/integration-tests/ganache-reverts/truffle.js
+++ /dev/null
@@ -1,20 +0,0 @@
-require("babel-register");
-require("babel-polyfill");
-
-module.exports = {
-  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/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 038d6f2cac2..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": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main",
-    "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/host-exports/src/mapping.ts b/tests/integration-tests/host-exports/src/mapping.ts
index 1e02d849132..65587293870 100644
--- a/tests/integration-tests/host-exports/src/mapping.ts
+++ b/tests/integration-tests/host-exports/src/mapping.ts
@@ -62,10 +62,10 @@ function testBigDecimal(): void {
   assert((bigInt & BigInt.fromI32(42)) == BigInt.fromI32(40));
 
   // Test big int left shift
-  assert(bigInt << 6 == BigInt.fromString("568888888888888832"));
+  assert(bigInt.leftShift(6) == BigInt.fromString("568888888888888832"));
 
   // Test big int right shift
-  assert(bigInt >> 6 == BigInt.fromString("138888888888888"));
+  assert(bigInt.rightShift(6) == BigInt.fromString("138888888888888"));
 }
 
 function testEthereumAbi(): void {
@@ -121,4 +121,4 @@ function ethereumAbiComplexCase(): void {
   assert(bigInt1.toBigInt() == decodedBigInt1, "uint256[0] ethereum encoded does not equal the decoded value");
   assert(bigInt2.toBigInt() == decodedBigInt2, "uint256[1] ethereum encoded does not equal the decoded value");
   assert(bool.toBoolean() == decodedBool, "boolean ethereum encoded does not equal the decoded value");
-}
+}
\ No newline at end of file
diff --git a/tests/integration-tests/host-exports/subgraph.yaml b/tests/integration-tests/host-exports/subgraph.yaml
index 09e3122864c..476496dcba0 100644
--- a/tests/integration-tests/host-exports/subgraph.yaml
+++ b/tests/integration-tests/host-exports/subgraph.yaml
@@ -1,4 +1,4 @@
-specVersion: 0.0.2
+specVersion: 0.0.4
 schema:
   file: ./schema.graphql
 dataSources:
@@ -6,11 +6,11 @@ dataSources:
     name: Contract
     network: test
     source:
-      address: "0xCfEB869F69431e42cdB54A4F4f105C19C080A601"
+      address: "@SimpleContract@"
       abi: Contract
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.5
+      apiVersion: 0.0.6
       language: wasm/assemblyscript
       abis:
         - name: Contract
diff --git a/tests/integration-tests/host-exports/test/test.js b/tests/integration-tests/host-exports/test/test.js
deleted file mode 100644
index fd0e2ee2257..00000000000
--- a/tests/integration-tests/host-exports/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/host-exports/truffle.js b/tests/integration-tests/host-exports/truffle.js
deleted file mode 100644
index e3957ea52e8..00000000000
--- a/tests/integration-tests/host-exports/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/int8/abis/Contract.abi b/tests/integration-tests/int8/abis/Contract.abi
new file mode 100644
index 00000000000..02da1a9e7f3
--- /dev/null
+++ b/tests/integration-tests/int8/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/int8/package.json b/tests/integration-tests/int8/package.json
new file mode 100644
index 00000000000..bd70d90c42f
--- /dev/null
+++ b/tests/integration-tests/int8/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "int8",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/int8 --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/int8/schema.graphql b/tests/integration-tests/int8/schema.graphql
new file mode 100644
index 00000000000..493c4ceef04
--- /dev/null
+++ b/tests/integration-tests/int8/schema.graphql
@@ -0,0 +1,4 @@
+type Foo @entity {
+  id: ID!
+  value: Int8!
+}
diff --git a/tests/integration-tests/int8/src/mapping.ts b/tests/integration-tests/int8/src/mapping.ts
new file mode 100644
index 00000000000..445d0fa20a1
--- /dev/null
+++ b/tests/integration-tests/int8/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 = i64.MAX_VALUE;
+  obj.save();
+
+  obj = <Foo>Foo.load("0");
+  assert(obj.value == i64.MAX_VALUE, "maybe invalid value");
+}
diff --git a/tests/integration-tests/int8/subgraph.yaml b/tests/integration-tests/int8/subgraph.yaml
new file mode 100644
index 00000000000..476496dcba0
--- /dev/null
+++ b/tests/integration-tests/int8/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/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 162a4dbd213..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": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main",
-    "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/non-fatal-errors/subgraph.yaml b/tests/integration-tests/non-fatal-errors/subgraph.yaml
index 1039ea79ae3..79d71847aa6 100644
--- a/tests/integration-tests/non-fatal-errors/subgraph.yaml
+++ b/tests/integration-tests/non-fatal-errors/subgraph.yaml
@@ -1,4 +1,4 @@
-specVersion: 0.0.2
+specVersion: 0.0.4
 schema:
   file: ./schema.graphql
 features:
@@ -8,11 +8,11 @@ dataSources:
     name: Success
     network: test
     source:
-      address: "0xCfEB869F69431e42cdB54A4F4f105C19C080A601"
+      address: "@SimpleContract@"
       abi: Contract
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.5
+      apiVersion: 0.0.6
       language: wasm/assemblyscript
       abis:
         - name: Contract
@@ -26,11 +26,11 @@ dataSources:
     name: Error
     network: test
     source:
-      address: "0xCfEB869F69431e42cdB54A4F4f105C19C080A601"
+      address: "@SimpleContract@"
       abi: Contract
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.5
+      apiVersion: 0.0.6
       language: wasm/assemblyscript
       abis:
         - name: Contract
@@ -48,7 +48,7 @@ templates:
       abi: Contract
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.5
+      apiVersion: 0.0.6
       language: wasm/assemblyscript
       abis:
         - name: Contract
diff --git a/tests/integration-tests/non-fatal-errors/test/test.js b/tests/integration-tests/non-fatal-errors/test/test.js
deleted file mode 100644
index 1d7a0e406ef..00000000000
--- a/tests/integration-tests/non-fatal-errors/test/test.js
+++ /dev/null
@@ -1,105 +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 httpPort = process.env.GRAPH_NODE_HTTP_PORT || 18000;
-const indexPort = process.env.GRAPH_NODE_INDEX_PORT || 18030;
-
-const fetchSubgraphs = createApolloFetch({
-  uri: `http://localhost:${indexPort}/graphql`,
-});
-const fetchSubgraph = createApolloFetch({
-  uri: `http://localhost:${httpPort}/subgraphs/name/test/non-fatal-errors`,
-});
-
-const exec = (cmd) => {
-  try {
-    return execSync(cmd, { cwd: srcDir, stdio: "inherit" });
-  } catch (e) {
-    throw new Error(`Failed to run command \`${cmd}\``);
-  }
-};
-
-const waitForSubgraphToBeUnhealthy = 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 } }`,
-        });
-
-        let health = result.data.indexingStatuses[0].health
-        if (health == "unhealthy") {
-          resolve();
-        } else if (health == "failed") {
-          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 be uhealthy`));
-        } 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();
-    await contract.emitTrigger(1);
-
-    // 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`);
-
-    // Wait for the subgraph to be indexed
-    await waitForSubgraphToBeUnhealthy();
-  });
-
-  it("only sucessful handler register changes", async () => {
-    let result = await fetchSubgraph({
-      query: `{ foos(orderBy: id, subgraphError: allow) { id } }`,
-    });
-
-    expect(result.errors).to.deep.equal([{
-      "message": "indexing_error"
-    }]);
-
-    // Importantly, "1" and "11" are not present because their handlers erroed.
-    expect(result.data).to.deep.equal({
-      foos: [
-        {
-          id: "0"
-        },
-        {
-          id: "00"
-        },
-      ],
-    });
-  });
-});
diff --git a/tests/integration-tests/non-fatal-errors/truffle.js b/tests/integration-tests/non-fatal-errors/truffle.js
deleted file mode 100644
index e3957ea52e8..00000000000
--- a/tests/integration-tests/non-fatal-errors/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/overloaded-contract-functions/contracts/Contract.sol b/tests/integration-tests/overloaded-contract-functions/contracts/Contract.sol
deleted file mode 100644
index 770db4bfba9..00000000000
--- a/tests/integration-tests/overloaded-contract-functions/contracts/Contract.sol
+++ /dev/null
@@ -1,21 +0,0 @@
-pragma solidity ^0.8.0;
-
-contract Contract {
-  event Trigger();
-
-  constructor() public {
-    emit Trigger();
-  }
-
-  function exampleFunction(string memory) public pure returns (string memory) {
-    return "string -> string";
-  }
-
-  function exampleFunction(uint256) public pure returns (string memory) {
-    return "uint256 -> string";
-  }
-
-  function exampleFunction(bytes32) public pure returns (uint256) {
-    return 256;
-  }
-}
diff --git a/tests/integration-tests/overloaded-contract-functions/contracts/Migrations.sol b/tests/integration-tests/overloaded-contract-functions/contracts/Migrations.sol
deleted file mode 100644
index 0b571c8e442..00000000000
--- a/tests/integration-tests/overloaded-contract-functions/contracts/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/integration-tests/overloaded-contract-functions/migrations/1_initial_migration.js b/tests/integration-tests/overloaded-contract-functions/migrations/1_initial_migration.js
deleted file mode 100644
index 1eb6f9daf69..00000000000
--- a/tests/integration-tests/overloaded-contract-functions/migrations/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/integration-tests/overloaded-contract-functions/migrations/2_deploy_contracts.js b/tests/integration-tests/overloaded-contract-functions/migrations/2_deploy_contracts.js
deleted file mode 100644
index ffe0359c95a..00000000000
--- a/tests/integration-tests/overloaded-contract-functions/migrations/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/integration-tests/overloaded-contract-functions/package.json b/tests/integration-tests/overloaded-contract-functions/package.json
deleted file mode 100644
index ac6c59b16db..00000000000
--- a/tests/integration-tests/overloaded-contract-functions/package.json
+++ /dev/null
@@ -1,25 +0,0 @@
-{
-  "name": "overloaded-contract-functions",
-  "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/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": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main",
-    "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/overloaded-contract-functions/test/test.js b/tests/integration-tests/overloaded-contract-functions/test/test.js
deleted file mode 100644
index 0b183c04974..00000000000
--- a/tests/integration-tests/overloaded-contract-functions/test/test.js
+++ /dev/null
@@ -1,107 +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 httpPort = process.env.GRAPH_NODE_HTTP_PORT || 18000;
-const indexPort = process.env.GRAPH_NODE_INDEX_PORT || 18030;
-
-const fetchSubgraphs = createApolloFetch({
-  uri: `http://localhost:${indexPort}/graphql`
-});
-const fetchSubgraph = createApolloFetch({
-  uri:
-    `http://localhost:${httpPort}/subgraphs/name/test/overloaded-contract-functions`
-});
-
-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 } }`
-        });
-
-        if (
-          JSON.stringify(result) ===
-          JSON.stringify({ data: { indexingStatuses: [{ synced: true }] } })
-        ) {
-          resolve();
-        } 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`);
-
-    // Wait for the subgraph to be indexed
-    await waitForSubgraphToBeSynced();
-  });
-
-  it("all overloads of the contract function are called", async () => {
-    let result = await fetchSubgraph({
-      query: `{ calls(orderBy: id) { id value } }`
-    });
-
-    expect(result.errors).to.be.undefined;
-    expect(result.data).to.deep.equal({
-      calls: [
-        {
-          id: "bytes32 -> uint256",
-          value: "256"
-        },
-        {
-          id: "string -> string",
-          value: "string -> string"
-        },
-        {
-          id: "uint256 -> string",
-          value: "uint256 -> string"
-        }
-      ]
-    });
-  });
-});
diff --git a/tests/integration-tests/overloaded-contract-functions/truffle.js b/tests/integration-tests/overloaded-contract-functions/truffle.js
deleted file mode 100644
index b9e17f8c4b9..00000000000
--- a/tests/integration-tests/overloaded-contract-functions/truffle.js
+++ /dev/null
@@ -1,20 +0,0 @@
-require("babel-register");
-require("babel-polyfill");
-
-module.exports = {
-  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/overloaded-contract-functions/abis/Contract.abi b/tests/integration-tests/overloaded-functions/abis/Contract.abi
similarity index 100%
rename from tests/integration-tests/overloaded-contract-functions/abis/Contract.abi
rename to tests/integration-tests/overloaded-functions/abis/Contract.abi
diff --git a/tests/integration-tests/overloaded-functions/package.json b/tests/integration-tests/overloaded-functions/package.json
new file mode 100644
index 00000000000..d00de20329c
--- /dev/null
+++ b/tests/integration-tests/overloaded-functions/package.json
@@ -0,0 +1,12 @@
+{
+  "name": "overloaded-contract-functions",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/overloaded-contract-functions --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/overloaded-contract-functions/schema.graphql b/tests/integration-tests/overloaded-functions/schema.graphql
similarity index 100%
rename from tests/integration-tests/overloaded-contract-functions/schema.graphql
rename to tests/integration-tests/overloaded-functions/schema.graphql
diff --git a/tests/integration-tests/overloaded-contract-functions/src/mapping.ts b/tests/integration-tests/overloaded-functions/src/mapping.ts
similarity index 100%
rename from tests/integration-tests/overloaded-contract-functions/src/mapping.ts
rename to tests/integration-tests/overloaded-functions/src/mapping.ts
diff --git a/tests/integration-tests/ganache-reverts/subgraph.yaml b/tests/integration-tests/overloaded-functions/subgraph.yaml
similarity index 80%
rename from tests/integration-tests/ganache-reverts/subgraph.yaml
rename to tests/integration-tests/overloaded-functions/subgraph.yaml
index 2b3cbfa922f..bf2b1bd00c9 100644
--- a/tests/integration-tests/ganache-reverts/subgraph.yaml
+++ b/tests/integration-tests/overloaded-functions/subgraph.yaml
@@ -1,4 +1,4 @@
-specVersion: 0.0.2
+specVersion: 0.0.4
 schema:
   file: ./schema.graphql
 dataSources:
@@ -6,11 +6,11 @@ dataSources:
     name: Contract
     network: test
     source:
-      address: "0xCfEB869F69431e42cdB54A4F4f105C19C080A601"
+      address: "@OverloadedContract@"
       abi: Contract
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.5
+      apiVersion: 0.0.6
       language: wasm/assemblyscript
       abis:
         - name: Contract
diff --git a/tests/integration-tests/package.json b/tests/integration-tests/package.json
deleted file mode 100644
index 1d272de326c..00000000000
--- a/tests/integration-tests/package.json
+++ /dev/null
@@ -1,13 +0,0 @@
-{
-  "private": true,
-  "workspaces": [
-    "api-version-v0-0-4",
-    "ganache-reverts",
-    "host-exports",
-    "non-fatal-errors",
-    "overloaded-contract-functions",
-    "poi-for-failed-subgraph",
-    "remove-then-update",
-    "value-roundtrip"
-  ]
-}
diff --git a/tests/integration-tests/poi-for-failed-subgraph/package.json b/tests/integration-tests/poi-for-failed-subgraph/package.json
index 665bf0ace52..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": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main",
-    "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/poi-for-failed-subgraph/subgraph.yaml b/tests/integration-tests/poi-for-failed-subgraph/subgraph.yaml
index 09e3122864c..476496dcba0 100644
--- a/tests/integration-tests/poi-for-failed-subgraph/subgraph.yaml
+++ b/tests/integration-tests/poi-for-failed-subgraph/subgraph.yaml
@@ -1,4 +1,4 @@
-specVersion: 0.0.2
+specVersion: 0.0.4
 schema:
   file: ./schema.graphql
 dataSources:
@@ -6,11 +6,11 @@ dataSources:
     name: Contract
     network: test
     source:
-      address: "0xCfEB869F69431e42cdB54A4F4f105C19C080A601"
+      address: "@SimpleContract@"
       abi: Contract
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.5
+      apiVersion: 0.0.6
       language: wasm/assemblyscript
       abis:
         - name: Contract
diff --git a/tests/integration-tests/poi-for-failed-subgraph/test/test.js b/tests/integration-tests/poi-for-failed-subgraph/test/test.js
deleted file mode 100644
index 42c511eead1..00000000000
--- a/tests/integration-tests/poi-for-failed-subgraph/test/test.js
+++ /dev/null
@@ -1,156 +0,0 @@
-const assert = require("assert")
-const path = require("path");
-const execSync = require("child_process").execSync;
-const { patching } = require("gluegun");
-const { createApolloFetch } = require("apollo-fetch");
-
-const Contract = artifacts.require("./Contract.sol");
-
-const srcDir = path.join(__dirname, "..");
-
-const httpPort = process.env.GRAPH_NODE_HTTP_PORT || 18000;
-const indexPort = process.env.GRAPH_NODE_INDEX_PORT || 18030;
-
-const fetchSubgraphs = createApolloFetch({
-  uri: `http://localhost:${indexPort}/graphql`,
-});
-const fetchSubgraph = createApolloFetch({
-  uri: `http://localhost:${httpPort}/subgraphs/name/test/poi-for-failed-subgraph`,
-});
-
-const fetchIndexingStatuses = subgraphName => fetchSubgraphs({
-  query: `{
-    indexingStatusesForSubgraphName(subgraphName: "${subgraphName}") {
-      subgraph
-      health
-      entityCount
-      chains {
-        network
-        latestBlock { number hash }
-      }
-    }
-  }`,
-})
-
-const fetchProofOfIndexing = ({ deploymentId, latestBlock }) => fetchSubgraphs({
-  query: `{
-    proofOfIndexing(
-      subgraph: "${deploymentId}",
-      blockNumber: ${latestBlock.number},
-      blockHash: "${latestBlock.hash}"
-    )
-  }`,
-})
-
-const fetchEntityCalls = () => fetchSubgraph({
-  query: `{
-    calls {
-      id
-      value
-    }
-  }`,
-})
-
-const exec = (cmd) => {
-  try {
-    return execSync(cmd, { cwd: srcDir, stdio: "inherit" });
-  } catch (e) {
-    throw new Error(`Failed to run command \`${cmd}\``);
-  }
-};
-
-const waitForSubgraphToFailWithError = async (blockNumber) =>
-  new Promise((resolve, reject) => {
-    let deadline = Date.now() + 60 * 1000;
-
-    const checkSubgraphFailedWithPoI = async () => {
-      try {
-        // Step necessary to get:
-        // - last block hash
-        // - last block number
-        // - subgraph deployment id
-        // So we can query the PoI later.
-        let statusesResult = await fetchIndexingStatuses("test/poi-for-failed-subgraph");
-
-        if (statusesResult.errors != null) {
-          reject("query contains errors: " + JSON.stringify(statusesResult.errors));
-        }
-
-        let statuses = statusesResult.data.indexingStatusesForSubgraphName;
-
-        assert(
-          statuses.length === 1,
-          `There should be only one subgraph with the provided name, found ${statuses.length} instead`
-        )
-
-        let status = statuses[0]
-
-        // Get Calls that the mappings tried to save before the DeterministicError happened.
-        let callsResult = await fetchEntityCalls()
-
-        let callsCount = (callsResult.data && callsResult.data.calls && callsResult.data.calls.length) || 0
-
-        if (callsCount !== 0) {
-          return reject(new Error("No entity besides the Proof of Indexing should be able to be stored"));
-        }
-
-        // Need to have failed since mappings have an `assert(false)`.
-        if (status.health === "failed") {
-          // Find latest block for the correct chain (we only use one)
-          let { latestBlock } = status.chains.find(({ network }) => network === "test")
-
-          let poiResult = await fetchProofOfIndexing({
-            deploymentId: status.subgraph,
-            latestBlock,
-          })
-
-          let hasPoI = poiResult.data && poiResult.data.proofOfIndexing != null
-          let hasOnlyOneEntityInTheDatabase = status.entityCount == 1
-
-          if (!hasPoI) {
-            return reject(new Error("Failed subgraph should have Proof of Indexing for block"));
-          } else if (!hasOnlyOneEntityInTheDatabase) {
-            // 1 instead of 3, which would happen if both 'Call' entities were saved in the database (look at src/mapping.ts)
-            return reject(new Error("Proof of Indexing returned, but it's not saved into the database"));
-          } else {
-            return resolve();
-          }
-        } else {
-          throw new Error("reject or retry");
-        }
-      } catch (e) {
-        if (Date.now() > deadline) {
-          return reject(new Error(`Timed out waiting for the subgraph to fail`));
-        } else {
-          setTimeout(checkSubgraphFailedWithPoI, 500);
-        }
-      }
-    };
-
-    setTimeout(checkSubgraphFailedWithPoI, 0);
-  });
-
-contract("Contract", (accounts) => {
-  // Deploy the subgraph once before all tests
-  before(async () => {
-    // Deploy the contract
-    const contract = await Contract.deployed();
-    await contract.emitTrigger(1);
-
-    // 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 fails with expected error", async () => {
-    await waitForSubgraphToFailWithError(3);
-  });
-});
diff --git a/tests/integration-tests/poi-for-failed-subgraph/truffle.js b/tests/integration-tests/poi-for-failed-subgraph/truffle.js
deleted file mode 100644
index 58130e7d21d..00000000000
--- a/tests/integration-tests/poi-for-failed-subgraph/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/remove-then-update/package.json b/tests/integration-tests/remove-then-update/package.json
index 91eea8a5417..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": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main",
-    "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/subgraph.yaml b/tests/integration-tests/remove-then-update/subgraph.yaml
index 09e3122864c..476496dcba0 100644
--- a/tests/integration-tests/remove-then-update/subgraph.yaml
+++ b/tests/integration-tests/remove-then-update/subgraph.yaml
@@ -1,4 +1,4 @@
-specVersion: 0.0.2
+specVersion: 0.0.4
 schema:
   file: ./schema.graphql
 dataSources:
@@ -6,11 +6,11 @@ dataSources:
     name: Contract
     network: test
     source:
-      address: "0xCfEB869F69431e42cdB54A4F4f105C19C080A601"
+      address: "@SimpleContract@"
       abi: Contract
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.5
+      apiVersion: 0.0.6
       language: wasm/assemblyscript
       abis:
         - name: Contract
diff --git a/tests/integration-tests/remove-then-update/test/test.js b/tests/integration-tests/remove-then-update/test/test.js
deleted file mode 100644
index ea1c4e79772..00000000000
--- a/tests/integration-tests/remove-then-update/test/test.js
+++ /dev/null
@@ -1,99 +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 httpPort = process.env.GRAPH_NODE_HTTP_PORT || 18000;
-const indexPort = process.env.GRAPH_NODE_INDEX_PORT || 18030;
-
-const fetchSubgraphs = createApolloFetch({
-  uri: `http://localhost:${indexPort}/graphql`,
-});
-const fetchSubgraph = createApolloFetch({
-  uri: `http://localhost:${httpPort}/subgraphs/name/test/remove-then-update`,
-});
-
-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();
-    await contract.emitTrigger(1);
-
-    // 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`);
-
-    // Wait for the subgraph to be indexed
-    await waitForSubgraphToBeSynced();
-  });
-
-  it("all overloads of the contract function are called", async () => {
-    let result = await fetchSubgraph({
-      query: `{ foos(orderBy: id) { id value removed } }`,
-    });
-
-    expect(result.errors).to.be.undefined;
-    expect(result.data).to.deep.equal({
-      foos: [
-        {
-          id: "0",
-          removed: true,
-          value: null,
-        },
-      ],
-    });
-  });
-});
diff --git a/tests/integration-tests/remove-then-update/truffle.js b/tests/integration-tests/remove-then-update/truffle.js
deleted file mode 100644
index e3957ea52e8..00000000000
--- a/tests/integration-tests/remove-then-update/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/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/overloaded-contract-functions/subgraph.yaml b/tests/integration-tests/reverted-calls/subgraph.yaml
similarity index 80%
rename from tests/integration-tests/overloaded-contract-functions/subgraph.yaml
rename to tests/integration-tests/reverted-calls/subgraph.yaml
index 2b3cbfa922f..18eda63af82 100644
--- a/tests/integration-tests/overloaded-contract-functions/subgraph.yaml
+++ b/tests/integration-tests/reverted-calls/subgraph.yaml
@@ -1,4 +1,4 @@
-specVersion: 0.0.2
+specVersion: 0.0.4
 schema:
   file: ./schema.graphql
 dataSources:
@@ -6,11 +6,11 @@ dataSources:
     name: Contract
     network: test
     source:
-      address: "0xCfEB869F69431e42cdB54A4F4f105C19C080A601"
+      address: "@RevertingContract@"
       abi: Contract
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.5
+      apiVersion: 0.0.6
       language: wasm/assemblyscript
       abis:
         - name: Contract
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 cf177d5c862..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": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main",
-    "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/value-roundtrip/subgraph.yaml b/tests/integration-tests/value-roundtrip/subgraph.yaml
index 09e3122864c..476496dcba0 100644
--- a/tests/integration-tests/value-roundtrip/subgraph.yaml
+++ b/tests/integration-tests/value-roundtrip/subgraph.yaml
@@ -1,4 +1,4 @@
-specVersion: 0.0.2
+specVersion: 0.0.4
 schema:
   file: ./schema.graphql
 dataSources:
@@ -6,11 +6,11 @@ dataSources:
     name: Contract
     network: test
     source:
-      address: "0xCfEB869F69431e42cdB54A4F4f105C19C080A601"
+      address: "@SimpleContract@"
       abi: Contract
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.5
+      apiVersion: 0.0.6
       language: wasm/assemblyscript
       abis:
         - name: Contract
diff --git a/tests/integration-tests/value-roundtrip/test/test.js b/tests/integration-tests/value-roundtrip/test/test.js
deleted file mode 100644
index d8247d9e98b..00000000000
--- a/tests/integration-tests/value-roundtrip/test/test.js
+++ /dev/null
@@ -1,102 +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 httpPort = process.env.GRAPH_NODE_HTTP_PORT || 18000;
-const indexPort = process.env.GRAPH_NODE_INDEX_PORT || 18030;
-
-const fetchSubgraphs = createApolloFetch({
-  uri: `http://localhost:${indexPort}/graphql`,
-});
-const fetchSubgraph = createApolloFetch({
-  uri: `http://localhost:${httpPort}/subgraphs/name/test/value-roundtrip`,
-});
-
-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`);
-
-    // Wait for the subgraph to be indexed
-    await waitForSubgraphToBeSynced();
-  });
-
-  it("test query", async () => {
-    // Also test that multiple block constraints do not result in a graphql error.
-    let result = await fetchSubgraph({
-      query: `{
-        foos_0: foos(orderBy: id, block: { number: 0 }) { id }
-        foos(orderBy: id) { id value }
-      }`,
-    });
-
-    expect(result.errors).to.be.undefined;
-    expect(result.data).to.deep.equal({
-      foos_0: [],
-      foos: [
-        {
-          id: "0",
-          value: "bla",
-        },
-      ],
-    });
-  });
-});
diff --git a/tests/integration-tests/value-roundtrip/truffle.js b/tests/integration-tests/value-roundtrip/truffle.js
deleted file mode 100644
index 27a9675b4d7..00000000000
--- a/tests/integration-tests/value-roundtrip/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/yarn.lock b/tests/integration-tests/yarn.lock
deleted file mode 100644
index bf8ff17f87e..00000000000
--- a/tests/integration-tests/yarn.lock
+++ /dev/null
@@ -1,12650 +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/runtime@^7.9.2":
-  version "7.18.9"
-  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.18.9.tgz#b4fcfce55db3d2e5e080d2490f608a3b9f407f4a"
-  integrity sha512-lkqXDcvlFT5rvEjiu6+QYO+1GXrEHRo2LOtS7E4GtX5ESIZOgepqsZBVIj6Pv+a6zqsya9VCgiK1KAK4BvJDAw==
-  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"
-
-"@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"
-
-"@graphprotocol/graph-cli@https://github.com/graphprotocol/graph-cli#main":
-  version "0.33.0"
-  resolved "https://github.com/graphprotocol/graph-cli#47e075a9701680580e0e8e09c5444963224dbf5c"
-  dependencies:
-    assemblyscript "0.19.10"
-    binary-install-raw "0.0.13"
-    chalk "3.0.0"
-    chokidar "3.5.1"
-    debug "4.3.1"
-    docker-compose "0.23.4"
-    dockerode "2.5.8"
-    fs-extra "9.0.0"
-    glob "7.1.6"
-    gluegun "https://github.com/edgeandnode/gluegun#v4.3.1-pin-colors-dep"
-    graphql "15.5.0"
-    immutable "3.8.2"
-    ipfs-http-client "34.0.0"
-    jayson "3.6.6"
-    js-yaml "3.13.1"
-    node-fetch "2.6.0"
-    pkginfo "0.4.1"
-    prettier "1.19.1"
-    request "2.88.2"
-    semver "7.3.5"
-    sync-request "6.1.0"
-    tmp-promise "3.0.2"
-    web3-eth-abi "1.7.0"
-    which "2.0.2"
-    yaml "1.9.2"
-
-"@graphprotocol/graph-cli@https://github.com/graphprotocol/graph-cli#v0.21.1":
-  version "0.21.1"
-  resolved "https://github.com/graphprotocol/graph-cli#352f34d66e3fc7ebd55fa0a2848ce32e191baf5f"
-  dependencies:
-    assemblyscript "git+https://github.com/AssemblyScript/assemblyscript.git#v0.6"
-    chalk "^3.0.0"
-    chokidar "^3.0.2"
-    debug "^4.1.1"
-    docker-compose "^0.23.2"
-    dockerode "^2.5.8"
-    fs-extra "^9.0.0"
-    glob "^7.1.2"
-    gluegun "^4.3.1"
-    graphql "^15.5.0"
-    immutable "^3.8.2"
-    ipfs-http-client "^34.0.0"
-    jayson "^3.0.2"
-    js-yaml "^3.13.1"
-    node-fetch "^2.3.0"
-    pkginfo "^0.4.1"
-    prettier "^1.13.5"
-    request "^2.88.0"
-    tmp-promise "^3.0.2"
-    yaml "^1.5.1"
-
-"@graphprotocol/graph-ts@https://github.com/graphprotocol/graph-ts#main":
-  version "0.28.1"
-  resolved "https://github.com/graphprotocol/graph-ts#4e91d2c0b695c7689aba205516d3e80fb5588454"
-  dependencies:
-    assemblyscript "0.19.10"
-
-"@graphprotocol/graph-ts@https://github.com/graphprotocol/graph-ts#v0.21.1":
-  version "0.20.0"
-  resolved "https://github.com/graphprotocol/graph-ts#56adb62d9e4233c6fc6c38bc0519a8a566afdd9e"
-  dependencies:
-    assemblyscript "https://github.com/AssemblyScript/assemblyscript#36040d5b5312f19a025782b5e36663823494c2f3"
-
-"@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"
-
-"@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==
-
-"@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"
-
-"@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==
-
-"@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"
-
-"@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/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-serve-static-core@^4.17.9":
-  version "4.17.30"
-  resolved "https://registry.yarnpkg.com/@types/express-serve-static-core/-/express-serve-static-core-4.17.30.tgz#0f2f99617fa8f9696170c46152ccf7500b34ac04"
-  integrity sha512-gstzbTWro2/nFed1WXtf+TtrpwxH7Ggs4RLYTLbeVgIkUQOI3WG/JKjgeOU1zXDvezllupjrf8OPIdvTbIaVOQ==
-  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/lodash@^4.14.159":
-  version "4.14.184"
-  resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.184.tgz#23f96cd2a21a28e106dc24d825d4aa966de7a9fe"
-  integrity sha512-RoZphVtHbxPZizt4IcILciSWiC6dcn+eZ8oX9IWEYfDMcocdd42f7NPI6fQj+6zI8y4E0L7gu2pcZKLGTRaV9Q==
-
-"@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/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/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@^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==
-
-"@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@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=
-
-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-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:
-  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"
-
-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=
-
-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"
-
-apisauce@^1.0.1:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/apisauce/-/apisauce-1.1.5.tgz#31d41a5cf805e401266cec67faf1a50f4aeae234"
-  integrity sha512-gKC8qb/bDJsPsnEXLZnXJ7gVx7dh87CEVNeIwv1dvaffnXoh5GHwac5pWR1P2broLiVj/fqFMQvLDDt/RhjiqA==
-  dependencies:
-    axios "^0.21.2"
-    ramda "^0.25.0"
-
-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"
-
-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"
-
-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"
-
-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=
-
-asmcrypto.js@^2.3.2:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/asmcrypto.js/-/asmcrypto.js-2.3.2.tgz#b9f84bd0a1fb82f21f8c29cc284a707ad17bba2e"
-  integrity sha512-3FgFARf7RupsZETQ1nHnhLUUvpcttcCq1iZCaVAbJZbCZ5VNRrNyvpDyHTOb0KC3llFcsyOT/a99NZcCbeiEsA==
-
-asn1.js@^5.0.1, 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"
-
-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@git+https://github.com/AssemblyScript/assemblyscript.git#v0.6":
-  version "0.6.0"
-  resolved "git+https://github.com/AssemblyScript/assemblyscript.git#3ed76a97f05335504166fce1653da75f4face28f"
-  dependencies:
-    "@protobufjs/utf8" "^1.1.0"
-    binaryen "77.0.0-nightly.20190407"
-    glob "^7.1.3"
-    long "^4.0.0"
-    opencollective-postinstall "^2.0.0"
-    source-map-support "^0.5.11"
-
-"assemblyscript@https://github.com/AssemblyScript/assemblyscript#36040d5b5312f19a025782b5e36663823494c2f3":
-  version "0.6.0"
-  resolved "https://github.com/AssemblyScript/assemblyscript#36040d5b5312f19a025782b5e36663823494c2f3"
-  dependencies:
-    "@protobufjs/utf8" "^1.1.0"
-    binaryen "77.0.0-nightly.20190407"
-    glob "^7.1.3"
-    long "^4.0.0"
-    opencollective-postinstall "^2.0.0"
-    source-map-support "^0.5.11"
-
-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==
-
-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@^2.6.1, async@^2.6.2, async@^2.6.3:
-  version "2.6.4"
-  resolved "https://registry.yarnpkg.com/async/-/async-2.6.4.tgz#706b7ff6084664cd7eae713f6f965433b5504221"
-  integrity sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==
-  dependencies:
-    lodash "^4.17.14"
-
-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.2:
-  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@77.0.0-nightly.20190407:
-  version "77.0.0-nightly.20190407"
-  resolved "https://registry.yarnpkg.com/binaryen/-/binaryen-77.0.0-nightly.20190407.tgz#fbe4f8ba0d6bd0809a84eb519d2d5b5ddff3a7d1"
-  integrity sha512-1mxYNvQ0xywMe582K7V6Vo2zzhZZxMTeGHH8aE/+/AND8f64D8Q1GThVY3RVRwGY/4p+p95ccw9Xbw2ovFXRIg==
-
-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"
-
-bip66@^1.1.5:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/bip66/-/bip66-1.1.5.tgz#01fa8748785ca70955d5011217d1b3139969ca22"
-  integrity sha512-nemMHz95EmS38a26XbbdxIYj5csHd3RMP3H5bwQknX0WYHF01qhpufP42mLOwVICuH2JmhIhXiWs89MfUGL7Xw==
-  dependencies:
-    safe-buffer "^5.0.1"
-
-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"
-
-bl@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/bl/-/bl-3.0.1.tgz#1cbb439299609e419b5a74d7fce2f8b37d8e5c6f"
-  integrity sha512-jrCW5ZhfQ/Vt07WX1Ngs+yn9BDqPL/gw28S7s9H6QK/gupnizNzJAss5akW20ISgOrbLTlXOOCTJeNUQqruAWQ==
-  dependencies:
-    readable-stream "^3.0.1"
-
-bl@^4.0.3:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/bl/-/bl-4.1.0.tgz#451535264182bec2fbbc83a62ab98cf11d9f7b3a"
-  integrity sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==
-  dependencies:
-    buffer "^5.5.0"
-    inherits "^2.0.4"
-    readable-stream "^3.4.0"
-
-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==
-
-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=
-
-borc@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/borc/-/borc-2.1.2.tgz#6ce75e7da5ce711b963755117dd1b187f6f8cf19"
-  integrity sha512-Sy9eoUi4OiKzq7VovMn246iTo17kzuyHJKomCfpWMlI6RpfN1gk95w7d7gH264nApVLg0HZfcpz62/g4VH1Y4w==
-  dependencies:
-    bignumber.js "^9.0.0"
-    buffer "^5.5.0"
-    commander "^2.15.0"
-    ieee754 "^1.1.13"
-    iso-url "~0.4.7"
-    json-text-sequence "~0.1.0"
-    readable-stream "^3.6.0"
-
-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"
-
-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:
-  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-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.0.6, 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, bs58@^4.0.1:
-  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.4.2, buffer@^5.4.3, 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.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"
-
-builtin-status-codes@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz#85982878e21b98e1c66425e03d0174788f569ee8"
-  integrity sha512-HpGFw18DgFWlncDfjTa2rcQ4W88O1mC8e8yZ2AvQY5KDaktSTwo+KRf6nHK6FRI5FyRyb/5T6+TSxfP7QyGsmQ==
-
-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"
-
-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==
-
-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"
-
-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.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.1, chokidar@^3.0.2:
-  version "3.5.1"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.1.tgz#ee9ce7bbebd2b79f49f304799d5468e31e14e68a"
-  integrity sha512-9+s+Od+W0VJJzawDma/gvBNQqkTiqYTWLuZoyAsivsI4AaWTCzHG06/TMjsf1cYe9Cb97UCEhjz7HvnPk2p/tw==
-  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.5.0"
-  optionalDependencies:
-    fsevents "~2.3.1"
-
-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, cids@~0.7.0, 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"
-
-cids@~0.8.0:
-  version "0.8.3"
-  resolved "https://registry.yarnpkg.com/cids/-/cids-0.8.3.tgz#aaf48ac8ed857c3d37dad94d8db1d8c9407b92db"
-  integrity sha512-yoXTbV3llpm+EBGWKeL9xKtksPE/s6DPoDSY4fn8I8TEW1zehWXPSB0pwAXVDlLaOlrw+sNynj995uD9abmPhA==
-  dependencies:
-    buffer "^5.6.0"
-    class-is "^1.1.0"
-    multibase "^1.0.0"
-    multicodec "^1.0.1"
-    multihashes "^1.0.1"
-
-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==
-
-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-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.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.3.3:
-  version "1.3.3"
-  resolved "https://registry.yarnpkg.com/colors/-/colors-1.3.3.tgz#39e005d546afe01e01f9c4ca8fa50f686a01205d"
-  integrity sha512-mmGt/1pZqYRjMxB1axhTo16/snVZ5krrKkcmMeVKxzECMMXoCgnvTPp10QgHfcbQZw8Dq2jMNG6je4JlWU0gWg==
-
-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.15.0, 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"
-
-"concat-stream@github:hugomrdias/concat-stream#feat/smaller":
-  version "2.0.0"
-  resolved "https://codeload.github.com/hugomrdias/concat-stream/tar.gz/057bc7b5d6d8df26c8cf00a3f151b6721a0a8034"
-  dependencies:
-    inherits "^2.0.3"
-    readable-stream "^3.0.2"
-
-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"
-
-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"
-
-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.0:
-  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"
-
-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.1:
-  version "4.3.1"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.1.tgz#f0d229c505e0c6d8c49ac553d1b13dc183f6b2ee"
-  integrity sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==
-  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"
-
-debug@^4.1.0, debug@^4.1.1, debug@^4.3.1:
-  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"
-
-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=
-
-delimit-stream@0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/delimit-stream/-/delimit-stream-0.1.0.tgz#9b8319477c0e5f8aeb3ce357ae305fc25ea1cd2b"
-  integrity sha512-a02fiQ7poS5CnjiJBAsjGLPp5EwVoGHNeu9sziBd9huppRfsAFIpv5zNLv0V1gbop53ilngAf5Kf331AwcoRBQ==
-
-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=
-
-detect-node@^2.0.4:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/detect-node/-/detect-node-2.1.0.tgz#c9c70775a49c3d03bc2c06d9a73be550f978f8b1"
-  integrity sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==
-
-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:
-  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"
-
-docker-compose@0.23.4:
-  version "0.23.4"
-  resolved "https://registry.yarnpkg.com/docker-compose/-/docker-compose-0.23.4.tgz#43bcabcde55a6ba2873b52fe0ccd99dd8fdceba8"
-  integrity sha512-yWdXby9uQ8o4syOfvoSJ9ZlTnLipvUmDn59uaYY5VGIUSUAfMPPGqE1DE3pOCnfSg9Tl9UOOFO0PCSAzuIHmuA==
-
-docker-compose@^0.23.2:
-  version "0.23.6"
-  resolved "https://registry.yarnpkg.com/docker-compose/-/docker-compose-0.23.6.tgz#bd21e17d599f17fcf7a4b5d607cff0358a9c378b"
-  integrity sha512-y3Q8MkwG862rNqkvEQG59/7Fi2/fzs3NYDCvqUAAD+z0WGs2qcJ9hRcn34hWgWv9ouPkFqe3Vwca0h+4bIIRWw==
-
-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, 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=
-
-drbg.js@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/drbg.js/-/drbg.js-1.0.1.tgz#3e36b6c42b37043823cdbc332d58f31e2445480b"
-  integrity sha512-F4wZ06PvqxYLFEZKkFxTDcns9oFNk34hvmJSEwdzsxVQ8YI5YaxtACgQatkYgv2VI2CFkUd2Y+xosPQnHv809g==
-  dependencies:
-    browserify-aes "^1.0.6"
-    create-hash "^1.1.2"
-    create-hmac "^1.1.4"
-
-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@^2.6.1:
-  version "2.7.4"
-  resolved "https://registry.yarnpkg.com/ejs/-/ejs-2.7.4.tgz#48661287573dcc53e366c7a1ae52c3a120eec9ba"
-  integrity sha512-7vmuyh5+kuUyJKePhQfRQBhXV5Ce+RnaeeQArKu1EAMpL3WbgMt5WG6uQZpEVvYSSsxMXRKOewtDk9RaTKXRlA==
-
-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:
-  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, end-of-stream@^1.4.1:
-  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"
-
-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@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/err-code/-/err-code-1.1.2.tgz#06e0116d3028f6aef4806849eb0ea6a748ae6960"
-  integrity sha512-CJAN+O0/yA1CKfRn9SXOGctSpEM7DCon/r/5r2eXFMY2zCCJBasFhcM5I+1kh3Ap11FsQCX+vGHceNPvpWKhoA==
-
-err-code@^2.0.0:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/err-code/-/err-code-2.0.3.tgz#23c2f3b756ffdfc608d30e27c9a941024807e7f9"
-  integrity sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==
-
-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:
-  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@^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"
-
-explain-error@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/explain-error/-/explain-error-1.0.4.tgz#a793d3ac0cad4c6ab571e9968fbbab6cb2532929"
-  integrity sha512-/wSgNMxFusiYRy1rd19LT2SQlIXDppHpumpWo06wxjflD1OYxDLbl6rMVw+U3bxD5Nuhex4TKqv9Aem4D0lVzQ==
-
-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-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-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-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@~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-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==
-
-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==
-
-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"
-
-flatmap@0.0.3:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/flatmap/-/flatmap-0.0.3.tgz#1f18a4d938152d495965f9c958d923ab2dd669b4"
-  integrity sha512-OuR+o7kHVe+x9RtIujPay7Uw3bvDZBZFSBXClEphZuSDLmZTqMdclasf4vFSsogC8baDz0eaC2NdO/2dlXHBKQ==
-
-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.0.0:
-  version "9.0.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-9.0.0.tgz#b6afc31036e247b2466dc99c29ae797d5d4580a3"
-  integrity sha512-pmEYSk3vYsG/bF651KPUXZ+hvjpgWYw/Gc7W9NFUe3ZVLczKKWIij3IKpOrQcdw4TILtibFslZ0UmR8Vvzig4g==
-  dependencies:
-    at-least-node "^1.0.0"
-    graceful-fs "^4.2.0"
-    jsonfile "^6.0.1"
-    universalify "^1.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-extra@^9.0.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-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.1:
-  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-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-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.0:
-  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, glob@^7.1.2:
-  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@^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"
-
-gluegun@^4.3.1, 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"
-
-"gluegun@https://github.com/edgeandnode/gluegun#v4.3.1-pin-colors-dep":
-  version "4.3.1"
-  resolved "https://github.com/edgeandnode/gluegun#b34b9003d7bf556836da41b57ef36eb21570620a"
-  dependencies:
-    apisauce "^1.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-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, graphql@^15.5.0:
-  version "15.5.0"
-  resolved "https://registry.yarnpkg.com/graphql/-/graphql-15.5.0.tgz#39d19494dbe69d1ea719915b578bf920344a69d5"
-  integrity sha512-OmaM7y0kaK31NKG31q4YbD2beNYa6jBBKtMFT6gLYJljHLJr42IqJ8KX08u3Li/0ifzTU5HjmoOOrwa5BRLeDA==
-
-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"
-
-hi-base32@~0.5.0:
-  version "0.5.1"
-  resolved "https://registry.yarnpkg.com/hi-base32/-/hi-base32-0.5.1.tgz#1279f2ddae2673219ea5870c2121d2a33132857e"
-  integrity sha512-EmBBpvdYh/4XxsnUybsPag6VikPYnN30td+vQk+GI3qpahVEG9+gTkG0aXVxTjBqQ5T6ijbWIu77O+C5WFWsnA==
-
-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==
-
-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==
-
-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@3.8.2, immutable@^3.8.2:
-  version "3.8.2"
-  resolved "https://registry.yarnpkg.com/immutable/-/immutable-3.8.2.tgz#c2439951455bb39913daf281376f1530e104adf3"
-  integrity sha1-wkOZUUVbs5kT2vKBN28VMOEErfM=
-
-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:
-  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=
-
-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==
-
-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@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-2.1.0.tgz#fa78bf5d2e6913c911ce9f819ee5146bb6d844e9"
-  integrity sha512-58yWmlHpp7VYfcdTwMTvwMmqx/Elfxjd9RXTDyMsbL7lLWmhMylLEqiYVLKuLzOZqVgiWXD9MfR62Vv89VRxkw==
-
-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==
-
-ip@^1.1.5:
-  version "1.1.8"
-  resolved "https://registry.yarnpkg.com/ip/-/ip-1.1.8.tgz#ae05948f6b075435ed3307acce04629da8cdbf48"
-  integrity sha512-PuExPYUiu6qMBQb4l06ecm6T6ujzhmh+MeJcW9wa89PoAz5pvd4zPgN5WJV104mb6S2T1AwNIAaB70JNrLQWhg==
-
-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-block@~0.8.1:
-  version "0.8.1"
-  resolved "https://registry.yarnpkg.com/ipfs-block/-/ipfs-block-0.8.1.tgz#05e1068832775e8f1c2da5b64106cc837fd2acb9"
-  integrity sha512-0FaCpmij+jZBoUYhjoB5ptjdl9QzvrdRIoBmUU5JiBnK2GA+4YM/ifklaB8ePRhA/rRzhd+KYBjvMFMAL4NrVQ==
-  dependencies:
-    cids "~0.7.0"
-    class-is "^1.1.0"
-
-ipfs-http-client@34.0.0, ipfs-http-client@^34.0.0:
-  version "34.0.0"
-  resolved "https://registry.yarnpkg.com/ipfs-http-client/-/ipfs-http-client-34.0.0.tgz#8804d06a11c22306332a8ffa0949b6f672a0c9c8"
-  integrity sha512-4RCkk8ix4Dqn6sxqFVwuXWCZ1eLFPsVaj6Ijvu1fs9VYgxgVudsW9PWwarlr4mw1xUCmPWYyXnEbGgzBrfMy0Q==
-  dependencies:
-    abort-controller "^3.0.0"
-    async "^2.6.1"
-    bignumber.js "^9.0.0"
-    bl "^3.0.0"
-    bs58 "^4.0.1"
-    buffer "^5.4.2"
-    cids "~0.7.1"
-    concat-stream "github:hugomrdias/concat-stream#feat/smaller"
-    debug "^4.1.0"
-    detect-node "^2.0.4"
-    end-of-stream "^1.4.1"
-    err-code "^2.0.0"
-    explain-error "^1.0.4"
-    flatmap "0.0.3"
-    glob "^7.1.3"
-    ipfs-block "~0.8.1"
-    ipfs-utils "~0.0.3"
-    ipld-dag-cbor "~0.15.0"
-    ipld-dag-pb "~0.17.3"
-    ipld-raw "^4.0.0"
-    is-ipfs "~0.6.1"
-    is-pull-stream "0.0.0"
-    is-stream "^2.0.0"
-    iso-stream-http "~0.1.2"
-    iso-url "~0.4.6"
-    iterable-ndjson "^1.1.0"
-    just-kebab-case "^1.1.0"
-    just-map-keys "^1.1.0"
-    kind-of "^6.0.2"
-    ky "^0.11.2"
-    ky-universal "^0.2.2"
-    lru-cache "^5.1.1"
-    multiaddr "^6.0.6"
-    multibase "~0.6.0"
-    multicodec "~0.5.1"
-    multihashes "~0.4.14"
-    ndjson "github:hugomrdias/ndjson#feat/readable-stream3"
-    once "^1.4.0"
-    peer-id "~0.12.3"
-    peer-info "~0.15.1"
-    promise-nodeify "^3.0.1"
-    promisify-es6 "^1.0.3"
-    pull-defer "~0.2.3"
-    pull-stream "^3.6.9"
-    pull-to-stream "~0.1.1"
-    pump "^3.0.0"
-    qs "^6.5.2"
-    readable-stream "^3.1.1"
-    stream-to-pull-stream "^1.7.2"
-    tar-stream "^2.0.1"
-    through2 "^3.0.1"
-
-ipfs-utils@~0.0.3:
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/ipfs-utils/-/ipfs-utils-0.0.4.tgz#946114cfeb6afb4454b4ccb10d2327cd323b0cce"
-  integrity sha512-7cZf6aGj2FG3XJWhCNwn4mS93Q0GEWjtBZvEHqzgI43U2qzNDCyzfS1pei1Y5F+tw/zDJ5U4XG0G9reJxR53Ig==
-  dependencies:
-    buffer "^5.2.1"
-    is-buffer "^2.0.3"
-    is-electron "^2.2.0"
-    is-pull-stream "0.0.0"
-    is-stream "^2.0.0"
-    kind-of "^6.0.2"
-    readable-stream "^3.4.0"
-
-ipld-dag-cbor@~0.15.0:
-  version "0.15.3"
-  resolved "https://registry.yarnpkg.com/ipld-dag-cbor/-/ipld-dag-cbor-0.15.3.tgz#283afdb81d5b07db8e4fff7a10ef5e517e87f299"
-  integrity sha512-m23nG7ZyoVFnkK55/bLAErc7EfiMgaEQlqHWDTGzPI+O5r6bPfp+qbL5zTVSIT8tpbHmu174dwerVtLoVgeVyA==
-  dependencies:
-    borc "^2.1.2"
-    buffer "^5.5.0"
-    cids "~0.8.0"
-    is-circular "^1.0.2"
-    multicodec "^1.0.0"
-    multihashing-async "~0.8.0"
-
-ipld-dag-pb@~0.17.3:
-  version "0.17.4"
-  resolved "https://registry.yarnpkg.com/ipld-dag-pb/-/ipld-dag-pb-0.17.4.tgz#080841cfdd014d996f8da7f3a522ec8b1f6b6494"
-  integrity sha512-YwCxETEMuXVspOKOhjIOHJvKvB/OZfCDkpSFiYBQN2/JQjM9y/RFCYzIQGm0wg7dCFLrhvfjAZLTSaKs65jzWA==
-  dependencies:
-    cids "~0.7.0"
-    class-is "^1.1.0"
-    multicodec "~0.5.1"
-    multihashing-async "~0.7.0"
-    protons "^1.0.1"
-    stable "~0.1.8"
-
-ipld-raw@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/ipld-raw/-/ipld-raw-4.0.1.tgz#49a6f58cdfece5a4d581925b19ee19255be2a29d"
-  integrity sha512-WjIdtZ06jJEar8zh+BHB84tE6ZdbS/XNa7+XCArOYfmeJ/c01T9VQpeMwdJQYn5c3s5UvvCu7y4VIi3vk2g1bA==
-  dependencies:
-    cids "~0.7.0"
-    multicodec "^1.0.0"
-    multihashing-async "~0.8.0"
-
-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, 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-circular@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-circular/-/is-circular-1.0.2.tgz#2e0ab4e9835f4c6b0ea2b9855a84acd501b8366c"
-  integrity sha512-YttjnrswnUYRVJvxCvu8z+PGMUSzC2JttP0OEXezlAEdp3EXzhf7IZ3j0gRAybJBQupedIZFhY61Tga6E0qASA==
-
-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-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@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-ip/-/is-ip-2.0.0.tgz#68eea07e8a0a0a94c2d080dd674c731ab2a461ab"
-  integrity sha512-9MTn0dteHETtyUx8pxqMwg5hMBi3pvlyglJ+b79KOCca0po23337LbVV2Hl4xmMvfw++ljnO0/+5G6G+0Szh6g==
-  dependencies:
-    ip-regex "^2.0.0"
-
-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-ipfs@~0.6.1:
-  version "0.6.3"
-  resolved "https://registry.yarnpkg.com/is-ipfs/-/is-ipfs-0.6.3.tgz#82a5350e0a42d01441c40b369f8791e91404c497"
-  integrity sha512-HyRot1dvLcxImtDqPxAaY1miO6WsiP/z7Yxpg2qpaLWv5UdhAPtLvHJ4kMLM0w8GSl8AFsVF23PHe1LzuWrUlQ==
-  dependencies:
-    bs58 "^4.0.1"
-    cids "~0.7.0"
-    mafmt "^7.0.0"
-    multiaddr "^7.2.1"
-    multibase "~0.6.0"
-    multihashes "~0.4.13"
-
-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-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-promise@~1, is-promise@~1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-1.0.1.tgz#31573761c057e33c2e91aab9e96da08cefbe76e5"
-  integrity sha512-mjWH5XxnhMA8cFnDchr6qRP9S/kLntKuEfIYku+PaN1CnS8v+OG9O/BKpRCVRJvpIkgAZm0Pf5Is3iSSOILlcg==
-
-is-pull-stream@0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/is-pull-stream/-/is-pull-stream-0.0.0.tgz#a3bc3d1c6d3055151c46bde6f399efed21440ca9"
-  integrity sha512-NWLwqCc95I6m8FZDYLAmVJc9Xgk8O+8pPOoDKFTC293FH4S7FBcbLCw3WWPCdiT8uUSdzPy47VM08WPDMJJrag==
-
-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"
-
-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-random-stream@^1.1.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/iso-random-stream/-/iso-random-stream-1.1.2.tgz#c703da2c518db573277c5678cc43c5298283d64c"
-  integrity sha512-7y0tsBBgQs544iTYjyrMp5xvgrbYR8b+plQq1Bryp+03p0LssrxC9C1M0oHv4QESDt7d95c74XvMk/yawKqX+A==
-  dependencies:
-    buffer "^6.0.3"
-    readable-stream "^3.4.0"
-
-iso-stream-http@~0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/iso-stream-http/-/iso-stream-http-0.1.2.tgz#b3dfea4c9f23ff26d078d40c539cfc0dfebacd37"
-  integrity sha512-oHEDNOysIMTNypbg2f1SlydqRBvjl4ZbSE9+0awVxnkx3K2stGTFwB/kpVqnB6UEfF8QD36kAjDwZvqyXBLMnQ==
-  dependencies:
-    builtin-status-codes "^3.0.0"
-    inherits "^2.0.1"
-    readable-stream "^3.1.1"
-
-iso-url@~0.4.6, iso-url@~0.4.7:
-  version "0.4.7"
-  resolved "https://registry.yarnpkg.com/iso-url/-/iso-url-0.4.7.tgz#de7e48120dae46921079fe78f325ac9e9217a385"
-  integrity sha512-27fFRDnPAMnHGLq36bWTpKET+eiXct3ENlCcdcMdk+mjXrb2kw3mhBUg1B7ewAC0kVzlOPhADzQgz1SE6Tglog==
-
-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"
-
-iterable-ndjson@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/iterable-ndjson/-/iterable-ndjson-1.1.0.tgz#36f7e8a5bb04fd087d384f29e44fc4280fc014fc"
-  integrity sha512-OOp1Lb0o3k5MkXHx1YaIY5Z0ELosZfTnBaas9f8opJVcZGBIONA2zY/6CYE+LKkqrSDooIneZbrBGgOZnHPkrg==
-  dependencies:
-    string_decoder "^1.2.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"
-
-jayson@3.6.6:
-  version "3.6.6"
-  resolved "https://registry.yarnpkg.com/jayson/-/jayson-3.6.6.tgz#189984f624e398f831bd2be8e8c80eb3abf764a1"
-  integrity sha512-f71uvrAWTtrwoww6MKcl9phQTC+56AopLyEenWvKVAIMz+q0oVGj6tenLZ7Z6UiPBkJtKLj4kt0tACllFQruGQ==
-  dependencies:
-    "@types/connect" "^3.4.33"
-    "@types/express-serve-static-core" "^4.17.9"
-    "@types/lodash" "^4.14.159"
-    "@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"
-    lodash "^4.17.20"
-    uuid "^8.3.2"
-    ws "^7.4.5"
-
-jayson@^3.0.2:
-  version "3.4.4"
-  resolved "https://registry.yarnpkg.com/jayson/-/jayson-3.4.4.tgz#dcedffba0c02785c4aa22dbff8c28966cae59773"
-  integrity sha512-fgQflh+Qnhdv9fjxTnpTsa2WUG/dgyeKQzIh5MJ77Qv2sqFyyAZn7mTUYgPjJMFjsKfb4HNsSBh6ktJeeQiAGQ==
-  dependencies:
-    "@types/connect" "^3.4.33"
-    "@types/express-serve-static-core" "^4.17.9"
-    "@types/lodash" "^4.14.159"
-    "@types/node" "^12.12.54"
-    JSONStream "^1.3.5"
-    commander "^2.20.3"
-    es6-promisify "^5.0.0"
-    eyes "^0.1.8"
-    json-stringify-safe "^5.0.1"
-    lodash "^4.17.20"
-    uuid "^3.4.0"
-
-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, 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.13.1:
-  version "3.13.1"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.13.1.tgz#aff151b30bfdfa8e49e05da22e7415e9dfa37847"
-  integrity sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==
-  dependencies:
-    argparse "^1.0.7"
-    esprima "^4.0.0"
-
-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.13.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"
-
-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==
-
-json-text-sequence@~0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/json-text-sequence/-/json-text-sequence-0.1.1.tgz#a72f217dc4afc4629fff5feb304dc1bd51a2f3d2"
-  integrity sha512-L3mEegEWHRekSHjc7+sc8eJhba9Clq1PZ8kMkzf8OxElhXc8O4TS5MwcVlj9aEbm5dr81N90WHC5nAz3UO971w==
-  dependencies:
-    delimit-stream "0.1.0"
-
-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"
-
-just-kebab-case@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/just-kebab-case/-/just-kebab-case-1.1.0.tgz#ebe854fde84b0afa4e597fcd870b12eb3c026755"
-  integrity sha512-QkuwuBMQ9BQHMUEkAtIA4INLrkmnnveqlFB1oFi09gbU0wBdZo6tTnyxNWMR84zHxBuwK7GLAwqN8nrvVxOLTA==
-
-just-map-keys@^1.1.0:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/just-map-keys/-/just-map-keys-1.2.1.tgz#ef6e16133b7d34329962dfae9101d581abb1b143"
-  integrity sha512-Dmyz1Cy2SWM+PpqDPB1kdDglyexdzMthnAsvOIE9w4OPj8NDRuY1mh20x/JfG5w6fCGw9F0WmcofJhYZ4MiuyA==
-
-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"
-
-keypair@^1.0.1:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/keypair/-/keypair-1.0.4.tgz#a749a45f388593f3950f18b3757d32a93bd8ce83"
-  integrity sha512-zwhgOhhniaL7oxMgUMKKw5219PWWABMO+dgMnzJOQ2/5L3XJtTJGhW2PEXlxXj9zaccdReZJZ83+4NPhVfNVDg==
-
-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, kind-of@^6.0.2:
-  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"
-
-ky-universal@^0.2.2:
-  version "0.2.2"
-  resolved "https://registry.yarnpkg.com/ky-universal/-/ky-universal-0.2.2.tgz#7a36e1a75641a98f878157463513965f799f5bfe"
-  integrity sha512-fb32o/fKy/ux2ALWa9HU2hvGtfOq7/vn2nH0FpVE+jwNzyTeORlAbj3Fiw+WLMbUlmVqZIWupnLZ2USHvqwZHw==
-  dependencies:
-    abort-controller "^3.0.0"
-    node-fetch "^2.3.0"
-
-ky@^0.11.2:
-  version "0.11.2"
-  resolved "https://registry.yarnpkg.com/ky/-/ky-0.11.2.tgz#4ffe6621d9d9ab61bf0f5500542e3a96d1ba0815"
-  integrity sha512-5Aou5BWue5/mkPqIRqzSWW+0Hkl403pr/2AIrCKYw7cVl/Xoe8Xe4KLBO0PRjbz7GnRe1/8wW1KhqQNFFE7/GQ==
-
-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"
-
-libp2p-crypto-secp256k1@~0.3.0:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/libp2p-crypto-secp256k1/-/libp2p-crypto-secp256k1-0.3.1.tgz#4cbeb857f5cfe5fefb1253e6b2994420c0ca166e"
-  integrity sha512-evrfK/CeUSd/lcELUdDruyPBvxDmLairth75S32OLl3H+++2m2fV24JEtxzdFS9JH3xEFw0h6JFO8DBa1bP9dA==
-  dependencies:
-    async "^2.6.2"
-    bs58 "^4.0.1"
-    multihashing-async "~0.6.0"
-    nodeify "^1.0.1"
-    safe-buffer "^5.1.2"
-    secp256k1 "^3.6.2"
-
-libp2p-crypto@~0.16.1:
-  version "0.16.4"
-  resolved "https://registry.yarnpkg.com/libp2p-crypto/-/libp2p-crypto-0.16.4.tgz#fb1a4ba39d56789303947784b5b0d6cefce12fdc"
-  integrity sha512-II8HxKc9jbmQp34pprlluNxsBCWJDjHRPYJzuRy7ragztNip9Zb7uJ4lCje6gGzz4DNAcHkAUn+GqCIK1592iA==
-  dependencies:
-    asmcrypto.js "^2.3.2"
-    asn1.js "^5.0.1"
-    async "^2.6.1"
-    bn.js "^4.11.8"
-    browserify-aes "^1.2.0"
-    bs58 "^4.0.1"
-    iso-random-stream "^1.1.0"
-    keypair "^1.0.1"
-    libp2p-crypto-secp256k1 "~0.3.0"
-    multihashing-async "~0.5.1"
-    node-forge "^0.10.0"
-    pem-jwk "^2.0.0"
-    protons "^1.0.1"
-    rsa-pem-to-jwk "^1.1.3"
-    tweetnacl "^1.0.0"
-    ursa-optional "~0.10.0"
-
-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.20, 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==
-
-looper@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/looper/-/looper-3.0.0.tgz#2efa54c3b1cbaba9b94aee2e5914b0be57fbb749"
-  integrity sha512-LJ9wplN/uSn72oJRsXTx+snxPet5c8XiZmOKCm906NVYu+ag6SB6vUcnJcWxgnl2NfbIyeobAn7Bwv6xRj2XJg==
-
-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@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
-  integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
-  dependencies:
-    yallist "^3.0.2"
-
-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"
-
-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=
-
-mafmt@^6.0.2:
-  version "6.0.10"
-  resolved "https://registry.yarnpkg.com/mafmt/-/mafmt-6.0.10.tgz#3ad251c78f14f8164e66f70fd3265662da41113a"
-  integrity sha512-FjHDnew6dW9lUu3eYwP0FvvJl9uvNbqfoJM+c1WJcSyutNEIlyu6v3f/rlPnD1cnmue38IjuHlhBdIh3btAiyw==
-  dependencies:
-    multiaddr "^6.1.0"
-
-mafmt@^7.0.0:
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/mafmt/-/mafmt-7.1.0.tgz#4126f6d0eded070ace7dbbb6fb04977412d380b5"
-  integrity sha512-vpeo9S+hepT3k2h5iFxzEHvvR0GPBx9uKaErmnRzYNcaKb03DgOArjEMlgG4a9LcuZZ89a3I8xbeto487n26eA==
-  dependencies:
-    multiaddr "^7.3.0"
-
-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"
-
-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-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:
-  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"
-
-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:
-  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"
-
-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"
-
-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@^6.0.3, multiaddr@^6.0.6, multiaddr@^6.1.0:
-  version "6.1.1"
-  resolved "https://registry.yarnpkg.com/multiaddr/-/multiaddr-6.1.1.tgz#9aae57b3e399089b9896d9455afa8f6b117dff06"
-  integrity sha512-Q1Ika0F9MNhMtCs62Ue+GWIJtRFEhZ3Xz8wH7/MZDVZTWhil1/H2bEGN02kUees3hkI3q1oHSjmXYDM0gxaFjQ==
-  dependencies:
-    bs58 "^4.0.1"
-    class-is "^1.1.0"
-    hi-base32 "~0.5.0"
-    ip "^1.1.5"
-    is-ip "^2.0.0"
-    varint "^5.0.0"
-
-multiaddr@^7.2.1, multiaddr@^7.3.0:
-  version "7.5.0"
-  resolved "https://registry.yarnpkg.com/multiaddr/-/multiaddr-7.5.0.tgz#976c88e256e512263445ab03b3b68c003d5f485e"
-  integrity sha512-GvhHsIGDULh06jyb6ev+VfREH9evJCFIRnh3jUt9iEZ6XDbyoisZRFEI9bMvK/AiR6y66y6P+eoBw9mBYMhMvw==
-  dependencies:
-    buffer "^5.5.0"
-    cids "~0.8.0"
-    class-is "^1.1.0"
-    is-ip "^3.1.0"
-    multibase "^0.7.0"
-    varint "^5.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@^1.0.0, multibase@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/multibase/-/multibase-1.0.1.tgz#4adbe1de0be8a1ab0274328b653c3f1903476724"
-  integrity sha512-KcCxpBVY8fdVKu4dJMAahq4F/2Z/9xqEjIiR7PiMe7LRGeorFn2NLmicN6nLBCqQvft6MG2Lc9X5P0IdyvnxEw==
-  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, multicodec@~0.5.1:
-  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, multicodec@^1.0.1:
-  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"
-
-multihashes@^0.4.15, multihashes@~0.4.13, multihashes@~0.4.14, 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"
-
-multihashes@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/multihashes/-/multihashes-1.0.1.tgz#a89415d68283cf6287c6e219e304e75ce7fb73fe"
-  integrity sha512-S27Tepg4i8atNiFaU5ZOm3+gl3KQlUanLs/jWcBxQHFttgq+5x1OgbQmf2d8axJ/48zYGBd/wT9d723USMFduw==
-  dependencies:
-    buffer "^5.6.0"
-    multibase "^1.0.1"
-    varint "^5.0.0"
-
-multihashing-async@~0.5.1:
-  version "0.5.2"
-  resolved "https://registry.yarnpkg.com/multihashing-async/-/multihashing-async-0.5.2.tgz#4af40e0dde2f1dbb12a7c6b265181437ac26b9de"
-  integrity sha512-mmyG6M/FKxrpBh9xQDUvuJ7BbqT93ZeEeH5X6LeMYKoYshYLr9BDdCsvDtZvn+Egf+/Xi+aOznrWL4vp3s+p0Q==
-  dependencies:
-    blakejs "^1.1.0"
-    js-sha3 "~0.8.0"
-    multihashes "~0.4.13"
-    murmurhash3js "^3.0.1"
-    nodeify "^1.0.1"
-
-multihashing-async@~0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/multihashing-async/-/multihashing-async-0.6.0.tgz#c1fc6696a624b9bf39b160b0c4c4e7ba3f394453"
-  integrity sha512-Qv8pgg99Lewc191A5nlXy0bSd2amfqlafNJZmarU6Sj7MZVjpR94SCxQjf4DwPtgWZkiLqsjUQBXA2RSq+hYyA==
-  dependencies:
-    blakejs "^1.1.0"
-    js-sha3 "~0.8.0"
-    multihashes "~0.4.13"
-    murmurhash3js "^3.0.1"
-    nodeify "^1.0.1"
-
-multihashing-async@~0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/multihashing-async/-/multihashing-async-0.7.0.tgz#3234fb98295be84386b85bfd20377d3e5be20d6b"
-  integrity sha512-SCbfl3f+DzJh+/5piukga9ofIOxwfT05t8R4jfzZIJ88YE9zU9+l3K2X+XB19MYyxqvyK9UJRNWbmQpZqQlbRA==
-  dependencies:
-    blakejs "^1.1.0"
-    buffer "^5.2.1"
-    err-code "^1.1.2"
-    js-sha3 "~0.8.0"
-    multihashes "~0.4.13"
-    murmurhash3js-revisited "^3.0.0"
-
-multihashing-async@~0.8.0:
-  version "0.8.2"
-  resolved "https://registry.yarnpkg.com/multihashing-async/-/multihashing-async-0.8.2.tgz#3d5da05df27d83be923f6d04143a0954ff87f27f"
-  integrity sha512-2lKa1autuCy8x7KIEj9aVNbAb3aIMRFYIwN7mq/zD4pxgNIVgGlm+f6GKY4880EOF2Y3GktHYssRy7TAJQ2DyQ==
-  dependencies:
-    blakejs "^1.1.0"
-    buffer "^5.4.3"
-    err-code "^2.0.0"
-    js-sha3 "^0.8.0"
-    multihashes "^1.0.1"
-    murmurhash3js-revisited "^3.0.0"
-
-murmurhash3js-revisited@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/murmurhash3js-revisited/-/murmurhash3js-revisited-3.0.0.tgz#6bd36e25de8f73394222adc6e41fa3fac08a5869"
-  integrity sha512-/sF3ee6zvScXMb1XFJ8gDsSnY+X8PbOyjIuBhtgis10W2Jx4ZjIhikUCIF9c4gpJxVnQIsPAFrSwTCuAjicP6g==
-
-murmurhash3js@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/murmurhash3js/-/murmurhash3js-3.0.1.tgz#3e983e5b47c2a06f43a713174e7e435ca044b998"
-  integrity sha512-KL8QYUaxq7kUbcl0Yto51rMcYt7E/4N4BG3/c96Iqw1PQrTRspu8Cpx4TZ4Nunib1d4bEkIH3gjCYlP2RLBdow==
-
-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==
-
-nan@^2.14.0, nan@^2.14.2:
-  version "2.16.0"
-  resolved "https://registry.yarnpkg.com/nan/-/nan-2.16.0.tgz#664f43e45460fb98faf00edca0bb0d7b8dce7916"
-  integrity sha512-UdAqHyFngu7TfQKsCBgAA6pWDkT8MAO7d0jyOecVhN5354xbLqdn8mV9Tat9gepAupm0bt2DbeaSC8vS52MuFA==
-
-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==
-
-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==
-
-"ndjson@github:hugomrdias/ndjson#feat/readable-stream3":
-  version "1.5.0"
-  resolved "https://codeload.github.com/hugomrdias/ndjson/tar.gz/4db16da6b42e5b39bf300c3a7cde62abb3fa3a11"
-  dependencies:
-    json-stringify-safe "^5.0.1"
-    minimist "^1.2.0"
-    split2 "^3.1.0"
-    through2 "^3.0.0"
-
-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=
-
-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.3.0:
-  version "2.6.7"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.7.tgz#24de9fba827e3b4ae44dc8b20256a379160052ad"
-  integrity sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==
-  dependencies:
-    whatwg-url "^5.0.0"
-
-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-forge@^0.10.0:
-  version "0.10.0"
-  resolved "https://registry.yarnpkg.com/node-forge/-/node-forge-0.10.0.tgz#32dea2afb3e9926f02ee5ce8794902691a676bf3"
-  integrity sha512-PPmu8eEeG9saEUvI97fm4OYxXVB6bFvyNTyiUOBichBpFG8A1Ljw3bY62+5oOjDEMHRnd0Y7HQ+x7uzxOzC6JA==
-
-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==
-
-nodeify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/nodeify/-/nodeify-1.0.1.tgz#64ab69a7bdbaf03ce107b4f0335c87c0b9e91b1d"
-  integrity sha512-n7C2NyEze8GCo/z73KdbjRsBiLbv6eBn1FxwYKQ23IqGo7pQY3mhQan61Sv7eEDJCiyUjTVrVkXTzJCo1dW7Aw==
-  dependencies:
-    is-promise "~1.0.0"
-    promise "~1.3.0"
-
-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:
-  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@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-2.1.1.tgz#43c36e5d569ff8e4816c4efa8be02d26967c18aa"
-  integrity sha512-CdsOUYIh5wIiozhJ3rLQgmUTgcyzFwZZrqhkKhODMoGtPKM+wt0h0CNIoauJWMsS9822EdzPsF/6mb4nLvPN5g==
-
-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.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:
-  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"
-
-optimist@~0.3.5:
-  version "0.3.7"
-  resolved "https://registry.yarnpkg.com/optimist/-/optimist-0.3.7.tgz#c90941ad59e4273328923074d2cf2e7cbc6ec0d9"
-  integrity sha512-TCx0dXQzVtSCg2OgY/bO9hjM9cV4XYx09TVK+s3+FhkjT6LovsLe+pPMzpWf+6yXK/hUizs2gUoTw3jHM0VaTQ==
-  dependencies:
-    wordwrap "~0.0.2"
-
-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@^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-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-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"
-
-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@^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-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"
-
-peer-id@~0.12.2, peer-id@~0.12.3:
-  version "0.12.5"
-  resolved "https://registry.yarnpkg.com/peer-id/-/peer-id-0.12.5.tgz#b22a1edc5b4aaaa2bb830b265ba69429823e5179"
-  integrity sha512-3xVWrtIvNm9/OPzaQBgXDrfWNx63AftgFQkvqO6YSZy7sP3Fuadwwbn54F/VO9AnpyW/26i0WRQz9FScivXrmw==
-  dependencies:
-    async "^2.6.3"
-    class-is "^1.1.0"
-    libp2p-crypto "~0.16.1"
-    multihashes "~0.4.15"
-
-peer-info@~0.15.1:
-  version "0.15.1"
-  resolved "https://registry.yarnpkg.com/peer-info/-/peer-info-0.15.1.tgz#21254a7c516d0dd046b150120b9aaf1b9ad02146"
-  integrity sha512-Y91Q2tZRC0CpSTPd1UebhGqniOrOAk/aj60uYUcWJXCoLTAnGu+4LJGoiay8ayudS6ice7l3SKhgL/cS62QacA==
-  dependencies:
-    mafmt "^6.0.2"
-    multiaddr "^6.0.3"
-    peer-id "~0.12.2"
-    unique-by "^1.0.0"
-
-pem-jwk@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/pem-jwk/-/pem-jwk-2.0.0.tgz#1c5bb264612fc391340907f5c1de60c06d22f085"
-  integrity sha512-rFxu7rVoHgQ5H9YsP50dDWf0rHjreVA2z0yPiWr5WdH/UHb29hKtF7h6l8vNd1cbYR1t0QL+JKhW55a2ZV4KtA==
-  dependencies:
-    asn1.js "^5.0.1"
-
-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:
-  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"
-
-pkginfo@0.4.1, pkginfo@^0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/pkginfo/-/pkginfo-0.4.1.tgz#b5418ef0439de5425fc4995042dced14fb2a84ff"
-  integrity sha1-tUGO8EOd5UJfxJlQQtztFPsqhP8=
-
-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, prettier@^1.13.5:
-  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-nodeify@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/promise-nodeify/-/promise-nodeify-3.0.1.tgz#f0f5d9720ee9ec71dd2bfa92667be504c10229c2"
-  integrity sha512-ghsSuzZXJX8iO7WVec2z7GI+Xk/EyiD+JZK7AZKhUqYfpLa/Zs4ylUD+CwwnKlG6G3HnkUPMAi6PO7zeqGKssg==
-
-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"
-
-promise@~1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/promise/-/promise-1.3.0.tgz#e5cc9a4c8278e4664ffedc01c7da84842b040175"
-  integrity sha512-R9WrbTF3EPkVtWjp7B7umQGVndpsi+rsDAfrR4xAALQpFLa/+2OriecLhawxzvii2gd9+DZFwROWDuUUaqS5yA==
-  dependencies:
-    is-promise "~1"
-
-promisify-es6@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/promisify-es6/-/promisify-es6-1.0.3.tgz#b012668c4df3c965ce13daac2b3a4d1726a96346"
-  integrity sha512-N9iVG+CGJsI4b4ZGazjwLnxErD2d9Pe4DPvvXSxYA9tFNu8ymXME4Qs5HIQ0LMJpNM7zj+m0NlNnNeqFpKzqnA==
-
-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"
-
-protocol-buffers-schema@^3.3.1:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/protocol-buffers-schema/-/protocol-buffers-schema-3.6.0.tgz#77bc75a48b2ff142c1ad5b5b90c94cd0fa2efd03"
-  integrity sha512-TdDRD+/QNdrCGCE7v8340QyuXd4kIWIgapsE2+n/SaGiSSbomYl4TjHlvIoCWRpE7wFt02EpB35VVA2ImcBVqw==
-
-protons@^1.0.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/protons/-/protons-1.2.1.tgz#5f1e0db8b2139469cd1c3b4e332a4c2d95d0a218"
-  integrity sha512-2oqDyc/SN+tNcJf8XxrXhYL7sQn2/OMl8mSdD7NVGsWjMEmAbks4eDVnCyf0vAoRbBWyWTEXWk4D8XfuKVl3zg==
-  dependencies:
-    buffer "^5.5.0"
-    protocol-buffers-schema "^3.3.1"
-    signed-varint "^2.0.1"
-    varint "^5.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"
-
-pull-defer@~0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/pull-defer/-/pull-defer-0.2.3.tgz#4ee09c6d9e227bede9938db80391c3dac489d113"
-  integrity sha512-/An3KE7mVjZCqNhZsr22k1Tx8MACnUnHZZNPSJ0S62td8JtYr/AiRG42Vz7Syu31SoTLUzVIe61jtT/pNdjVYA==
-
-pull-stream@^3.2.3, pull-stream@^3.6.9:
-  version "3.6.14"
-  resolved "https://registry.yarnpkg.com/pull-stream/-/pull-stream-3.6.14.tgz#529dbd5b86131f4a5ed636fdf7f6af00781357ee"
-  integrity sha512-KIqdvpqHHaTUA2mCYcLG1ibEbu/LCKoJZsBWyv9lSYtPkJPBq8m3Hxa103xHi6D2thj5YXa0TqK3L3GUkwgnew==
-
-pull-to-stream@~0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/pull-to-stream/-/pull-to-stream-0.1.1.tgz#fa2058528528e3542b81d6f17cbc42288508ff37"
-  integrity sha512-thZkMv6F9PILt9zdvpI2gxs19mkDrlixYKX6cOBxAW16i1NZH+yLAmF4r8QfJ69zuQh27e01JZP9y27tsH021w==
-  dependencies:
-    readable-stream "^3.1.1"
-
-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@^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==
-
-qs@6.11.0, qs@^6.4.0, qs@^6.5.2:
-  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==
-
-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.0.0, readable-stream@^3.0.1, readable-stream@^3.0.2, 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.5.0:
-  version "3.5.0"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.5.0.tgz#9ba74c019b15d365278d2e91bb8c48d7b4d42c9e"
-  integrity sha512-cMhu7c/8rdhkHXWsY+osBhfSy0JikwpHK/5+imo+LpeasTF8ouErHrlYkwT0++njiyuDvc7OFY5T3ukvZ8qmFQ==
-  dependencies:
-    picomatch "^2.2.1"
-
-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, request@^2.88.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"
-
-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==
-
-rsa-pem-to-jwk@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/rsa-pem-to-jwk/-/rsa-pem-to-jwk-1.1.3.tgz#245e76bdb7e7234cfee7ca032d31b54c38fab98e"
-  integrity sha512-ZlVavEvTnD8Rzh/pdB8NH4VF5GNEtF6biGQcTtC4GKFMsbZR08oHtOYefbhCN+JnJIuMItiCDCMycdcMrw6blA==
-  dependencies:
-    object-assign "^2.0.0"
-    rsa-unpack "0.0.6"
-
-rsa-unpack@0.0.6:
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/rsa-unpack/-/rsa-unpack-0.0.6.tgz#f50ebd56a628378e631f297161026ce9ab4eddba"
-  integrity sha512-HRrl8GHjjPziPFRDJPq/v5OxZ3IPdksV5h3cime/oHgcgM1k1toO5OdtzClgBqRf5dF6IgptOB0g/zFb0w5zQw==
-  dependencies:
-    optimist "~0.3.5"
-
-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@^3.6.2:
-  version "3.8.0"
-  resolved "https://registry.yarnpkg.com/secp256k1/-/secp256k1-3.8.0.tgz#28f59f4b01dbee9575f56a47034b7d2e3b3b352d"
-  integrity sha512-k5ke5avRZbtl9Tqx/SA7CbY3NF6Ro+Sj9cZxezFzuBlLDmyqPiL8hJJ+EmzD8Ig4LUDByHJ3/iPOVoRixs/hmw==
-  dependencies:
-    bindings "^1.5.0"
-    bip66 "^1.1.5"
-    bn.js "^4.11.8"
-    create-hash "^1.2.0"
-    drbg.js "^1.0.1"
-    elliptic "^6.5.2"
-    nan "^2.14.0"
-    safe-buffer "^5.1.2"
-
-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@^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@~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@^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@^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:
-  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==
-
-signed-varint@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/signed-varint/-/signed-varint-2.0.1.tgz#50a9989da7c98c2c61dad119bc97470ef8528129"
-  integrity sha512-abgDPg1106vuZZOvw7cFwdCABddfJRz5akcCcchzTbhyhYnsG31y4AlZEgp315T7W3nQq5P4xeOm186ZiPVFzw==
-  dependencies:
-    varint "~5.0.0"
-
-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==
-
-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.11, 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-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==
-
-split2@^3.1.0:
-  version "3.2.2"
-  resolved "https://registry.yarnpkg.com/split2/-/split2-3.2.2.tgz#bf2cf2a37d838312c249c89206fd7a17dd12365f"
-  integrity sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==
-  dependencies:
-    readable-stream "^3.0.0"
-
-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"
-
-stable@~0.1.8:
-  version "0.1.8"
-  resolved "https://registry.yarnpkg.com/stable/-/stable-0.1.8.tgz#836eb3c8382fe2936feaf544631017ce7d47a3cf"
-  integrity sha512-ji9qxRnOVfcuLDySj9qzhGSEFVobyt1kIOSkj1qZzYLzq7Tos/oUUWvotUPQLlrsidqsK6tBH89Bc9kL5zHA6w==
-
-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-pull-stream@^1.7.2:
-  version "1.7.3"
-  resolved "https://registry.yarnpkg.com/stream-to-pull-stream/-/stream-to-pull-stream-1.7.3.tgz#4161aa2d2eb9964de60bfa1af7feaf917e874ece"
-  integrity sha512-6sNyqJpr5dIOQdgNy/xcDWwDuzAsAwVzhzrWlAPAQ7Lkjx/rv0wgvxEyKwTq6FmNd5rjTrELt/CLmaSw7crMGg==
-  dependencies:
-    looper "^3.0.0"
-    pull-stream "^3.2.3"
-
-streamsearch@0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/streamsearch/-/streamsearch-0.1.2.tgz#808b9d0e56fc273d809ba57338e929919a1a9f1a"
-  integrity sha1-gIudDlb8Jz2Am6VzOOkpkZoanxo=
-
-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.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, string_decoder@^1.2.0:
-  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:
-  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.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"
-
-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-stream@^2.0.1:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-2.2.0.tgz#acad84c284136b060dc3faa64474aa9aebd77287"
-  integrity sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==
-  dependencies:
-    bl "^4.0.3"
-    end-of-stream "^1.4.1"
-    fs-constants "^1.0.0"
-    inherits "^2.0.3"
-    readable-stream "^3.1.1"
-
-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, through2@^3.0.0, through2@^3.0.1:
-  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=
-
-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.2, tmp-promise@^3.0.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/tmp-promise/-/tmp-promise-3.0.2.tgz#6e933782abff8b00c3119d63589ca1fb9caaa62a"
-  integrity sha512-OyCLAKU1HzBjL6Ev3gxUeraJNlbNingmi8IrHHEsYH8LTmEuhvYfqvhn2F/je+mjf4N58UmZ96OMEy1JanSCpA==
-  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"
-
-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.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==
-
-tweetnacl@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-1.0.3.tgz#ac0af71680458d8a6378d0d0d050ab1407d35596"
-  integrity sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==
-
-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-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==
-
-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-by@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unique-by/-/unique-by-1.0.0.tgz#5220c86ba7bc572fb713ad74651470cb644212bd"
-  integrity sha512-rJRXK5V0zL6TiSzhoGNpJp5dr+TZBLoPJFC06rLn17Ug++7Aa0Qnve5v+skXeQxx6/sI7rBsSesa6MAcmFi8Ew==
-
-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@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-1.0.0.tgz#b61a1da173e8435b2fe3c67d29b9adf8594bd16d"
-  integrity sha512-rb6X1W158d7pRQBg5gkR8uPaSfiids68LTJQYOtEUhoJUWBdaQHsuT/EUduxXYxcrt4r5PJ4fuHW1MHT6p0qug==
-
-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=
-
-ursa-optional@~0.10.0:
-  version "0.10.2"
-  resolved "https://registry.yarnpkg.com/ursa-optional/-/ursa-optional-0.10.2.tgz#bd74e7d60289c22ac2a69a3c8dea5eb2817f9681"
-  integrity sha512-TKdwuLboBn7M34RcvVTuQyhvrA8gYKapuVdm0nBP0mnBc7oECOfUQZrY91cefL3/nm64ZyrejSRrhTVdX7NG/A==
-  dependencies:
-    bindings "^1.5.0"
-    nan "^2.14.2"
-
-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, uuid@^3.4.0:
-  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==
-
-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, varint@~5.0.0:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/varint/-/varint-5.0.2.tgz#5b47f8a947eb668b848e034dcfa87d0ff8a7f7a4"
-  integrity sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow==
-
-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"
-
-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"
-
-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"
-
-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"
-
-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@~0.0.2:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.3.tgz#a3d5da6cd5c0bc0008d37234bbaf1bed63059107"
-  integrity sha512-1tMA907+V4QmxV7dbRvb4/8MaRALK6q9Abid3ndMYnbyo8piisCmeONVqVSXqQA3KaP4SLt5b7ud6E2sqP8TFw==
-
-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"
-
-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.0.2, 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.9.2:
-  version "1.9.2"
-  resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.9.2.tgz#f0cfa865f003ab707663e4f04b3956957ea564ed"
-  integrity sha512-HPT7cGGI0DuRcsO51qC1j9O16Dh1mZ2bnXwsi0jrSpsLz0WxOLSLXfkABVl6bZO629py3CU+OMJtpNHDLB97kg==
-  dependencies:
-    "@babel/runtime" "^7.9.2"
-
-yaml@^1.5.1:
-  version "1.10.0"
-  resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.10.0.tgz#3b593add944876077d4d683fee01081bd9fff31e"
-  integrity sha512-yr2icI4glYaNG+KWONODapy2/jDdMSDnrONSjblABjD9B4Z5LgiircSt8m8sRZFNi08kG9Sm0uSHtEmP3zaEGg==
-
-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-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"
-
-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/.gitignore b/tests/runner-tests/api-version/.gitignore
new file mode 100644
index 00000000000..6ca27766f49
--- /dev/null
+++ b/tests/runner-tests/api-version/.gitignore
@@ -0,0 +1,2 @@
+subgraph-0.0.7.yaml
+subgraph-0.0.8.yaml
\ No newline at end of file
diff --git a/tests/runner-tests/api-version/abis/Contract.abi b/tests/runner-tests/api-version/abis/Contract.abi
new file mode 100644
index 00000000000..9d9f56b9263
--- /dev/null
+++ b/tests/runner-tests/api-version/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/api-version/data.0.0.7.json b/tests/runner-tests/api-version/data.0.0.7.json
new file mode 100644
index 00000000000..d5496551483
--- /dev/null
+++ b/tests/runner-tests/api-version/data.0.0.7.json
@@ -0,0 +1,3 @@
+{
+  "apiVersion": "0.0.7"
+}
diff --git a/tests/runner-tests/api-version/data.0.0.8.json b/tests/runner-tests/api-version/data.0.0.8.json
new file mode 100644
index 00000000000..f01f6e94057
--- /dev/null
+++ b/tests/runner-tests/api-version/data.0.0.8.json
@@ -0,0 +1,3 @@
+{
+  "apiVersion": "0.0.8"
+}
diff --git a/tests/runner-tests/api-version/package.json b/tests/runner-tests/api-version/package.json
new file mode 100644
index 00000000000..b67821fa3d6
--- /dev/null
+++ b/tests/runner-tests/api-version/package.json
@@ -0,0 +1,17 @@
+{
+  "name": "api-version",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "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": "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",
+    "mustache": "^4.2.0"
+  }
+}
diff --git a/tests/runner-tests/api-version/schema.graphql b/tests/runner-tests/api-version/schema.graphql
new file mode 100644
index 00000000000..32db8d43674
--- /dev/null
+++ b/tests/runner-tests/api-version/schema.graphql
@@ -0,0 +1,4 @@
+type TestResult @entity {
+  id: ID!
+  message: String!
+}
diff --git a/tests/runner-tests/api-version/src/mapping.ts b/tests/runner-tests/api-version/src/mapping.ts
new file mode 100644
index 00000000000..7a50ee868e6
--- /dev/null
+++ b/tests/runner-tests/api-version/src/mapping.ts
@@ -0,0 +1,15 @@
+import { Entity, Value, store } from "@graphprotocol/graph-ts";
+import { TestEvent } from "../generated/Contract/Contract";
+import { TestResult } from "../generated/schema";
+
+export function handleTestEvent(event: TestEvent): void {
+  let testResult = new TestResult(event.params.testCommand);
+  testResult.message = event.params.testCommand;
+  let testResultEntity = testResult as Entity;
+  testResultEntity.set(
+    "invalid_field",
+    Value.fromString("This is an invalid field"),
+  );
+  store.set("TestResult", testResult.id, testResult);
+  testResult.save();
+}
diff --git a/tests/runner-tests/api-version/subgraph.template.yaml b/tests/runner-tests/api-version/subgraph.template.yaml
new file mode 100644
index 00000000000..c1429c63b90
--- /dev/null
+++ b/tests/runner-tests/api-version/subgraph.template.yaml
@@ -0,0 +1,23 @@
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "0x0000000000000000000000000000000000000000"
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: {{apiVersion}}
+      language: wasm/assemblyscript
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      entities:
+        - Call
+      eventHandlers:
+        - event: TestEvent(string)
+          handler: handleTestEvent
+      file: ./src/mapping.ts
\ No newline at end of file
diff --git a/tests/runner-tests/arweave-file-data-sources/abis/Contract.abi b/tests/runner-tests/arweave-file-data-sources/abis/Contract.abi
new file mode 100644
index 00000000000..9d9f56b9263
--- /dev/null
+++ b/tests/runner-tests/arweave-file-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/runner-tests/arweave-file-data-sources/package.json b/tests/runner-tests/arweave-file-data-sources/package.json
new file mode 100644
index 00000000000..f264024b638
--- /dev/null
+++ b/tests/runner-tests/arweave-file-data-sources/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "arweave-file-data-sources",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/file-data-sources --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/arweave-file-data-sources/schema.graphql b/tests/runner-tests/arweave-file-data-sources/schema.graphql
new file mode 100644
index 00000000000..d5d07cef24e
--- /dev/null
+++ b/tests/runner-tests/arweave-file-data-sources/schema.graphql
@@ -0,0 +1,5 @@
+type File @entity {
+  id: ID!
+  content: String!
+}
+
diff --git a/tests/runner-tests/arweave-file-data-sources/src/mapping.ts b/tests/runner-tests/arweave-file-data-sources/src/mapping.ts
new file mode 100644
index 00000000000..71929348b89
--- /dev/null
+++ b/tests/runner-tests/arweave-file-data-sources/src/mapping.ts
@@ -0,0 +1,26 @@
+import {
+  ethereum,
+  dataSource,
+  BigInt,
+  Bytes,
+} from "@graphprotocol/graph-ts";
+import { File } from "../generated/schema";
+
+const KNOWN_HASH = "8APeQ5lW0-csTcBaGdPBDLAL2ci2AT9pTn2tppGPU_8";
+
+export function handleBlock(block: ethereum.Block): void {
+  if (block.number == BigInt.fromI32(0)) {
+    dataSource.create("File", [KNOWN_HASH]);
+  }
+}
+
+export function handleFile(data: Bytes): void {
+  let entity = new File(dataSource.stringParam());
+  entity.content = data.toString();
+  entity.save();
+
+  // Test that an offchain data source can load its own entities
+  let loaded_entity = File.load(dataSource.stringParam())!;
+  assert(loaded_entity.content == entity.content);
+}
+
diff --git a/tests/integration-tests/api-version-v0-0-4/subgraph.yaml b/tests/runner-tests/arweave-file-data-sources/subgraph.yaml
similarity index 60%
rename from tests/integration-tests/api-version-v0-0-4/subgraph.yaml
rename to tests/runner-tests/arweave-file-data-sources/subgraph.yaml
index cfb724e24d0..a1ea9fab02c 100644
--- a/tests/integration-tests/api-version-v0-0-4/subgraph.yaml
+++ b/tests/runner-tests/arweave-file-data-sources/subgraph.yaml
@@ -1,19 +1,16 @@
-specVersion: 0.0.2
-repository: https://github.com/graphprotocol/example-subgraph
+specVersion: 0.0.7
 schema:
   file: ./schema.graphql
-features:
-  - nonFatalErrors
 dataSources:
   - kind: ethereum/contract
     name: Contract
     network: test
     source:
-      address: "0xCfEB869F69431e42cdB54A4F4f105C19C080A601"
+      address: "0x0000000000000000000000000000000000000000"
       abi: Contract
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.4
+      apiVersion: 0.0.7
       language: wasm/assemblyscript
       entities:
         - Gravatar
@@ -24,20 +21,16 @@ dataSources:
         - handler: handleBlock
       file: ./src/mapping.ts
 templates:
-  - kind: ethereum/contract
-    name: Template
-    network: test
-    source:
-      abi: Contract
+  - kind: file/arweave
+    name: File
     mapping:
       kind: ethereum/events
-      apiVersion: 0.0.4
+      apiVersion: 0.0.7
       language: wasm/assemblyscript
       entities:
-        - Gravatar
+        - File
       abis:
         - name: Contract
           file: ./abis/Contract.abi
-      blockHandlers:
-        - handler: handleBlockTemplate
+      handler: handleFile
       file: ./src/mapping.ts
diff --git a/tests/runner-tests/block-handlers/abis/Contract.abi b/tests/runner-tests/block-handlers/abis/Contract.abi
new file mode 100644
index 00000000000..9d9f56b9263
--- /dev/null
+++ b/tests/runner-tests/block-handlers/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/block-handlers/package.json b/tests/runner-tests/block-handlers/package.json
new file mode 100644
index 00000000000..0331812e103
--- /dev/null
+++ b/tests/runner-tests/block-handlers/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "block-handlers",
+  "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-cli": "0.60.0",
+    "@graphprotocol/graph-ts": "0.31.0"
+  }
+}
diff --git a/tests/runner-tests/block-handlers/schema.graphql b/tests/runner-tests/block-handlers/schema.graphql
new file mode 100644
index 00000000000..d16f126fc69
--- /dev/null
+++ b/tests/runner-tests/block-handlers/schema.graphql
@@ -0,0 +1,11 @@
+type BlockFromPollingHandler @entity {
+  id: ID!
+  number: BigInt!
+  hash: Bytes!
+}
+
+type BlockFromOtherPollingHandler @entity {
+  id: ID!
+  number: BigInt!
+  hash: Bytes!
+}
\ No newline at end of file
diff --git a/tests/runner-tests/block-handlers/src/mapping.ts b/tests/runner-tests/block-handlers/src/mapping.ts
new file mode 100644
index 00000000000..4b832e0e043
--- /dev/null
+++ b/tests/runner-tests/block-handlers/src/mapping.ts
@@ -0,0 +1,34 @@
+import { ethereum, log } from "@graphprotocol/graph-ts";
+import { Contract, TestEvent } from "../generated/Contract/Contract";
+import { ContractTemplate } from "../generated/templates";
+import {
+  BlockFromOtherPollingHandler,
+  BlockFromPollingHandler,
+} from "../generated/schema";
+
+export function handleBlockPolling(block: ethereum.Block): void {
+  log.info("===> handleBlockPolling {}", [block.number.toString()]);
+  let blockEntity = new BlockFromPollingHandler(block.number.toString());
+  blockEntity.number = block.number;
+  blockEntity.hash = block.hash;
+  blockEntity.save();
+}
+
+export function handleBlockPollingFromTemplate(block: ethereum.Block): void {
+  log.info("===> handleBlockPollingFromTemplate {}", [block.number.toString()]);
+  let blockEntity = new BlockFromOtherPollingHandler(block.number.toString());
+  blockEntity.number = block.number;
+  blockEntity.hash = block.hash;
+  blockEntity.save();
+}
+
+export function handleCommand(event: TestEvent): void {
+  let command = event.params.testCommand;
+
+  if (command == "hello_world") {
+    log.info("Hello World!", []);
+  } else if (command == "create_template") {
+    log.info("===> Creating template {}", [event.address.toHexString()]);
+    ContractTemplate.create(event.address);
+  }
+}
diff --git a/tests/runner-tests/block-handlers/subgraph.yaml b/tests/runner-tests/block-handlers/subgraph.yaml
new file mode 100644
index 00000000000..a3c1a082bda
--- /dev/null
+++ b/tests/runner-tests/block-handlers/subgraph.yaml
@@ -0,0 +1,52 @@
+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:
+        - Gravatar
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlockPolling
+          filter:
+            kind: polling
+            every: 4
+      eventHandlers:
+        - event: TestEvent(string)
+          handler: handleCommand
+      file: ./src/mapping.ts
+templates:
+  - kind: ethereum/contract
+    name: ContractTemplate
+    network: test
+    source:
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - Gravatar
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlockPollingFromTemplate
+          filter:
+            kind: polling
+            every: 2
+      eventHandlers:
+        - event: TestEvent(string)
+          handler: handleCommand
+      file: ./src/mapping.ts
diff --git a/tests/runner-tests/data-source-revert/grafted.yaml b/tests/runner-tests/data-source-revert/grafted.yaml
index 96703b41964..16dca790850 100644
--- a/tests/runner-tests/data-source-revert/grafted.yaml
+++ b/tests/runner-tests/data-source-revert/grafted.yaml
@@ -4,8 +4,9 @@ features:
 schema:
   file: ./schema.graphql
 graft:
-  # Must match the id from building `subgraph.yaml`
-  base: QmX8y4Vwg7pqEMa94GmuT8RRRTJNVKdQTT6Yq8Zw3Vvpd6
+  # This can be overwritten by `updateAndDeploy.js`.
+  # Please commit this file when this happens.
+  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 813b91748ef..80bdeb280e4 100644
--- a/tests/runner-tests/data-source-revert/package.json
+++ b/tests/runner-tests/data-source-revert/package.json
@@ -1,13 +1,14 @@
 {
   "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",
-    "deploy:test-grafted": "graph deploy test/data-source-revert-grafted grafted.yaml --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+    "deploy:test-grafted": "node updateAndDeploy.js"
   },
   "devDependencies": {
-    "@graphprotocol/graph-cli": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main"
+    "@graphprotocol/graph-cli": "0.60.0",
+    "@graphprotocol/graph-ts": "0.31.0"
   }
 }
diff --git a/tests/runner-tests/data-source-revert/updateAndDeploy.js b/tests/runner-tests/data-source-revert/updateAndDeploy.js
new file mode 100644
index 00000000000..d7bc0971346
--- /dev/null
+++ b/tests/runner-tests/data-source-revert/updateAndDeploy.js
@@ -0,0 +1,17 @@
+// This takes a Qm.. hash as a CLI input, which is the graft base.
+
+const fs = require('fs');
+const { execSync } = require('child_process');
+
+const graftBase = process.argv[2];
+
+const yamlPath = './grafted.yaml';
+let yamlContent = fs.readFileSync(yamlPath, 'utf-8');
+yamlContent = yamlContent.replace(/base: .+/, `base: ${graftBase}`);
+fs.writeFileSync(yamlPath, yamlContent);
+console.log("bafuzz")
+
+// Assuming you have your IPFS_URI and GRAPH_NODE_ADMIN_URI exported as environment variables.
+execSync('graph deploy test/data-source-revert-grafted grafted.yaml --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI', {
+    stdio: 'inherit'
+});
diff --git a/tests/runner-tests/data-source-revert2/package.json b/tests/runner-tests/data-source-revert2/package.json
index 50c61bc7d79..45feeedf629 100644
--- a/tests/runner-tests/data-source-revert2/package.json
+++ b/tests/runner-tests/data-source-revert2/package.json
@@ -1,12 +1,13 @@
 {
   "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"
   },
   "devDependencies": {
-    "@graphprotocol/graph-cli": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main"
+    "@graphprotocol/graph-cli": "0.60.0",
+    "@graphprotocol/graph-ts": "0.31.0"
   }
 }
diff --git a/tests/runner-tests/data-sources/abis/Contract.abi b/tests/runner-tests/data-sources/abis/Contract.abi
new file mode 100644
index 00000000000..9d9f56b9263
--- /dev/null
+++ b/tests/runner-tests/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/runner-tests/data-sources/package.json b/tests/runner-tests/data-sources/package.json
new file mode 100644
index 00000000000..118366dd6c5
--- /dev/null
+++ b/tests/runner-tests/data-sources/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "data-sources",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/data-sources --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/data-sources/schema.graphql b/tests/runner-tests/data-sources/schema.graphql
new file mode 100644
index 00000000000..6f97fa65c43
--- /dev/null
+++ b/tests/runner-tests/data-sources/schema.graphql
@@ -0,0 +1,6 @@
+type Data @entity {
+  id: ID!
+  foo: String
+  bar: Int
+  isTest: Boolean
+}
diff --git a/tests/runner-tests/data-sources/src/mapping.ts b/tests/runner-tests/data-sources/src/mapping.ts
new file mode 100644
index 00000000000..3446d1f83c4
--- /dev/null
+++ b/tests/runner-tests/data-sources/src/mapping.ts
@@ -0,0 +1,15 @@
+import { BigInt, dataSource, ethereum, log } from "@graphprotocol/graph-ts";
+import { Data } from "../generated/schema";
+
+export function handleBlock(block: ethereum.Block): void {
+  let foo = dataSource.context().getString("foo");
+  let bar = dataSource.context().getI32("bar");
+  let isTest = dataSource.context().getBoolean("isTest");
+  if (block.number == BigInt.fromI32(0)) {
+    let data = new Data("0");
+    data.foo = foo;
+    data.bar = bar;
+    data.isTest = isTest;
+    data.save();
+  }
+}
diff --git a/tests/runner-tests/data-sources/subgraph.yaml b/tests/runner-tests/data-sources/subgraph.yaml
new file mode 100644
index 00000000000..ed8ebed4a7f
--- /dev/null
+++ b/tests/runner-tests/data-sources/subgraph.yaml
@@ -0,0 +1,32 @@
+specVersion: 0.0.8
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    context:
+      foo:
+        type: String
+        data: test
+      bar:
+        type: Int
+        data: 1
+      isTest:
+        type: Bool
+        data: true
+    source:
+      address: "0x0000000000000000000000000000000000000000"
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - Gravatar
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlock
+      file: ./src/mapping.ts
diff --git a/tests/runner-tests/derived-loaders/abis/Contract.abi b/tests/runner-tests/derived-loaders/abis/Contract.abi
new file mode 100644
index 00000000000..9d9f56b9263
--- /dev/null
+++ b/tests/runner-tests/derived-loaders/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/derived-loaders/package.json b/tests/runner-tests/derived-loaders/package.json
new file mode 100644
index 00000000000..d885b871d24
--- /dev/null
+++ b/tests/runner-tests/derived-loaders/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "derived-loaders",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/derived-loaders --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/derived-loaders/schema.graphql b/tests/runner-tests/derived-loaders/schema.graphql
new file mode 100644
index 00000000000..ade664b2f00
--- /dev/null
+++ b/tests/runner-tests/derived-loaders/schema.graphql
@@ -0,0 +1,45 @@
+type BFoo @entity {
+  id: Bytes!
+  value: Int8!
+  bar: [BBar!]! @derivedFrom(field: "fooValue")
+}
+
+type BBar @entity {
+  id: Bytes!
+  value: Int8!
+  value2: Int8!
+  fooValue: BFoo!
+}
+
+type BBarTestResult @entity {
+  id: Bytes!
+  value: Int8!
+  value2: Int8!
+  fooValue: BFoo!
+}
+
+type Foo @entity {
+  id: ID!
+  value: Int8!
+  bar: [Bar!]! @derivedFrom(field: "fooValue")
+}
+
+type Bar @entity {
+  id: ID!
+  value: Int8!
+  value2: Int8!
+  fooValue: Foo!
+}
+
+type BarTestResult @entity {
+  id: ID!
+  value: Int8!
+  value2: Int8!
+  fooValue: Foo!
+}
+
+type TestResult @entity {
+  id: ID!
+  barDerived: [BarTestResult!]
+  bBarDerived: [BBarTestResult!]
+}
diff --git a/tests/runner-tests/derived-loaders/src/helpers.ts b/tests/runner-tests/derived-loaders/src/helpers.ts
new file mode 100644
index 00000000000..72bc2e8f959
--- /dev/null
+++ b/tests/runner-tests/derived-loaders/src/helpers.ts
@@ -0,0 +1,160 @@
+import { Bytes, log } from "@graphprotocol/graph-ts";
+import {
+  BBar,
+  BBarTestResult,
+  Bar,
+  BarTestResult,
+  TestResult,
+} from "../generated/schema";
+
+/**
+ * Asserts that two `Bar` instances are equal.
+ */
+export function assertBarsEqual(a: Bar, b: Bar): void {
+  assert(
+    a.id == b.id &&
+      a.value == b.value &&
+      a.value2 == b.value2 &&
+      a.fooValue == b.fooValue,
+    "Bar instances are not equal"
+  );
+}
+
+/**
+ * Asserts that two `BBar` instances are equal.
+ */
+export function assertBBarsEqual(
+  a: BBar,
+  b: BBar,
+  message: string = "BBar instances are not equal"
+): void {
+  assert(
+    a.id.toHex() == b.id.toHex() &&
+      a.value == b.value &&
+      a.value2 == b.value2 &&
+      a.fooValue.toHex() == b.fooValue.toHex(),
+    message
+  );
+}
+
+/**
+ * Creates a new `Bar` entity and saves it.
+ */
+export function createBar(
+  id: string,
+  fooValue: string,
+  value: i64,
+  value2: i64
+): Bar {
+  let bar = new Bar(id);
+  bar.fooValue = fooValue;
+  bar.value = value;
+  bar.value2 = value2;
+  bar.save();
+  return bar;
+}
+
+/**
+ * Creates a new `BBar` entity and saves it.
+ */
+export function createBBar(
+  id: Bytes,
+  fooValue: Bytes,
+  value: i64,
+  value2: i64
+): BBar {
+  let bBar = new BBar(id);
+  bBar.fooValue = fooValue;
+  bBar.value = value;
+  bBar.value2 = value2;
+  bBar.save();
+  return bBar;
+}
+
+/**
+ * A function to loop over an array of `Bar` instances and assert that the values are equal.
+ */
+export function assertBarsArrayEqual(bars: Bar[], expected: Bar[]): void {
+  assert(bars.length == expected.length, "bars.length != expected.length");
+  for (let i = 0; i < bars.length; i++) {
+    assertBarsEqual(bars[i], expected[i]);
+  }
+}
+
+/**
+ * A function to loop over an array of `BBar` instances and assert that the values are equal.
+ */
+export function assertBBarsArrayEqual(bBars: BBar[], expected: BBar[]): void {
+  assert(bBars.length == expected.length, "bBars.length != expected.length");
+  for (let i = 0; i < bBars.length; i++) {
+    assertBBarsEqual(bBars[i], expected[i]);
+  }
+}
+
+export function convertBarToBarTestResult(
+  barInstance: Bar,
+  testId: string
+): BarTestResult {
+  const barTestResult = new BarTestResult(barInstance.id + "_" + testId);
+
+  barTestResult.value = barInstance.value;
+  barTestResult.value2 = barInstance.value2;
+  barTestResult.fooValue = barInstance.fooValue;
+  barTestResult.save();
+
+  return barTestResult;
+}
+
+export function convertbBarToBBarTestResult(
+  bBarInstance: BBar,
+  testId: string
+): BBarTestResult {
+  const bBarTestResult = new BBarTestResult(
+    Bytes.fromUTF8(bBarInstance.id.toString() + "_" + testId)
+  );
+
+  bBarTestResult.value = bBarInstance.value;
+  bBarTestResult.value2 = bBarInstance.value2;
+  bBarTestResult.fooValue = bBarInstance.fooValue;
+  bBarTestResult.save();
+
+  return bBarTestResult;
+}
+
+// convertBarArrayToBarTestResultArray
+export function saveBarsToTestResult(
+  barArray: Bar[],
+  testResult: TestResult,
+  testID: string
+): void {
+  let result: string[] = [];
+  for (let i = 0; i < barArray.length; i++) {
+    result.push(convertBarToBarTestResult(barArray[i], testID).id);
+  }
+  testResult.barDerived = result;
+}
+
+// convertBBarArrayToBBarTestResultArray
+export function saveBBarsToTestResult(
+  bBarArray: BBar[],
+  testResult: TestResult,
+  testID: string
+): void {
+  let result: Bytes[] = [];
+  for (let i = 0; i < bBarArray.length; i++) {
+    result.push(convertbBarToBBarTestResult(bBarArray[i], testID).id);
+  }
+  testResult.bBarDerived = result;
+}
+
+export function logTestResult(testResult: TestResult): void {
+  log.info("TestResult with ID: {} has barDerived: {} and bBarDerived: {}", [
+    testResult.id,
+    testResult.barDerived ? testResult.barDerived!.join(", ") : "null",
+    testResult.bBarDerived
+      ? testResult
+          .bBarDerived!.map<string>((b) => b.toHex())
+          .join(", ")
+      : "null",
+  ]);
+}
diff --git a/tests/runner-tests/derived-loaders/src/mapping.ts b/tests/runner-tests/derived-loaders/src/mapping.ts
new file mode 100644
index 00000000000..063a25d1ca3
--- /dev/null
+++ b/tests/runner-tests/derived-loaders/src/mapping.ts
@@ -0,0 +1,166 @@
+import { Bytes, store } from "@graphprotocol/graph-ts";
+import { TestEvent } from "../generated/Contract/Contract";
+import { Bar, Foo, BFoo, BBar, TestResult } from "../generated/schema";
+import {
+  assertBBarsArrayEqual,
+  assertBBarsEqual,
+  assertBarsArrayEqual,
+  assertBarsEqual,
+  createBBar,
+  createBar,
+  saveBBarsToTestResult,
+  saveBarsToTestResult,
+  logTestResult,
+} from "./helpers";
+
+export function handleTestEvent(event: TestEvent): void {
+  let testResult = new TestResult(event.params.testCommand);
+  handleTestEventForID(event, testResult);
+  handleTestEventForBytesAsIDs(event, testResult);
+  logTestResult(testResult);
+  testResult.save();
+}
+
+function handleTestEventForID(event: TestEvent, testResult: TestResult): void {
+  // This test is to check that the derived entities are loaded correctly
+  // in the case where the derived entities are created in the same handler call
+  // ie: updates are coming from `entity_cache.handler_updates`
+  if (event.params.testCommand == "1_0") {
+    let foo = new Foo("0");
+    foo.value = 0;
+    foo.save();
+
+    let bar = createBar("0", "0", 0, 0);
+    let bar1 = createBar("1", "0", 0, 0);
+    let bar2 = createBar("2", "0", 0, 0);
+
+    let fooLoaded = Foo.load("0");
+    let barDerived = fooLoaded!.bar.load();
+
+    saveBarsToTestResult(barDerived, testResult, event.params.testCommand);
+
+    // bar0, bar1, bar2 should be loaded
+    assertBarsArrayEqual(barDerived, [bar, bar1, bar2]);
+  }
+
+  // This test is to check that the derived entities are loaded correctly
+  // in the case where the derived entities are created in the same block
+  // ie: updates are coming from `entity_cache.updates`
+  if (event.params.testCommand == "1_1") {
+    let fooLoaded = Foo.load("0");
+
+    let barLoaded = Bar.load("0");
+    barLoaded!.value = 1;
+    barLoaded!.save();
+
+    // remove bar1 to test that it is not loaded
+    // This tests the case where the entity is present in `entity_cache.updates` but is removed by
+    // An update from `entity_cache.handler_updates`
+    store.remove("Bar", "1");
+
+    let barDerivedLoaded = fooLoaded!.bar.load();
+    saveBarsToTestResult(
+      barDerivedLoaded,
+      testResult,
+      event.params.testCommand
+    );
+
+    // bar1 should not be loaded as it was removed
+    assert(barDerivedLoaded.length == 2, "barDerivedLoaded.length != 2");
+    // bar0 should be loaded with the updated value
+    assertBarsEqual(barDerivedLoaded[0], barLoaded!);
+  }
+
+  if (event.params.testCommand == "2_0") {
+    let fooLoaded = Foo.load("0");
+    let barDerived = fooLoaded!.bar.load();
+
+    // update bar0
+    // This tests the case where the entity is present in `store` but is updated by
+    // An update from `entity_cache.handler_updates`
+    let barLoaded = Bar.load("0");
+    barLoaded!.value = 2;
+    barLoaded!.save();
+
+    // remove bar2 to test that it is not loaded
+    // This tests the case where the entity is present in store but is removed by
+    // An update from `entity_cache.handler_updates`
+    store.remove("Bar", "2");
+
+    let barDerivedLoaded = fooLoaded!.bar.load();
+    assert(barDerivedLoaded.length == 1, "barDerivedLoaded.length != 1");
+    // bar0 should be loaded with the updated value
+    assertBarsEqual(barDerivedLoaded[0], barLoaded!);
+
+    saveBarsToTestResult(
+      barDerivedLoaded,
+      testResult,
+      event.params.testCommand
+    );
+  }
+}
+
+// Same as handleTestEventForID but uses Bytes as IDs
+function handleTestEventForBytesAsIDs(
+  event: TestEvent,
+  testResult: TestResult
+): void {
+  if (event.params.testCommand == "1_0") {
+    let bFoo = new BFoo(Bytes.fromUTF8("0"));
+    bFoo.value = 0;
+    bFoo.save();
+
+    let bBar = createBBar(Bytes.fromUTF8("0"), Bytes.fromUTF8("0"), 0, 0);
+    let bBar1 = createBBar(Bytes.fromUTF8("1"), Bytes.fromUTF8("0"), 0, 0);
+    let bBar2 = createBBar(Bytes.fromUTF8("2"), Bytes.fromUTF8("0"), 0, 0);
+
+    let bFooLoaded = BFoo.load(Bytes.fromUTF8("0"));
+    let bBarDerived: BBar[] = bFooLoaded!.bar.load();
+
+    saveBBarsToTestResult(bBarDerived, testResult, event.params.testCommand);
+
+    assertBBarsArrayEqual(bBarDerived, [bBar, bBar1, bBar2]);
+  }
+
+  if (event.params.testCommand == "1_1") {
+    let bFooLoaded = BFoo.load(Bytes.fromUTF8("0"));
+    let bBarDerived = bFooLoaded!.bar.load();
+
+    let bBarLoaded = BBar.load(Bytes.fromUTF8("0"));
+    bBarLoaded!.value = 1;
+    bBarLoaded!.save();
+
+    store.remove("BBar", Bytes.fromUTF8("1").toHex());
+
+    let bBarDerivedLoaded = bFooLoaded!.bar.load();
+    saveBBarsToTestResult(
+      bBarDerivedLoaded,
+      testResult,
+      event.params.testCommand
+    );
+
+    assert(bBarDerivedLoaded.length == 2, "bBarDerivedLoaded.length != 2");
+    assertBBarsEqual(bBarDerivedLoaded[0], bBarLoaded!);
+  }
+
+  if (event.params.testCommand == "2_0") {
+    let bFooLoaded = BFoo.load(Bytes.fromUTF8("0"));
+    let bBarDerived = bFooLoaded!.bar.load();
+
+    let bBarLoaded = BBar.load(Bytes.fromUTF8("0"));
+    bBarLoaded!.value = 2;
+    bBarLoaded!.save();
+
+    store.remove("BBar", Bytes.fromUTF8("2").toHex());
+
+    let bBarDerivedLoaded = bFooLoaded!.bar.load();
+    saveBBarsToTestResult(
+      bBarDerivedLoaded,
+      testResult,
+      event.params.testCommand
+    );
+
+    assert(bBarDerivedLoaded.length == 1, "bBarDerivedLoaded.length != 1");
+    assertBBarsEqual(bBarDerivedLoaded[0], bBarLoaded!);
+  }
+}
\ No newline at end of file
diff --git a/tests/runner-tests/derived-loaders/subgraph.yaml b/tests/runner-tests/derived-loaders/subgraph.yaml
new file mode 100644
index 00000000000..99d5a09db46
--- /dev/null
+++ b/tests/runner-tests/derived-loaders/subgraph.yaml
@@ -0,0 +1,23 @@
+specVersion: 0.0.4
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "0x0000000000000000000000000000000000000000"
+      abi: Contract
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.6
+      language: wasm/assemblyscript
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      entities:
+        - Call
+      eventHandlers:
+        - event: TestEvent(string)
+          handler: handleTestEvent
+      file: ./src/mapping.ts
diff --git a/tests/runner-tests/dynamic-data-source/package.json b/tests/runner-tests/dynamic-data-source/package.json
index 7e31db5c444..2adee43df73 100644
--- a/tests/runner-tests/dynamic-data-source/package.json
+++ b/tests/runner-tests/dynamic-data-source/package.json
@@ -1,25 +1,13 @@
 {
   "name": "dynamic-data-source",
-  "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/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": {
-    "@graphprotocol/graph-cli": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main",
-    "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-cli": "0.60.0",
+    "@graphprotocol/graph-ts": "0.31.0"
   }
 }
diff --git a/tests/runner-tests/end-block/abis/Contract.abi b/tests/runner-tests/end-block/abis/Contract.abi
new file mode 100644
index 00000000000..9d9f56b9263
--- /dev/null
+++ b/tests/runner-tests/end-block/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/end-block/package.json b/tests/runner-tests/end-block/package.json
new file mode 100644
index 00000000000..2d20109c509
--- /dev/null
+++ b/tests/runner-tests/end-block/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "end-block",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "codegen": "graph codegen --skip-migrations",
+    "deploy:test": "graph deploy test/end-block --version-label v0.0.1 --ipfs $IPFS_URI --node $GRAPH_NODE_ADMIN_URI"
+  },
+  "devDependencies": {
+    "@graphprotocol/graph-cli": "0.54.0-alpha-20230727052453-1e0e6e5",
+    "@graphprotocol/graph-ts": "0.30.0"
+  }
+}
diff --git a/tests/runner-tests/end-block/schema.graphql b/tests/runner-tests/end-block/schema.graphql
new file mode 100644
index 00000000000..c1afe145b8c
--- /dev/null
+++ b/tests/runner-tests/end-block/schema.graphql
@@ -0,0 +1,12 @@
+type Block @entity {
+  id: ID!
+  hash: String!
+  number: BigInt!
+}
+
+type TestEventEntity @entity {
+  id: ID!
+  blockHash: String!
+  blockNumber: BigInt!
+  command: String!
+}
diff --git a/tests/runner-tests/end-block/src/mapping.ts b/tests/runner-tests/end-block/src/mapping.ts
new file mode 100644
index 00000000000..0ce2ef94eb3
--- /dev/null
+++ b/tests/runner-tests/end-block/src/mapping.ts
@@ -0,0 +1,23 @@
+import {
+  ethereum,
+} from '@graphprotocol/graph-ts';
+import { TestEvent } from '../generated/Contract/Contract';
+import { Block, TestEventEntity } from '../generated/schema';
+
+export function handleBlock(block: ethereum.Block): void {
+  let entity = new Block(block.number.toHex());
+  entity.number = block.number;
+  entity.hash = block.hash.toHexString();
+  entity.save();
+}
+
+export function handleTestEvent(event: TestEvent): void {
+  let command = event.params.testCommand;
+  let entity = new TestEventEntity(
+    event.transaction.hash.toHex() + "-" + event.logIndex.toString(),
+  );
+  entity.blockNumber = event.block.number;
+  entity.blockHash = event.block.hash.toHexString();
+  entity.command = command;
+  entity.save();
+}
diff --git a/tests/runner-tests/end-block/subgraph.yaml b/tests/runner-tests/end-block/subgraph.yaml
new file mode 100644
index 00000000000..76ed7ca3cd5
--- /dev/null
+++ b/tests/runner-tests/end-block/subgraph.yaml
@@ -0,0 +1,46 @@
+specVersion: 0.0.9
+schema:
+  file: ./schema.graphql
+dataSources:
+  - kind: ethereum/contract
+    name: Contract
+    network: test
+    source:
+      address: "0x0000000000000000000000000000000000000000"
+      abi: Contract
+      endBlock: 8
+    mapping:
+      kind: ethereum/events
+      apiVersion: 0.0.7
+      language: wasm/assemblyscript
+      entities:
+        - Gravatar
+      abis:
+        - name: Contract
+          file: ./abis/Contract.abi
+      blockHandlers:
+        - handler: handleBlock
+      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/end-block/substreams-test-v1.0.1.spkg b/tests/runner-tests/end-block/substreams-test-v1.0.1.spkg
new file mode 100644
index 00000000000..641e2786a4a
Binary files /dev/null and b/tests/runner-tests/end-block/substreams-test-v1.0.1.spkg differ
diff --git a/tests/runner-tests/fatal-error/package.json b/tests/runner-tests/fatal-error/package.json
index 2df8ce04bf0..41b7164985f 100644
--- a/tests/runner-tests/fatal-error/package.json
+++ b/tests/runner-tests/fatal-error/package.json
@@ -1,20 +1,13 @@
 {
   "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": {
-    "@graphprotocol/graph-cli": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main",
-    "solc": "^0.8.2"
-  },
-  "dependencies": {
-    "apollo-fetch": "^0.7.0",
-    "babel-polyfill": "^6.26.0",
-    "babel-register": "^6.26.0",
-    "gluegun": "^4.6.1"
+    "@graphprotocol/graph-cli": "0.60.0",
+    "@graphprotocol/graph-ts": "0.31.0"
   }
 }
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 5aa79b0f6b3..e29a94f75d9 100644
--- a/tests/runner-tests/file-data-sources/package.json
+++ b/tests/runner-tests/file-data-sources/package.json
@@ -1,13 +1,13 @@
 {
   "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": {
-    "@graphprotocol/graph-cli": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main"
+    "@graphprotocol/graph-cli": "0.60.0",
+    "@graphprotocol/graph-ts": "0.31.0"
   }
 }
diff --git a/tests/runner-tests/file-data-sources/schema.graphql b/tests/runner-tests/file-data-sources/schema.graphql
index 48408ae69a2..4b0112f29c0 100644
--- a/tests/runner-tests/file-data-sources/schema.graphql
+++ b/tests/runner-tests/file-data-sources/schema.graphql
@@ -1,9 +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!
-}
\ No newline at end of file
+  ipfs: FileEntity @derivedFrom(field: "foo")
+}
diff --git a/tests/runner-tests/file-data-sources/src/mapping.ts b/tests/runner-tests/file-data-sources/src/mapping.ts
index dbd8013908d..a7f6ffa70ab 100644
--- a/tests/runner-tests/file-data-sources/src/mapping.ts
+++ b/tests/runner-tests/file-data-sources/src/mapping.ts
@@ -1,87 +1,154 @@
-import { ethereum, dataSource, BigInt, Bytes, DataSourceContext } from '@graphprotocol/graph-ts'
-import { TestEvent } from '../generated/Contract/Contract'
-import { IpfsFile, IpfsFile1 } from '../generated/schema'
-
-// CID of `file-data-sources/abis/Contract.abi` after being processed by graph-cli.
-const KNOWN_CID = "QmQ2REmceVtzawp7yrnxLQXgNNCtFHEnig6fL9aqE1kcWq"
-
-export function handleBlock(block: ethereum.Block): void {
-  let entity = new IpfsFile("onchain")
-  entity.content = "onchain"
-  entity.save()
-
-  // 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])
+import {
+  ethereum,
+  dataSource,
+  BigInt,
+  Bytes,
+  DataSourceContext,
+  store,
+  log,
+} from "@graphprotocol/graph-ts";
+import { TestEvent } from "../generated/Contract/Contract";
+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(),
+    );
   }
 
-  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 == 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);
+
+    log.info(
+      "Creating file data source from handleFile, command : {} ,hash1: {}, hash2: {}",
+      [SPAWN_FDS_FROM_OFFCHAIN_HANDLER, hash1, hash2],
+    );
+    dataSource.createWithContext("File", [hash1], context);
+  }
 
-    // Test that using an invalid CID will be ignored
-    dataSource.create("File", ["hi, I'm not valid"])
+  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);
   }
 
+  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"
-    entity.save()
-  } else if (command == "createFile1") {
-    // Will fail the subgraph with a conflict between two entities created by offchain data sources.
+  if (event.params.testCommand == CREATE_FOO) {
+    let entity = new Foo(event.params.data);
+    entity.save();
     let context = new DataSourceContext();
-    context.setBytes("hash", event.block.hash);
-    dataSource.createWithContext("File1", [KNOWN_CID], context)
-  } else {
-    assert(false, "Unknown command: " + command);
+    context.setString("command", CREATE_FOO);
+    dataSource.createWithContext("File", [event.params.data], context);
+  }
+
+  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();
+
+      assert(fileEntity.length == 0, "Expected exactly one file entity");
+    }
   }
 }
 
 export function handleFile(data: Bytes): void {
-  // Test that offchain data sources cannot read onchain data.
-  assert(IpfsFile.load("onchain") == null);
+  log.info('handleFile {}', [dataSource.stringParam()]);
+  let context = dataSource.context();
 
-  if (dataSource.stringParam() != "QmVkvoPGi9jvvuxsHDVJDgzPEzagBaWSZRYoRDzU244HjZ") {
-    // Test that an offchain data source cannot read from another offchain data source.
-    assert(IpfsFile.load("QmVkvoPGi9jvvuxsHDVJDgzPEzagBaWSZRYoRDzU244HjZ") == null);
-  }
+  if (!context.isSet('command')) {
+    log.info('Creating FileEntity from handleFile: {} , content : {}', [
+      dataSource.stringParam(),
+      data.toString(),
+    ]);
 
-  let entity = new IpfsFile(dataSource.stringParam())
-  entity.content = data.toString()
-  entity.save()
+    let entity = new FileEntity(dataSource.stringParam());
+    entity.content = data.toString();
+    entity.save();
 
-  // Test that an offchain data source can load its own entities
-  let loaded_entity = IpfsFile.load(dataSource.stringParam())!
-  assert(loaded_entity.content == entity.content)
-}
+    return;
+  }
 
-export function handleFile1(data: Bytes): void {
-  let entity = new IpfsFile1(dataSource.stringParam())
-  entity.content = data.toString()
-  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 502faccdff6..5438b43c9f2 100644
--- a/tests/runner-tests/file-data-sources/subgraph.yaml
+++ b/tests/runner-tests/file-data-sources/subgraph.yaml
@@ -13,53 +13,44 @@ 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:
-  - kind: file/ipfs
-    name: File
+  - kind: ethereum/contract
+    name: OnChainDataSource
+    network: test
+    source:
+      abi: Contract
     mapping:
       kind: ethereum/events
       apiVersion: 0.0.7
       language: wasm/assemblyscript
       entities:
-        - IpfsFile
+        - Gravatar
       abis:
         - name: Contract
           file: ./abis/Contract.abi
-      handler: handleFile
+      eventHandlers:
+        - event: TestEvent(string,string)
+          handler: handleTestEvent
       file: ./src/mapping.ts
   - kind: file/ipfs
-    name: File1
+    name: File
     mapping:
       kind: ethereum/events
       apiVersion: 0.0.7
       language: wasm/assemblyscript
       entities:
-        - IpfsFile1
+        - FileEntity
       abis:
         - name: Contract
           file: ./abis/Contract.abi
-      handler: handleFile1
+      handler: handleFile
       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
\ 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 c35ae39ad3d..00000000000
--- a/tests/runner-tests/package.json
+++ /dev/null
@@ -1,11 +0,0 @@
-{
-  "private": true,
-  "workspaces": [
-    "data-source-revert",
-    "data-source-revert2",
-    "dynamic-data-source",
-    "fatal-error",
-    "file-data-sources",
-    "typename"
-  ]
-}
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/typename/package.json b/tests/runner-tests/typename/package.json
index 4d4d46b63e6..047227cdbe7 100644
--- a/tests/runner-tests/typename/package.json
+++ b/tests/runner-tests/typename/package.json
@@ -1,13 +1,13 @@
 {
   "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": {
-    "@graphprotocol/graph-cli": "https://github.com/graphprotocol/graph-cli#main",
-    "@graphprotocol/graph-ts": "https://github.com/graphprotocol/graph-ts#main"
+    "@graphprotocol/graph-cli": "0.50.0",
+    "@graphprotocol/graph-ts": "0.30.0"
   }
 }
diff --git a/tests/runner-tests/yarn.lock b/tests/runner-tests/yarn.lock
deleted file mode 100644
index df7ba6fc49a..00000000000
--- a/tests/runner-tests/yarn.lock
+++ /dev/null
@@ -1,12557 +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/runtime@^7.9.2":
-  version "7.18.9"
-  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.18.9.tgz#b4fcfce55db3d2e5e080d2490f608a3b9f407f4a"
-  integrity sha512-lkqXDcvlFT5rvEjiu6+QYO+1GXrEHRo2LOtS7E4GtX5ESIZOgepqsZBVIj6Pv+a6zqsya9VCgiK1KAK4BvJDAw==
-  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"
-
-"@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"
-
-"@graphprotocol/graph-cli@https://github.com/graphprotocol/graph-cli#main":
-  version "0.33.0"
-  resolved "https://github.com/graphprotocol/graph-cli#47e075a9701680580e0e8e09c5444963224dbf5c"
-  dependencies:
-    assemblyscript "0.19.10"
-    binary-install-raw "0.0.13"
-    chalk "3.0.0"
-    chokidar "3.5.1"
-    debug "4.3.1"
-    docker-compose "0.23.4"
-    dockerode "2.5.8"
-    fs-extra "9.0.0"
-    glob "7.1.6"
-    gluegun "https://github.com/edgeandnode/gluegun#v4.3.1-pin-colors-dep"
-    graphql "15.5.0"
-    immutable "3.8.2"
-    ipfs-http-client "34.0.0"
-    jayson "3.6.6"
-    js-yaml "3.13.1"
-    node-fetch "2.6.0"
-    pkginfo "0.4.1"
-    prettier "1.19.1"
-    request "2.88.2"
-    semver "7.3.5"
-    sync-request "6.1.0"
-    tmp-promise "3.0.2"
-    web3-eth-abi "1.7.0"
-    which "2.0.2"
-    yaml "1.9.2"
-
-"@graphprotocol/graph-ts@https://github.com/graphprotocol/graph-ts#main":
-  version "0.28.1"
-  resolved "https://github.com/graphprotocol/graph-ts#4e91d2c0b695c7689aba205516d3e80fb5588454"
-  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"
-
-"@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==
-
-"@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"
-
-"@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==
-
-"@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"
-
-"@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/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-serve-static-core@^4.17.9":
-  version "4.17.30"
-  resolved "https://registry.yarnpkg.com/@types/express-serve-static-core/-/express-serve-static-core-4.17.30.tgz#0f2f99617fa8f9696170c46152ccf7500b34ac04"
-  integrity sha512-gstzbTWro2/nFed1WXtf+TtrpwxH7Ggs4RLYTLbeVgIkUQOI3WG/JKjgeOU1zXDvezllupjrf8OPIdvTbIaVOQ==
-  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/lodash@^4.14.159":
-  version "4.14.184"
-  resolved "https://registry.yarnpkg.com/@types/lodash/-/lodash-4.14.184.tgz#23f96cd2a21a28e106dc24d825d4aa966de7a9fe"
-  integrity sha512-RoZphVtHbxPZizt4IcILciSWiC6dcn+eZ8oX9IWEYfDMcocdd42f7NPI6fQj+6zI8y4E0L7gu2pcZKLGTRaV9Q==
-
-"@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/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/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@^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==
-
-"@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@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=
-
-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-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:
-  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"
-
-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=
-
-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"
-
-apisauce@^1.0.1:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/apisauce/-/apisauce-1.1.5.tgz#31d41a5cf805e401266cec67faf1a50f4aeae234"
-  integrity sha512-gKC8qb/bDJsPsnEXLZnXJ7gVx7dh87CEVNeIwv1dvaffnXoh5GHwac5pWR1P2broLiVj/fqFMQvLDDt/RhjiqA==
-  dependencies:
-    axios "^0.21.2"
-    ramda "^0.25.0"
-
-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"
-
-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"
-
-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"
-
-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=
-
-asmcrypto.js@^2.3.2:
-  version "2.3.2"
-  resolved "https://registry.yarnpkg.com/asmcrypto.js/-/asmcrypto.js-2.3.2.tgz#b9f84bd0a1fb82f21f8c29cc284a707ad17bba2e"
-  integrity sha512-3FgFARf7RupsZETQ1nHnhLUUvpcttcCq1iZCaVAbJZbCZ5VNRrNyvpDyHTOb0KC3llFcsyOT/a99NZcCbeiEsA==
-
-asn1.js@^5.0.1, 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"
-
-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"
-
-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==
-
-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@^2.6.1, async@^2.6.2, async@^2.6.3:
-  version "2.6.4"
-  resolved "https://registry.yarnpkg.com/async/-/async-2.6.4.tgz#706b7ff6084664cd7eae713f6f965433b5504221"
-  integrity sha512-mzo5dfJYwAn29PeiJ0zvwTo04zj8HDJj0Mn8TD7sno7q12prdbnasKJHhkm2c1LgrhlJ0teaea8860oxi51mGA==
-  dependencies:
-    lodash "^4.17.14"
-
-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.2:
-  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==
-
-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"
-
-bip66@^1.1.5:
-  version "1.1.5"
-  resolved "https://registry.yarnpkg.com/bip66/-/bip66-1.1.5.tgz#01fa8748785ca70955d5011217d1b3139969ca22"
-  integrity sha512-nemMHz95EmS38a26XbbdxIYj5csHd3RMP3H5bwQknX0WYHF01qhpufP42mLOwVICuH2JmhIhXiWs89MfUGL7Xw==
-  dependencies:
-    safe-buffer "^5.0.1"
-
-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"
-
-bl@^3.0.0:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/bl/-/bl-3.0.1.tgz#1cbb439299609e419b5a74d7fce2f8b37d8e5c6f"
-  integrity sha512-jrCW5ZhfQ/Vt07WX1Ngs+yn9BDqPL/gw28S7s9H6QK/gupnizNzJAss5akW20ISgOrbLTlXOOCTJeNUQqruAWQ==
-  dependencies:
-    readable-stream "^3.0.1"
-
-bl@^4.0.3:
-  version "4.1.0"
-  resolved "https://registry.yarnpkg.com/bl/-/bl-4.1.0.tgz#451535264182bec2fbbc83a62ab98cf11d9f7b3a"
-  integrity sha512-1W07cM9gS6DcLperZfFSj+bWLtaPGSOHWhPiGzXmvVJbRLdG82sH/Kn8EtW1VqWVA54AKf2h5k5BbnIbwF3h6w==
-  dependencies:
-    buffer "^5.5.0"
-    inherits "^2.0.4"
-    readable-stream "^3.4.0"
-
-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==
-
-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=
-
-borc@^2.1.2:
-  version "2.1.2"
-  resolved "https://registry.yarnpkg.com/borc/-/borc-2.1.2.tgz#6ce75e7da5ce711b963755117dd1b187f6f8cf19"
-  integrity sha512-Sy9eoUi4OiKzq7VovMn246iTo17kzuyHJKomCfpWMlI6RpfN1gk95w7d7gH264nApVLg0HZfcpz62/g4VH1Y4w==
-  dependencies:
-    bignumber.js "^9.0.0"
-    buffer "^5.5.0"
-    commander "^2.15.0"
-    ieee754 "^1.1.13"
-    iso-url "~0.4.7"
-    json-text-sequence "~0.1.0"
-    readable-stream "^3.6.0"
-
-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"
-
-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:
-  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-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.0.6, 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, bs58@^4.0.1:
-  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.4.2, buffer@^5.4.3, 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.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"
-
-builtin-status-codes@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/builtin-status-codes/-/builtin-status-codes-3.0.0.tgz#85982878e21b98e1c66425e03d0174788f569ee8"
-  integrity sha512-HpGFw18DgFWlncDfjTa2rcQ4W88O1mC8e8yZ2AvQY5KDaktSTwo+KRf6nHK6FRI5FyRyb/5T6+TSxfP7QyGsmQ==
-
-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"
-
-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==
-
-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"
-
-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.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.1:
-  version "3.5.1"
-  resolved "https://registry.yarnpkg.com/chokidar/-/chokidar-3.5.1.tgz#ee9ce7bbebd2b79f49f304799d5468e31e14e68a"
-  integrity sha512-9+s+Od+W0VJJzawDma/gvBNQqkTiqYTWLuZoyAsivsI4AaWTCzHG06/TMjsf1cYe9Cb97UCEhjz7HvnPk2p/tw==
-  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.5.0"
-  optionalDependencies:
-    fsevents "~2.3.1"
-
-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, cids@~0.7.0, 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"
-
-cids@~0.8.0:
-  version "0.8.3"
-  resolved "https://registry.yarnpkg.com/cids/-/cids-0.8.3.tgz#aaf48ac8ed857c3d37dad94d8db1d8c9407b92db"
-  integrity sha512-yoXTbV3llpm+EBGWKeL9xKtksPE/s6DPoDSY4fn8I8TEW1zehWXPSB0pwAXVDlLaOlrw+sNynj995uD9abmPhA==
-  dependencies:
-    buffer "^5.6.0"
-    class-is "^1.1.0"
-    multibase "^1.0.0"
-    multicodec "^1.0.1"
-    multihashes "^1.0.1"
-
-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==
-
-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-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.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.3.3:
-  version "1.3.3"
-  resolved "https://registry.yarnpkg.com/colors/-/colors-1.3.3.tgz#39e005d546afe01e01f9c4ca8fa50f686a01205d"
-  integrity sha512-mmGt/1pZqYRjMxB1axhTo16/snVZ5krrKkcmMeVKxzECMMXoCgnvTPp10QgHfcbQZw8Dq2jMNG6je4JlWU0gWg==
-
-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.15.0, 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"
-
-"concat-stream@github:hugomrdias/concat-stream#feat/smaller":
-  version "2.0.0"
-  resolved "https://codeload.github.com/hugomrdias/concat-stream/tar.gz/057bc7b5d6d8df26c8cf00a3f151b6721a0a8034"
-  dependencies:
-    inherits "^2.0.3"
-    readable-stream "^3.0.2"
-
-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"
-
-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"
-
-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.0:
-  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"
-
-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.1:
-  version "4.3.1"
-  resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.1.tgz#f0d229c505e0c6d8c49ac553d1b13dc183f6b2ee"
-  integrity sha512-doEwdvm4PCeK4K3RQN2ZC2BYUBaxwLARCqZmMjtF8a51J2Rb0xpVloFRnCODwqjpwnAoao4pelN8l3RJdv3gRQ==
-  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"
-
-debug@^4.1.0, debug@^4.1.1, debug@^4.3.1:
-  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"
-
-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=
-
-delimit-stream@0.1.0:
-  version "0.1.0"
-  resolved "https://registry.yarnpkg.com/delimit-stream/-/delimit-stream-0.1.0.tgz#9b8319477c0e5f8aeb3ce357ae305fc25ea1cd2b"
-  integrity sha512-a02fiQ7poS5CnjiJBAsjGLPp5EwVoGHNeu9sziBd9huppRfsAFIpv5zNLv0V1gbop53ilngAf5Kf331AwcoRBQ==
-
-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=
-
-detect-node@^2.0.4:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/detect-node/-/detect-node-2.1.0.tgz#c9c70775a49c3d03bc2c06d9a73be550f978f8b1"
-  integrity sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==
-
-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:
-  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"
-
-docker-compose@0.23.4:
-  version "0.23.4"
-  resolved "https://registry.yarnpkg.com/docker-compose/-/docker-compose-0.23.4.tgz#43bcabcde55a6ba2873b52fe0ccd99dd8fdceba8"
-  integrity sha512-yWdXby9uQ8o4syOfvoSJ9ZlTnLipvUmDn59uaYY5VGIUSUAfMPPGqE1DE3pOCnfSg9Tl9UOOFO0PCSAzuIHmuA==
-
-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=
-
-drbg.js@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/drbg.js/-/drbg.js-1.0.1.tgz#3e36b6c42b37043823cdbc332d58f31e2445480b"
-  integrity sha512-F4wZ06PvqxYLFEZKkFxTDcns9oFNk34hvmJSEwdzsxVQ8YI5YaxtACgQatkYgv2VI2CFkUd2Y+xosPQnHv809g==
-  dependencies:
-    browserify-aes "^1.0.6"
-    create-hash "^1.1.2"
-    create-hmac "^1.1.4"
-
-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@^2.6.1:
-  version "2.7.4"
-  resolved "https://registry.yarnpkg.com/ejs/-/ejs-2.7.4.tgz#48661287573dcc53e366c7a1ae52c3a120eec9ba"
-  integrity sha512-7vmuyh5+kuUyJKePhQfRQBhXV5Ce+RnaeeQArKu1EAMpL3WbgMt5WG6uQZpEVvYSSsxMXRKOewtDk9RaTKXRlA==
-
-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:
-  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, end-of-stream@^1.4.1:
-  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"
-
-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@^1.1.2:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/err-code/-/err-code-1.1.2.tgz#06e0116d3028f6aef4806849eb0ea6a748ae6960"
-  integrity sha512-CJAN+O0/yA1CKfRn9SXOGctSpEM7DCon/r/5r2eXFMY2zCCJBasFhcM5I+1kh3Ap11FsQCX+vGHceNPvpWKhoA==
-
-err-code@^2.0.0:
-  version "2.0.3"
-  resolved "https://registry.yarnpkg.com/err-code/-/err-code-2.0.3.tgz#23c2f3b756ffdfc608d30e27c9a941024807e7f9"
-  integrity sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==
-
-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:
-  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@^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"
-
-explain-error@^1.0.4:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/explain-error/-/explain-error-1.0.4.tgz#a793d3ac0cad4c6ab571e9968fbbab6cb2532929"
-  integrity sha512-/wSgNMxFusiYRy1rd19LT2SQlIXDppHpumpWo06wxjflD1OYxDLbl6rMVw+U3bxD5Nuhex4TKqv9Aem4D0lVzQ==
-
-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-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-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-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@~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-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==
-
-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==
-
-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"
-
-flatmap@0.0.3:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/flatmap/-/flatmap-0.0.3.tgz#1f18a4d938152d495965f9c958d923ab2dd669b4"
-  integrity sha512-OuR+o7kHVe+x9RtIujPay7Uw3bvDZBZFSBXClEphZuSDLmZTqMdclasf4vFSsogC8baDz0eaC2NdO/2dlXHBKQ==
-
-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.0.0:
-  version "9.0.0"
-  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-9.0.0.tgz#b6afc31036e247b2466dc99c29ae797d5d4580a3"
-  integrity sha512-pmEYSk3vYsG/bF651KPUXZ+hvjpgWYw/Gc7W9NFUe3ZVLczKKWIij3IKpOrQcdw4TILtibFslZ0UmR8Vvzig4g==
-  dependencies:
-    at-least-node "^1.0.0"
-    graceful-fs "^4.2.0"
-    jsonfile "^6.0.1"
-    universalify "^1.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-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-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.1:
-  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-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-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.0:
-  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@^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"
-
-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"
-
-"gluegun@https://github.com/edgeandnode/gluegun#v4.3.1-pin-colors-dep":
-  version "4.3.1"
-  resolved "https://github.com/edgeandnode/gluegun#b34b9003d7bf556836da41b57ef36eb21570620a"
-  dependencies:
-    apisauce "^1.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-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==
-
-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"
-
-hi-base32@~0.5.0:
-  version "0.5.1"
-  resolved "https://registry.yarnpkg.com/hi-base32/-/hi-base32-0.5.1.tgz#1279f2ddae2673219ea5870c2121d2a33132857e"
-  integrity sha512-EmBBpvdYh/4XxsnUybsPag6VikPYnN30td+vQk+GI3qpahVEG9+gTkG0aXVxTjBqQ5T6ijbWIu77O+C5WFWsnA==
-
-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==
-
-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==
-
-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@3.8.2:
-  version "3.8.2"
-  resolved "https://registry.yarnpkg.com/immutable/-/immutable-3.8.2.tgz#c2439951455bb39913daf281376f1530e104adf3"
-  integrity sha1-wkOZUUVbs5kT2vKBN28VMOEErfM=
-
-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:
-  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=
-
-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==
-
-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@^2.0.0:
-  version "2.1.0"
-  resolved "https://registry.yarnpkg.com/ip-regex/-/ip-regex-2.1.0.tgz#fa78bf5d2e6913c911ce9f819ee5146bb6d844e9"
-  integrity sha512-58yWmlHpp7VYfcdTwMTvwMmqx/Elfxjd9RXTDyMsbL7lLWmhMylLEqiYVLKuLzOZqVgiWXD9MfR62Vv89VRxkw==
-
-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==
-
-ip@^1.1.5:
-  version "1.1.8"
-  resolved "https://registry.yarnpkg.com/ip/-/ip-1.1.8.tgz#ae05948f6b075435ed3307acce04629da8cdbf48"
-  integrity sha512-PuExPYUiu6qMBQb4l06ecm6T6ujzhmh+MeJcW9wa89PoAz5pvd4zPgN5WJV104mb6S2T1AwNIAaB70JNrLQWhg==
-
-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-block@~0.8.1:
-  version "0.8.1"
-  resolved "https://registry.yarnpkg.com/ipfs-block/-/ipfs-block-0.8.1.tgz#05e1068832775e8f1c2da5b64106cc837fd2acb9"
-  integrity sha512-0FaCpmij+jZBoUYhjoB5ptjdl9QzvrdRIoBmUU5JiBnK2GA+4YM/ifklaB8ePRhA/rRzhd+KYBjvMFMAL4NrVQ==
-  dependencies:
-    cids "~0.7.0"
-    class-is "^1.1.0"
-
-ipfs-http-client@34.0.0:
-  version "34.0.0"
-  resolved "https://registry.yarnpkg.com/ipfs-http-client/-/ipfs-http-client-34.0.0.tgz#8804d06a11c22306332a8ffa0949b6f672a0c9c8"
-  integrity sha512-4RCkk8ix4Dqn6sxqFVwuXWCZ1eLFPsVaj6Ijvu1fs9VYgxgVudsW9PWwarlr4mw1xUCmPWYyXnEbGgzBrfMy0Q==
-  dependencies:
-    abort-controller "^3.0.0"
-    async "^2.6.1"
-    bignumber.js "^9.0.0"
-    bl "^3.0.0"
-    bs58 "^4.0.1"
-    buffer "^5.4.2"
-    cids "~0.7.1"
-    concat-stream "github:hugomrdias/concat-stream#feat/smaller"
-    debug "^4.1.0"
-    detect-node "^2.0.4"
-    end-of-stream "^1.4.1"
-    err-code "^2.0.0"
-    explain-error "^1.0.4"
-    flatmap "0.0.3"
-    glob "^7.1.3"
-    ipfs-block "~0.8.1"
-    ipfs-utils "~0.0.3"
-    ipld-dag-cbor "~0.15.0"
-    ipld-dag-pb "~0.17.3"
-    ipld-raw "^4.0.0"
-    is-ipfs "~0.6.1"
-    is-pull-stream "0.0.0"
-    is-stream "^2.0.0"
-    iso-stream-http "~0.1.2"
-    iso-url "~0.4.6"
-    iterable-ndjson "^1.1.0"
-    just-kebab-case "^1.1.0"
-    just-map-keys "^1.1.0"
-    kind-of "^6.0.2"
-    ky "^0.11.2"
-    ky-universal "^0.2.2"
-    lru-cache "^5.1.1"
-    multiaddr "^6.0.6"
-    multibase "~0.6.0"
-    multicodec "~0.5.1"
-    multihashes "~0.4.14"
-    ndjson "github:hugomrdias/ndjson#feat/readable-stream3"
-    once "^1.4.0"
-    peer-id "~0.12.3"
-    peer-info "~0.15.1"
-    promise-nodeify "^3.0.1"
-    promisify-es6 "^1.0.3"
-    pull-defer "~0.2.3"
-    pull-stream "^3.6.9"
-    pull-to-stream "~0.1.1"
-    pump "^3.0.0"
-    qs "^6.5.2"
-    readable-stream "^3.1.1"
-    stream-to-pull-stream "^1.7.2"
-    tar-stream "^2.0.1"
-    through2 "^3.0.1"
-
-ipfs-utils@~0.0.3:
-  version "0.0.4"
-  resolved "https://registry.yarnpkg.com/ipfs-utils/-/ipfs-utils-0.0.4.tgz#946114cfeb6afb4454b4ccb10d2327cd323b0cce"
-  integrity sha512-7cZf6aGj2FG3XJWhCNwn4mS93Q0GEWjtBZvEHqzgI43U2qzNDCyzfS1pei1Y5F+tw/zDJ5U4XG0G9reJxR53Ig==
-  dependencies:
-    buffer "^5.2.1"
-    is-buffer "^2.0.3"
-    is-electron "^2.2.0"
-    is-pull-stream "0.0.0"
-    is-stream "^2.0.0"
-    kind-of "^6.0.2"
-    readable-stream "^3.4.0"
-
-ipld-dag-cbor@~0.15.0:
-  version "0.15.3"
-  resolved "https://registry.yarnpkg.com/ipld-dag-cbor/-/ipld-dag-cbor-0.15.3.tgz#283afdb81d5b07db8e4fff7a10ef5e517e87f299"
-  integrity sha512-m23nG7ZyoVFnkK55/bLAErc7EfiMgaEQlqHWDTGzPI+O5r6bPfp+qbL5zTVSIT8tpbHmu174dwerVtLoVgeVyA==
-  dependencies:
-    borc "^2.1.2"
-    buffer "^5.5.0"
-    cids "~0.8.0"
-    is-circular "^1.0.2"
-    multicodec "^1.0.0"
-    multihashing-async "~0.8.0"
-
-ipld-dag-pb@~0.17.3:
-  version "0.17.4"
-  resolved "https://registry.yarnpkg.com/ipld-dag-pb/-/ipld-dag-pb-0.17.4.tgz#080841cfdd014d996f8da7f3a522ec8b1f6b6494"
-  integrity sha512-YwCxETEMuXVspOKOhjIOHJvKvB/OZfCDkpSFiYBQN2/JQjM9y/RFCYzIQGm0wg7dCFLrhvfjAZLTSaKs65jzWA==
-  dependencies:
-    cids "~0.7.0"
-    class-is "^1.1.0"
-    multicodec "~0.5.1"
-    multihashing-async "~0.7.0"
-    protons "^1.0.1"
-    stable "~0.1.8"
-
-ipld-raw@^4.0.0:
-  version "4.0.1"
-  resolved "https://registry.yarnpkg.com/ipld-raw/-/ipld-raw-4.0.1.tgz#49a6f58cdfece5a4d581925b19ee19255be2a29d"
-  integrity sha512-WjIdtZ06jJEar8zh+BHB84tE6ZdbS/XNa7+XCArOYfmeJ/c01T9VQpeMwdJQYn5c3s5UvvCu7y4VIi3vk2g1bA==
-  dependencies:
-    cids "~0.7.0"
-    multicodec "^1.0.0"
-    multihashing-async "~0.8.0"
-
-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, 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-circular@^1.0.2:
-  version "1.0.2"
-  resolved "https://registry.yarnpkg.com/is-circular/-/is-circular-1.0.2.tgz#2e0ab4e9835f4c6b0ea2b9855a84acd501b8366c"
-  integrity sha512-YttjnrswnUYRVJvxCvu8z+PGMUSzC2JttP0OEXezlAEdp3EXzhf7IZ3j0gRAybJBQupedIZFhY61Tga6E0qASA==
-
-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-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@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/is-ip/-/is-ip-2.0.0.tgz#68eea07e8a0a0a94c2d080dd674c731ab2a461ab"
-  integrity sha512-9MTn0dteHETtyUx8pxqMwg5hMBi3pvlyglJ+b79KOCca0po23337LbVV2Hl4xmMvfw++ljnO0/+5G6G+0Szh6g==
-  dependencies:
-    ip-regex "^2.0.0"
-
-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-ipfs@~0.6.1:
-  version "0.6.3"
-  resolved "https://registry.yarnpkg.com/is-ipfs/-/is-ipfs-0.6.3.tgz#82a5350e0a42d01441c40b369f8791e91404c497"
-  integrity sha512-HyRot1dvLcxImtDqPxAaY1miO6WsiP/z7Yxpg2qpaLWv5UdhAPtLvHJ4kMLM0w8GSl8AFsVF23PHe1LzuWrUlQ==
-  dependencies:
-    bs58 "^4.0.1"
-    cids "~0.7.0"
-    mafmt "^7.0.0"
-    multiaddr "^7.2.1"
-    multibase "~0.6.0"
-    multihashes "~0.4.13"
-
-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-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-promise@~1, is-promise@~1.0.0:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/is-promise/-/is-promise-1.0.1.tgz#31573761c057e33c2e91aab9e96da08cefbe76e5"
-  integrity sha512-mjWH5XxnhMA8cFnDchr6qRP9S/kLntKuEfIYku+PaN1CnS8v+OG9O/BKpRCVRJvpIkgAZm0Pf5Is3iSSOILlcg==
-
-is-pull-stream@0.0.0:
-  version "0.0.0"
-  resolved "https://registry.yarnpkg.com/is-pull-stream/-/is-pull-stream-0.0.0.tgz#a3bc3d1c6d3055151c46bde6f399efed21440ca9"
-  integrity sha512-NWLwqCc95I6m8FZDYLAmVJc9Xgk8O+8pPOoDKFTC293FH4S7FBcbLCw3WWPCdiT8uUSdzPy47VM08WPDMJJrag==
-
-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"
-
-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-random-stream@^1.1.0:
-  version "1.1.2"
-  resolved "https://registry.yarnpkg.com/iso-random-stream/-/iso-random-stream-1.1.2.tgz#c703da2c518db573277c5678cc43c5298283d64c"
-  integrity sha512-7y0tsBBgQs544iTYjyrMp5xvgrbYR8b+plQq1Bryp+03p0LssrxC9C1M0oHv4QESDt7d95c74XvMk/yawKqX+A==
-  dependencies:
-    buffer "^6.0.3"
-    readable-stream "^3.4.0"
-
-iso-stream-http@~0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/iso-stream-http/-/iso-stream-http-0.1.2.tgz#b3dfea4c9f23ff26d078d40c539cfc0dfebacd37"
-  integrity sha512-oHEDNOysIMTNypbg2f1SlydqRBvjl4ZbSE9+0awVxnkx3K2stGTFwB/kpVqnB6UEfF8QD36kAjDwZvqyXBLMnQ==
-  dependencies:
-    builtin-status-codes "^3.0.0"
-    inherits "^2.0.1"
-    readable-stream "^3.1.1"
-
-iso-url@~0.4.6, iso-url@~0.4.7:
-  version "0.4.7"
-  resolved "https://registry.yarnpkg.com/iso-url/-/iso-url-0.4.7.tgz#de7e48120dae46921079fe78f325ac9e9217a385"
-  integrity sha512-27fFRDnPAMnHGLq36bWTpKET+eiXct3ENlCcdcMdk+mjXrb2kw3mhBUg1B7ewAC0kVzlOPhADzQgz1SE6Tglog==
-
-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"
-
-iterable-ndjson@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/iterable-ndjson/-/iterable-ndjson-1.1.0.tgz#36f7e8a5bb04fd087d384f29e44fc4280fc014fc"
-  integrity sha512-OOp1Lb0o3k5MkXHx1YaIY5Z0ELosZfTnBaas9f8opJVcZGBIONA2zY/6CYE+LKkqrSDooIneZbrBGgOZnHPkrg==
-  dependencies:
-    string_decoder "^1.2.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"
-
-jayson@3.6.6:
-  version "3.6.6"
-  resolved "https://registry.yarnpkg.com/jayson/-/jayson-3.6.6.tgz#189984f624e398f831bd2be8e8c80eb3abf764a1"
-  integrity sha512-f71uvrAWTtrwoww6MKcl9phQTC+56AopLyEenWvKVAIMz+q0oVGj6tenLZ7Z6UiPBkJtKLj4kt0tACllFQruGQ==
-  dependencies:
-    "@types/connect" "^3.4.33"
-    "@types/express-serve-static-core" "^4.17.9"
-    "@types/lodash" "^4.14.159"
-    "@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"
-    lodash "^4.17.20"
-    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, 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.13.1:
-  version "3.13.1"
-  resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.13.1.tgz#aff151b30bfdfa8e49e05da22e7415e9dfa37847"
-  integrity sha512-YfbcO7jXDdyj0DGxYVSlSeQNHbD7XPWvrVWeVUujrQEoZzWJIRrCPoyk6kL6IAjAG2IolMK4T0hNUe0HOUs5Jw==
-  dependencies:
-    argparse "^1.0.7"
-    esprima "^4.0.0"
-
-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"
-
-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==
-
-json-text-sequence@~0.1.0:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/json-text-sequence/-/json-text-sequence-0.1.1.tgz#a72f217dc4afc4629fff5feb304dc1bd51a2f3d2"
-  integrity sha512-L3mEegEWHRekSHjc7+sc8eJhba9Clq1PZ8kMkzf8OxElhXc8O4TS5MwcVlj9aEbm5dr81N90WHC5nAz3UO971w==
-  dependencies:
-    delimit-stream "0.1.0"
-
-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"
-
-just-kebab-case@^1.1.0:
-  version "1.1.0"
-  resolved "https://registry.yarnpkg.com/just-kebab-case/-/just-kebab-case-1.1.0.tgz#ebe854fde84b0afa4e597fcd870b12eb3c026755"
-  integrity sha512-QkuwuBMQ9BQHMUEkAtIA4INLrkmnnveqlFB1oFi09gbU0wBdZo6tTnyxNWMR84zHxBuwK7GLAwqN8nrvVxOLTA==
-
-just-map-keys@^1.1.0:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/just-map-keys/-/just-map-keys-1.2.1.tgz#ef6e16133b7d34329962dfae9101d581abb1b143"
-  integrity sha512-Dmyz1Cy2SWM+PpqDPB1kdDglyexdzMthnAsvOIE9w4OPj8NDRuY1mh20x/JfG5w6fCGw9F0WmcofJhYZ4MiuyA==
-
-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"
-
-keypair@^1.0.1:
-  version "1.0.4"
-  resolved "https://registry.yarnpkg.com/keypair/-/keypair-1.0.4.tgz#a749a45f388593f3950f18b3757d32a93bd8ce83"
-  integrity sha512-zwhgOhhniaL7oxMgUMKKw5219PWWABMO+dgMnzJOQ2/5L3XJtTJGhW2PEXlxXj9zaccdReZJZ83+4NPhVfNVDg==
-
-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, kind-of@^6.0.2:
-  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"
-
-ky-universal@^0.2.2:
-  version "0.2.2"
-  resolved "https://registry.yarnpkg.com/ky-universal/-/ky-universal-0.2.2.tgz#7a36e1a75641a98f878157463513965f799f5bfe"
-  integrity sha512-fb32o/fKy/ux2ALWa9HU2hvGtfOq7/vn2nH0FpVE+jwNzyTeORlAbj3Fiw+WLMbUlmVqZIWupnLZ2USHvqwZHw==
-  dependencies:
-    abort-controller "^3.0.0"
-    node-fetch "^2.3.0"
-
-ky@^0.11.2:
-  version "0.11.2"
-  resolved "https://registry.yarnpkg.com/ky/-/ky-0.11.2.tgz#4ffe6621d9d9ab61bf0f5500542e3a96d1ba0815"
-  integrity sha512-5Aou5BWue5/mkPqIRqzSWW+0Hkl403pr/2AIrCKYw7cVl/Xoe8Xe4KLBO0PRjbz7GnRe1/8wW1KhqQNFFE7/GQ==
-
-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"
-
-libp2p-crypto-secp256k1@~0.3.0:
-  version "0.3.1"
-  resolved "https://registry.yarnpkg.com/libp2p-crypto-secp256k1/-/libp2p-crypto-secp256k1-0.3.1.tgz#4cbeb857f5cfe5fefb1253e6b2994420c0ca166e"
-  integrity sha512-evrfK/CeUSd/lcELUdDruyPBvxDmLairth75S32OLl3H+++2m2fV24JEtxzdFS9JH3xEFw0h6JFO8DBa1bP9dA==
-  dependencies:
-    async "^2.6.2"
-    bs58 "^4.0.1"
-    multihashing-async "~0.6.0"
-    nodeify "^1.0.1"
-    safe-buffer "^5.1.2"
-    secp256k1 "^3.6.2"
-
-libp2p-crypto@~0.16.1:
-  version "0.16.4"
-  resolved "https://registry.yarnpkg.com/libp2p-crypto/-/libp2p-crypto-0.16.4.tgz#fb1a4ba39d56789303947784b5b0d6cefce12fdc"
-  integrity sha512-II8HxKc9jbmQp34pprlluNxsBCWJDjHRPYJzuRy7ragztNip9Zb7uJ4lCje6gGzz4DNAcHkAUn+GqCIK1592iA==
-  dependencies:
-    asmcrypto.js "^2.3.2"
-    asn1.js "^5.0.1"
-    async "^2.6.1"
-    bn.js "^4.11.8"
-    browserify-aes "^1.2.0"
-    bs58 "^4.0.1"
-    iso-random-stream "^1.1.0"
-    keypair "^1.0.1"
-    libp2p-crypto-secp256k1 "~0.3.0"
-    multihashing-async "~0.5.1"
-    node-forge "^0.10.0"
-    pem-jwk "^2.0.0"
-    protons "^1.0.1"
-    rsa-pem-to-jwk "^1.1.3"
-    tweetnacl "^1.0.0"
-    ursa-optional "~0.10.0"
-
-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.20, 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==
-
-looper@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/looper/-/looper-3.0.0.tgz#2efa54c3b1cbaba9b94aee2e5914b0be57fbb749"
-  integrity sha512-LJ9wplN/uSn72oJRsXTx+snxPet5c8XiZmOKCm906NVYu+ag6SB6vUcnJcWxgnl2NfbIyeobAn7Bwv6xRj2XJg==
-
-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@^5.1.1:
-  version "5.1.1"
-  resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-5.1.1.tgz#1da27e6710271947695daf6848e847f01d84b920"
-  integrity sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==
-  dependencies:
-    yallist "^3.0.2"
-
-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"
-
-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=
-
-mafmt@^6.0.2:
-  version "6.0.10"
-  resolved "https://registry.yarnpkg.com/mafmt/-/mafmt-6.0.10.tgz#3ad251c78f14f8164e66f70fd3265662da41113a"
-  integrity sha512-FjHDnew6dW9lUu3eYwP0FvvJl9uvNbqfoJM+c1WJcSyutNEIlyu6v3f/rlPnD1cnmue38IjuHlhBdIh3btAiyw==
-  dependencies:
-    multiaddr "^6.1.0"
-
-mafmt@^7.0.0:
-  version "7.1.0"
-  resolved "https://registry.yarnpkg.com/mafmt/-/mafmt-7.1.0.tgz#4126f6d0eded070ace7dbbb6fb04977412d380b5"
-  integrity sha512-vpeo9S+hepT3k2h5iFxzEHvvR0GPBx9uKaErmnRzYNcaKb03DgOArjEMlgG4a9LcuZZ89a3I8xbeto487n26eA==
-  dependencies:
-    multiaddr "^7.3.0"
-
-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"
-
-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-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:
-  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"
-
-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:
-  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"
-
-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"
-
-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@^6.0.3, multiaddr@^6.0.6, multiaddr@^6.1.0:
-  version "6.1.1"
-  resolved "https://registry.yarnpkg.com/multiaddr/-/multiaddr-6.1.1.tgz#9aae57b3e399089b9896d9455afa8f6b117dff06"
-  integrity sha512-Q1Ika0F9MNhMtCs62Ue+GWIJtRFEhZ3Xz8wH7/MZDVZTWhil1/H2bEGN02kUees3hkI3q1oHSjmXYDM0gxaFjQ==
-  dependencies:
-    bs58 "^4.0.1"
-    class-is "^1.1.0"
-    hi-base32 "~0.5.0"
-    ip "^1.1.5"
-    is-ip "^2.0.0"
-    varint "^5.0.0"
-
-multiaddr@^7.2.1, multiaddr@^7.3.0:
-  version "7.5.0"
-  resolved "https://registry.yarnpkg.com/multiaddr/-/multiaddr-7.5.0.tgz#976c88e256e512263445ab03b3b68c003d5f485e"
-  integrity sha512-GvhHsIGDULh06jyb6ev+VfREH9evJCFIRnh3jUt9iEZ6XDbyoisZRFEI9bMvK/AiR6y66y6P+eoBw9mBYMhMvw==
-  dependencies:
-    buffer "^5.5.0"
-    cids "~0.8.0"
-    class-is "^1.1.0"
-    is-ip "^3.1.0"
-    multibase "^0.7.0"
-    varint "^5.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@^1.0.0, multibase@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/multibase/-/multibase-1.0.1.tgz#4adbe1de0be8a1ab0274328b653c3f1903476724"
-  integrity sha512-KcCxpBVY8fdVKu4dJMAahq4F/2Z/9xqEjIiR7PiMe7LRGeorFn2NLmicN6nLBCqQvft6MG2Lc9X5P0IdyvnxEw==
-  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, multicodec@~0.5.1:
-  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, multicodec@^1.0.1:
-  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"
-
-multihashes@^0.4.15, multihashes@~0.4.13, multihashes@~0.4.14, 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"
-
-multihashes@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/multihashes/-/multihashes-1.0.1.tgz#a89415d68283cf6287c6e219e304e75ce7fb73fe"
-  integrity sha512-S27Tepg4i8atNiFaU5ZOm3+gl3KQlUanLs/jWcBxQHFttgq+5x1OgbQmf2d8axJ/48zYGBd/wT9d723USMFduw==
-  dependencies:
-    buffer "^5.6.0"
-    multibase "^1.0.1"
-    varint "^5.0.0"
-
-multihashing-async@~0.5.1:
-  version "0.5.2"
-  resolved "https://registry.yarnpkg.com/multihashing-async/-/multihashing-async-0.5.2.tgz#4af40e0dde2f1dbb12a7c6b265181437ac26b9de"
-  integrity sha512-mmyG6M/FKxrpBh9xQDUvuJ7BbqT93ZeEeH5X6LeMYKoYshYLr9BDdCsvDtZvn+Egf+/Xi+aOznrWL4vp3s+p0Q==
-  dependencies:
-    blakejs "^1.1.0"
-    js-sha3 "~0.8.0"
-    multihashes "~0.4.13"
-    murmurhash3js "^3.0.1"
-    nodeify "^1.0.1"
-
-multihashing-async@~0.6.0:
-  version "0.6.0"
-  resolved "https://registry.yarnpkg.com/multihashing-async/-/multihashing-async-0.6.0.tgz#c1fc6696a624b9bf39b160b0c4c4e7ba3f394453"
-  integrity sha512-Qv8pgg99Lewc191A5nlXy0bSd2amfqlafNJZmarU6Sj7MZVjpR94SCxQjf4DwPtgWZkiLqsjUQBXA2RSq+hYyA==
-  dependencies:
-    blakejs "^1.1.0"
-    js-sha3 "~0.8.0"
-    multihashes "~0.4.13"
-    murmurhash3js "^3.0.1"
-    nodeify "^1.0.1"
-
-multihashing-async@~0.7.0:
-  version "0.7.0"
-  resolved "https://registry.yarnpkg.com/multihashing-async/-/multihashing-async-0.7.0.tgz#3234fb98295be84386b85bfd20377d3e5be20d6b"
-  integrity sha512-SCbfl3f+DzJh+/5piukga9ofIOxwfT05t8R4jfzZIJ88YE9zU9+l3K2X+XB19MYyxqvyK9UJRNWbmQpZqQlbRA==
-  dependencies:
-    blakejs "^1.1.0"
-    buffer "^5.2.1"
-    err-code "^1.1.2"
-    js-sha3 "~0.8.0"
-    multihashes "~0.4.13"
-    murmurhash3js-revisited "^3.0.0"
-
-multihashing-async@~0.8.0:
-  version "0.8.2"
-  resolved "https://registry.yarnpkg.com/multihashing-async/-/multihashing-async-0.8.2.tgz#3d5da05df27d83be923f6d04143a0954ff87f27f"
-  integrity sha512-2lKa1autuCy8x7KIEj9aVNbAb3aIMRFYIwN7mq/zD4pxgNIVgGlm+f6GKY4880EOF2Y3GktHYssRy7TAJQ2DyQ==
-  dependencies:
-    blakejs "^1.1.0"
-    buffer "^5.4.3"
-    err-code "^2.0.0"
-    js-sha3 "^0.8.0"
-    multihashes "^1.0.1"
-    murmurhash3js-revisited "^3.0.0"
-
-murmurhash3js-revisited@^3.0.0:
-  version "3.0.0"
-  resolved "https://registry.yarnpkg.com/murmurhash3js-revisited/-/murmurhash3js-revisited-3.0.0.tgz#6bd36e25de8f73394222adc6e41fa3fac08a5869"
-  integrity sha512-/sF3ee6zvScXMb1XFJ8gDsSnY+X8PbOyjIuBhtgis10W2Jx4ZjIhikUCIF9c4gpJxVnQIsPAFrSwTCuAjicP6g==
-
-murmurhash3js@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/murmurhash3js/-/murmurhash3js-3.0.1.tgz#3e983e5b47c2a06f43a713174e7e435ca044b998"
-  integrity sha512-KL8QYUaxq7kUbcl0Yto51rMcYt7E/4N4BG3/c96Iqw1PQrTRspu8Cpx4TZ4Nunib1d4bEkIH3gjCYlP2RLBdow==
-
-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==
-
-nan@^2.14.0, nan@^2.14.2:
-  version "2.16.0"
-  resolved "https://registry.yarnpkg.com/nan/-/nan-2.16.0.tgz#664f43e45460fb98faf00edca0bb0d7b8dce7916"
-  integrity sha512-UdAqHyFngu7TfQKsCBgAA6pWDkT8MAO7d0jyOecVhN5354xbLqdn8mV9Tat9gepAupm0bt2DbeaSC8vS52MuFA==
-
-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==
-
-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==
-
-"ndjson@github:hugomrdias/ndjson#feat/readable-stream3":
-  version "1.5.0"
-  resolved "https://codeload.github.com/hugomrdias/ndjson/tar.gz/4db16da6b42e5b39bf300c3a7cde62abb3fa3a11"
-  dependencies:
-    json-stringify-safe "^5.0.1"
-    minimist "^1.2.0"
-    split2 "^3.1.0"
-    through2 "^3.0.0"
-
-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=
-
-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.3.0:
-  version "2.6.7"
-  resolved "https://registry.yarnpkg.com/node-fetch/-/node-fetch-2.6.7.tgz#24de9fba827e3b4ae44dc8b20256a379160052ad"
-  integrity sha512-ZjMPFEfVx5j+y2yF35Kzx5sF7kDzxuDj6ziH4FFbOp87zKDZNx8yExJIb05OGF4Nlt9IHFIMBkRl41VdvcNdbQ==
-  dependencies:
-    whatwg-url "^5.0.0"
-
-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-forge@^0.10.0:
-  version "0.10.0"
-  resolved "https://registry.yarnpkg.com/node-forge/-/node-forge-0.10.0.tgz#32dea2afb3e9926f02ee5ce8794902691a676bf3"
-  integrity sha512-PPmu8eEeG9saEUvI97fm4OYxXVB6bFvyNTyiUOBichBpFG8A1Ljw3bY62+5oOjDEMHRnd0Y7HQ+x7uzxOzC6JA==
-
-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==
-
-nodeify@^1.0.1:
-  version "1.0.1"
-  resolved "https://registry.yarnpkg.com/nodeify/-/nodeify-1.0.1.tgz#64ab69a7bdbaf03ce107b4f0335c87c0b9e91b1d"
-  integrity sha512-n7C2NyEze8GCo/z73KdbjRsBiLbv6eBn1FxwYKQ23IqGo7pQY3mhQan61Sv7eEDJCiyUjTVrVkXTzJCo1dW7Aw==
-  dependencies:
-    is-promise "~1.0.0"
-    promise "~1.3.0"
-
-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:
-  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@^2.0.0:
-  version "2.1.1"
-  resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-2.1.1.tgz#43c36e5d569ff8e4816c4efa8be02d26967c18aa"
-  integrity sha512-CdsOUYIh5wIiozhJ3rLQgmUTgcyzFwZZrqhkKhODMoGtPKM+wt0h0CNIoauJWMsS9822EdzPsF/6mb4nLvPN5g==
-
-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.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:
-  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"
-
-optimist@~0.3.5:
-  version "0.3.7"
-  resolved "https://registry.yarnpkg.com/optimist/-/optimist-0.3.7.tgz#c90941ad59e4273328923074d2cf2e7cbc6ec0d9"
-  integrity sha512-TCx0dXQzVtSCg2OgY/bO9hjM9cV4XYx09TVK+s3+FhkjT6LovsLe+pPMzpWf+6yXK/hUizs2gUoTw3jHM0VaTQ==
-  dependencies:
-    wordwrap "~0.0.2"
-
-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@^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-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-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"
-
-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@^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-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"
-
-peer-id@~0.12.2, peer-id@~0.12.3:
-  version "0.12.5"
-  resolved "https://registry.yarnpkg.com/peer-id/-/peer-id-0.12.5.tgz#b22a1edc5b4aaaa2bb830b265ba69429823e5179"
-  integrity sha512-3xVWrtIvNm9/OPzaQBgXDrfWNx63AftgFQkvqO6YSZy7sP3Fuadwwbn54F/VO9AnpyW/26i0WRQz9FScivXrmw==
-  dependencies:
-    async "^2.6.3"
-    class-is "^1.1.0"
-    libp2p-crypto "~0.16.1"
-    multihashes "~0.4.15"
-
-peer-info@~0.15.1:
-  version "0.15.1"
-  resolved "https://registry.yarnpkg.com/peer-info/-/peer-info-0.15.1.tgz#21254a7c516d0dd046b150120b9aaf1b9ad02146"
-  integrity sha512-Y91Q2tZRC0CpSTPd1UebhGqniOrOAk/aj60uYUcWJXCoLTAnGu+4LJGoiay8ayudS6ice7l3SKhgL/cS62QacA==
-  dependencies:
-    mafmt "^6.0.2"
-    multiaddr "^6.0.3"
-    peer-id "~0.12.2"
-    unique-by "^1.0.0"
-
-pem-jwk@^2.0.0:
-  version "2.0.0"
-  resolved "https://registry.yarnpkg.com/pem-jwk/-/pem-jwk-2.0.0.tgz#1c5bb264612fc391340907f5c1de60c06d22f085"
-  integrity sha512-rFxu7rVoHgQ5H9YsP50dDWf0rHjreVA2z0yPiWr5WdH/UHb29hKtF7h6l8vNd1cbYR1t0QL+JKhW55a2ZV4KtA==
-  dependencies:
-    asn1.js "^5.0.1"
-
-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:
-  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"
-
-pkginfo@0.4.1:
-  version "0.4.1"
-  resolved "https://registry.yarnpkg.com/pkginfo/-/pkginfo-0.4.1.tgz#b5418ef0439de5425fc4995042dced14fb2a84ff"
-  integrity sha1-tUGO8EOd5UJfxJlQQtztFPsqhP8=
-
-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-nodeify@^3.0.1:
-  version "3.0.1"
-  resolved "https://registry.yarnpkg.com/promise-nodeify/-/promise-nodeify-3.0.1.tgz#f0f5d9720ee9ec71dd2bfa92667be504c10229c2"
-  integrity sha512-ghsSuzZXJX8iO7WVec2z7GI+Xk/EyiD+JZK7AZKhUqYfpLa/Zs4ylUD+CwwnKlG6G3HnkUPMAi6PO7zeqGKssg==
-
-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"
-
-promise@~1.3.0:
-  version "1.3.0"
-  resolved "https://registry.yarnpkg.com/promise/-/promise-1.3.0.tgz#e5cc9a4c8278e4664ffedc01c7da84842b040175"
-  integrity sha512-R9WrbTF3EPkVtWjp7B7umQGVndpsi+rsDAfrR4xAALQpFLa/+2OriecLhawxzvii2gd9+DZFwROWDuUUaqS5yA==
-  dependencies:
-    is-promise "~1"
-
-promisify-es6@^1.0.3:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/promisify-es6/-/promisify-es6-1.0.3.tgz#b012668c4df3c965ce13daac2b3a4d1726a96346"
-  integrity sha512-N9iVG+CGJsI4b4ZGazjwLnxErD2d9Pe4DPvvXSxYA9tFNu8ymXME4Qs5HIQ0LMJpNM7zj+m0NlNnNeqFpKzqnA==
-
-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"
-
-protocol-buffers-schema@^3.3.1:
-  version "3.6.0"
-  resolved "https://registry.yarnpkg.com/protocol-buffers-schema/-/protocol-buffers-schema-3.6.0.tgz#77bc75a48b2ff142c1ad5b5b90c94cd0fa2efd03"
-  integrity sha512-TdDRD+/QNdrCGCE7v8340QyuXd4kIWIgapsE2+n/SaGiSSbomYl4TjHlvIoCWRpE7wFt02EpB35VVA2ImcBVqw==
-
-protons@^1.0.1:
-  version "1.2.1"
-  resolved "https://registry.yarnpkg.com/protons/-/protons-1.2.1.tgz#5f1e0db8b2139469cd1c3b4e332a4c2d95d0a218"
-  integrity sha512-2oqDyc/SN+tNcJf8XxrXhYL7sQn2/OMl8mSdD7NVGsWjMEmAbks4eDVnCyf0vAoRbBWyWTEXWk4D8XfuKVl3zg==
-  dependencies:
-    buffer "^5.5.0"
-    protocol-buffers-schema "^3.3.1"
-    signed-varint "^2.0.1"
-    varint "^5.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"
-
-pull-defer@~0.2.3:
-  version "0.2.3"
-  resolved "https://registry.yarnpkg.com/pull-defer/-/pull-defer-0.2.3.tgz#4ee09c6d9e227bede9938db80391c3dac489d113"
-  integrity sha512-/An3KE7mVjZCqNhZsr22k1Tx8MACnUnHZZNPSJ0S62td8JtYr/AiRG42Vz7Syu31SoTLUzVIe61jtT/pNdjVYA==
-
-pull-stream@^3.2.3, pull-stream@^3.6.9:
-  version "3.6.14"
-  resolved "https://registry.yarnpkg.com/pull-stream/-/pull-stream-3.6.14.tgz#529dbd5b86131f4a5ed636fdf7f6af00781357ee"
-  integrity sha512-KIqdvpqHHaTUA2mCYcLG1ibEbu/LCKoJZsBWyv9lSYtPkJPBq8m3Hxa103xHi6D2thj5YXa0TqK3L3GUkwgnew==
-
-pull-to-stream@~0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/pull-to-stream/-/pull-to-stream-0.1.1.tgz#fa2058528528e3542b81d6f17cbc42288508ff37"
-  integrity sha512-thZkMv6F9PILt9zdvpI2gxs19mkDrlixYKX6cOBxAW16i1NZH+yLAmF4r8QfJ69zuQh27e01JZP9y27tsH021w==
-  dependencies:
-    readable-stream "^3.1.1"
-
-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@^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==
-
-qs@6.11.0, qs@^6.4.0, qs@^6.5.2:
-  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==
-
-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.0.0, readable-stream@^3.0.1, readable-stream@^3.0.2, 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.5.0:
-  version "3.5.0"
-  resolved "https://registry.yarnpkg.com/readdirp/-/readdirp-3.5.0.tgz#9ba74c019b15d365278d2e91bb8c48d7b4d42c9e"
-  integrity sha512-cMhu7c/8rdhkHXWsY+osBhfSy0JikwpHK/5+imo+LpeasTF8ouErHrlYkwT0++njiyuDvc7OFY5T3ukvZ8qmFQ==
-  dependencies:
-    picomatch "^2.2.1"
-
-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"
-
-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==
-
-rsa-pem-to-jwk@^1.1.3:
-  version "1.1.3"
-  resolved "https://registry.yarnpkg.com/rsa-pem-to-jwk/-/rsa-pem-to-jwk-1.1.3.tgz#245e76bdb7e7234cfee7ca032d31b54c38fab98e"
-  integrity sha512-ZlVavEvTnD8Rzh/pdB8NH4VF5GNEtF6biGQcTtC4GKFMsbZR08oHtOYefbhCN+JnJIuMItiCDCMycdcMrw6blA==
-  dependencies:
-    object-assign "^2.0.0"
-    rsa-unpack "0.0.6"
-
-rsa-unpack@0.0.6:
-  version "0.0.6"
-  resolved "https://registry.yarnpkg.com/rsa-unpack/-/rsa-unpack-0.0.6.tgz#f50ebd56a628378e631f297161026ce9ab4eddba"
-  integrity sha512-HRrl8GHjjPziPFRDJPq/v5OxZ3IPdksV5h3cime/oHgcgM1k1toO5OdtzClgBqRf5dF6IgptOB0g/zFb0w5zQw==
-  dependencies:
-    optimist "~0.3.5"
-
-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@^3.6.2:
-  version "3.8.0"
-  resolved "https://registry.yarnpkg.com/secp256k1/-/secp256k1-3.8.0.tgz#28f59f4b01dbee9575f56a47034b7d2e3b3b352d"
-  integrity sha512-k5ke5avRZbtl9Tqx/SA7CbY3NF6Ro+Sj9cZxezFzuBlLDmyqPiL8hJJ+EmzD8Ig4LUDByHJ3/iPOVoRixs/hmw==
-  dependencies:
-    bindings "^1.5.0"
-    bip66 "^1.1.5"
-    bn.js "^4.11.8"
-    create-hash "^1.2.0"
-    drbg.js "^1.0.1"
-    elliptic "^6.5.2"
-    nan "^2.14.0"
-    safe-buffer "^5.1.2"
-
-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@^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@~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@^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@^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:
-  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==
-
-signed-varint@^2.0.1:
-  version "2.0.1"
-  resolved "https://registry.yarnpkg.com/signed-varint/-/signed-varint-2.0.1.tgz#50a9989da7c98c2c61dad119bc97470ef8528129"
-  integrity sha512-abgDPg1106vuZZOvw7cFwdCABddfJRz5akcCcchzTbhyhYnsG31y4AlZEgp315T7W3nQq5P4xeOm186ZiPVFzw==
-  dependencies:
-    varint "~5.0.0"
-
-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==
-
-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-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==
-
-split2@^3.1.0:
-  version "3.2.2"
-  resolved "https://registry.yarnpkg.com/split2/-/split2-3.2.2.tgz#bf2cf2a37d838312c249c89206fd7a17dd12365f"
-  integrity sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==
-  dependencies:
-    readable-stream "^3.0.0"
-
-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"
-
-stable@~0.1.8:
-  version "0.1.8"
-  resolved "https://registry.yarnpkg.com/stable/-/stable-0.1.8.tgz#836eb3c8382fe2936feaf544631017ce7d47a3cf"
-  integrity sha512-ji9qxRnOVfcuLDySj9qzhGSEFVobyt1kIOSkj1qZzYLzq7Tos/oUUWvotUPQLlrsidqsK6tBH89Bc9kL5zHA6w==
-
-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-pull-stream@^1.7.2:
-  version "1.7.3"
-  resolved "https://registry.yarnpkg.com/stream-to-pull-stream/-/stream-to-pull-stream-1.7.3.tgz#4161aa2d2eb9964de60bfa1af7feaf917e874ece"
-  integrity sha512-6sNyqJpr5dIOQdgNy/xcDWwDuzAsAwVzhzrWlAPAQ7Lkjx/rv0wgvxEyKwTq6FmNd5rjTrELt/CLmaSw7crMGg==
-  dependencies:
-    looper "^3.0.0"
-    pull-stream "^3.2.3"
-
-streamsearch@0.1.2:
-  version "0.1.2"
-  resolved "https://registry.yarnpkg.com/streamsearch/-/streamsearch-0.1.2.tgz#808b9d0e56fc273d809ba57338e929919a1a9f1a"
-  integrity sha1-gIudDlb8Jz2Am6VzOOkpkZoanxo=
-
-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.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, string_decoder@^1.2.0:
-  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:
-  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.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"
-
-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-stream@^2.0.1:
-  version "2.2.0"
-  resolved "https://registry.yarnpkg.com/tar-stream/-/tar-stream-2.2.0.tgz#acad84c284136b060dc3faa64474aa9aebd77287"
-  integrity sha512-ujeqbceABgwMZxEJnk2HDY2DlnUZ+9oEcb1KzTVfYHio0UE6dG71n60d8D2I4qNvleWrrXpmjpt7vZeF1LnMZQ==
-  dependencies:
-    bl "^4.0.3"
-    end-of-stream "^1.4.1"
-    fs-constants "^1.0.0"
-    inherits "^2.0.3"
-    readable-stream "^3.1.1"
-
-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, through2@^3.0.0, through2@^3.0.1:
-  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=
-
-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.2:
-  version "3.0.2"
-  resolved "https://registry.yarnpkg.com/tmp-promise/-/tmp-promise-3.0.2.tgz#6e933782abff8b00c3119d63589ca1fb9caaa62a"
-  integrity sha512-OyCLAKU1HzBjL6Ev3gxUeraJNlbNingmi8IrHHEsYH8LTmEuhvYfqvhn2F/je+mjf4N58UmZ96OMEy1JanSCpA==
-  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"
-
-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.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==
-
-tweetnacl@^1.0.0:
-  version "1.0.3"
-  resolved "https://registry.yarnpkg.com/tweetnacl/-/tweetnacl-1.0.3.tgz#ac0af71680458d8a6378d0d0d050ab1407d35596"
-  integrity sha512-6rt+RN7aOi1nGMyC4Xa5DdYiukl2UWCbcJft7YhxReBGQD7OAM8Pbxw6YMo4r2diNEA8FEmu32YOn9rhaiE5yw==
-
-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-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==
-
-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-by@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/unique-by/-/unique-by-1.0.0.tgz#5220c86ba7bc572fb713ad74651470cb644212bd"
-  integrity sha512-rJRXK5V0zL6TiSzhoGNpJp5dr+TZBLoPJFC06rLn17Ug++7Aa0Qnve5v+skXeQxx6/sI7rBsSesa6MAcmFi8Ew==
-
-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@^1.0.0:
-  version "1.0.0"
-  resolved "https://registry.yarnpkg.com/universalify/-/universalify-1.0.0.tgz#b61a1da173e8435b2fe3c67d29b9adf8594bd16d"
-  integrity sha512-rb6X1W158d7pRQBg5gkR8uPaSfiids68LTJQYOtEUhoJUWBdaQHsuT/EUduxXYxcrt4r5PJ4fuHW1MHT6p0qug==
-
-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=
-
-ursa-optional@~0.10.0:
-  version "0.10.2"
-  resolved "https://registry.yarnpkg.com/ursa-optional/-/ursa-optional-0.10.2.tgz#bd74e7d60289c22ac2a69a3c8dea5eb2817f9681"
-  integrity sha512-TKdwuLboBn7M34RcvVTuQyhvrA8gYKapuVdm0nBP0mnBc7oECOfUQZrY91cefL3/nm64ZyrejSRrhTVdX7NG/A==
-  dependencies:
-    bindings "^1.5.0"
-    nan "^2.14.2"
-
-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==
-
-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, varint@~5.0.0:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/varint/-/varint-5.0.2.tgz#5b47f8a947eb668b848e034dcfa87d0ff8a7f7a4"
-  integrity sha512-lKxKYG6H03yCZUpAGOPOsMcGxd1RHCu1iKvEHYDPmTyq2HueGhD73ssNBqqQWfvYs04G9iUFRvmAVLW20Jw6ow==
-
-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"
-
-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"
-
-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"
-
-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"
-
-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@~0.0.2:
-  version "0.0.3"
-  resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.3.tgz#a3d5da6cd5c0bc0008d37234bbaf1bed63059107"
-  integrity sha512-1tMA907+V4QmxV7dbRvb4/8MaRALK6q9Abid3ndMYnbyo8piisCmeONVqVSXqQA3KaP4SLt5b7ud6E2sqP8TFw==
-
-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"
-
-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.0.2, 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.9.2:
-  version "1.9.2"
-  resolved "https://registry.yarnpkg.com/yaml/-/yaml-1.9.2.tgz#f0cfa865f003ab707663e4f04b3956957ea564ed"
-  integrity sha512-HPT7cGGI0DuRcsO51qC1j9O16Dh1mZ2bnXwsi0jrSpsLz0WxOLSLXfkABVl6bZO629py3CU+OMJtpNHDLB97kg==
-  dependencies:
-    "@babel/runtime" "^7.9.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-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"
-
-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/src/config.rs b/tests/src/config.rs
new file mode 100644
index 00000000000..e35fbb6bf0d
--- /dev/null
+++ b/tests/src/config.rs
@@ -0,0 +1,375 @@
+use std::sync::OnceLock;
+use std::time::{Duration, Instant};
+use std::{fs, path::PathBuf};
+
+use tokio::process::{Child, Command};
+
+use graph::prelude::anyhow::Context;
+use graph::prelude::diesel::connection::SimpleConnection;
+use graph::prelude::{lazy_static, reqwest};
+use tokio::time::sleep;
+
+use crate::helpers::TestFile;
+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)]
+pub struct DbConfig {
+    pub host: String,
+    pub port: u16,
+    pub user: String,
+    pub password: String,
+    pub name: String,
+}
+
+impl DbConfig {
+    pub fn url(&self) -> String {
+        format!(
+            "postgres://{}:{}@{}:{}/{}",
+            self.user, self.password, self.host, self.port, self.name
+        )
+    }
+
+    pub fn template_url(&self) -> String {
+        format!(
+            "postgres://{}:{}@{}:{}/{}",
+            self.user, self.password, self.host, self.port, "template1"
+        )
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct EthConfig {
+    pub network: String,
+    pub port: u16,
+    pub host: String,
+}
+
+impl EthConfig {
+    pub fn url(&self) -> String {
+        format!("http://{}:{}", self.host, self.port)
+    }
+
+    pub fn network_url(&self) -> String {
+        format!("{}:{}", self.network, self.url())
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct GraphNodePorts {
+    pub http: u16,
+    pub index: u16,
+    pub admin: u16,
+    pub metrics: u16,
+}
+
+impl Default for GraphNodePorts {
+    fn default() -> Self {
+        Self {
+            http: 3030,
+            admin: 3032,
+            index: 3033,
+            metrics: 3034,
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct GraphNodeConfig {
+    bin: PathBuf,
+    pub ports: GraphNodePorts,
+    pub ipfs_uri: String,
+    pub log_file: TestFile,
+}
+
+impl GraphNodeConfig {
+    pub fn admin_uri(&self) -> String {
+        format!("http://localhost:{}", self.ports.admin)
+    }
+
+    pub fn index_node_uri(&self) -> String {
+        format!("http://localhost:{}/graphql", self.ports.index)
+    }
+
+    pub fn http_uri(&self) -> String {
+        format!("http://localhost:{}", self.ports.http)
+    }
+
+    pub async fn check_if_up(&self) -> anyhow::Result<bool> {
+        let url = format!("http://localhost:{}/", self.ports.http);
+        let client = reqwest::Client::new();
+        match client.get(&url).send().await {
+            Ok(res) => {
+                if res.status().is_success() {
+                    Ok(true)
+                } else {
+                    Err(anyhow::anyhow!("got non-success for GET on {url}"))
+                }
+            }
+            Err(e) => {
+                if e.is_connect() {
+                    Ok(false)
+                } else {
+                    Err(e).context(format!("failed to connect to {url}"))
+                }
+            }
+        }
+    }
+
+    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 {
+    fn default() -> Self {
+        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,
+            log_file: TestFile::new("integration-tests/graph-node.log"),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Config {
+    pub db: DbConfig,
+    pub eth: EthConfig,
+    pub graph_node: GraphNodeConfig,
+    pub graph_cli: String,
+    pub num_parallel_tests: usize,
+    pub timeout: Duration,
+}
+
+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 = [
+            "--config",
+            &config_path_str,
+            "--ipfs",
+            &self.graph_node.ipfs_uri,
+            "--http-port",
+            &http_port,
+            "--index-node-port",
+            &index_port,
+            "--admin-port",
+            &admin_port,
+            "--metrics-port",
+            &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!(
+            "graph-node",
+            "Writing logs to {}",
+            self.graph_node.log_file.path.display()
+        );
+        let mut command = Command::new(self.graph_node.bin.as_os_str());
+        command
+            .stdout(stdout)
+            .stderr(stderr)
+            .args(args.clone())
+            .env("GRAPH_STORE_WRITE_BATCH_DURATION", "5")
+            .env("ETHEREUM_REORG_THRESHOLD", "0");
+
+        status!(
+            "graph-node",
+            "Starting: '{} {}'",
+            self.graph_node.bin.as_os_str().to_string_lossy(),
+            args.join(" ")
+        );
+        let child = command.spawn().context("failed to start graph-node")?;
+
+        status!("graph-node", "Waiting to accept requests",);
+        let start = Instant::now();
+        loop {
+            let up = self.graph_node.check_if_up().await?;
+            if up {
+                break;
+            } else {
+                sleep(Duration::from_millis(500)).await;
+            }
+        }
+        status!("graph-node", "Up after {}ms", start.elapsed().as_millis());
+        Ok(child)
+    }
+
+    pub fn reset_database(&self) {
+        use graph::prelude::diesel::{Connection, PgConnection};
+        // The drop and create statements need to happen as separate statements
+        let drop_db = format!(r#"drop database if exists "{}""#, self.db.name);
+        let create_db = format!(
+            r#"create database "{}" template = 'template0' locale = 'C' encoding = 'UTF8'"#,
+            self.db.name
+        );
+        let setup = format!(
+            r#"
+        create extension pg_trgm;
+        create extension btree_gist;
+        create extension postgres_fdw;
+        grant usage on foreign data wrapper postgres_fdw to "{}";
+        "#,
+            self.db.user
+        );
+
+        let template_uri = self.db.template_url();
+
+        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 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");
+    }
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        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: 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: eth_port,
+                host: "localhost".to_string(),
+            },
+            graph_node: GraphNodeConfig::from_env(),
+            graph_cli,
+            num_parallel_tests,
+            timeout: Duration::from_secs(600),
+        }
+    }
+}
diff --git a/tests/src/contract.rs b/tests/src/contract.rs
new file mode 100644
index 00000000000..82fc89fec87
--- /dev/null
+++ b/tests/src/contract.rs
@@ -0,0 +1,319 @@
+use graph::prelude::{
+    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},
+};
+
+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 = "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"
+        .parse()
+        .unwrap();
+    static ref FROM_KEY: PrivateKeySigner =
+        "ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
+            .parse()
+            .unwrap();
+    static ref CONTRACTS: Vec<Contract> = {
+        vec![
+            Contract {
+                name: "SimpleContract".to_string(),
+                address: "0x5fbdb2315678afecb367f032d93f642f64180aa3"
+                    .parse()
+                    .unwrap(),
+            },
+            Contract {
+                name: "LimitedContract".to_string(),
+                address: "0x0b306bf915c4d645ff596e518faf3f9669b97016"
+                    .parse()
+                    .unwrap(),
+            },
+            Contract {
+                name: "RevertingContract".to_string(),
+                address: "0x959922be3caee4b8cd9a407cc3ac1c251c2007b1"
+                    .parse()
+                    .unwrap(),
+            },
+            Contract {
+                name: "OverloadedContract".to_string(),
+                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,
+    pub address: Address,
+}
+
+impl Contract {
+    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 bytes = self.code().await;
+        !bytes.is_empty()
+    }
+
+    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));
+
+        let json: Value = serde_json::from_reader(bin.reader()?).unwrap();
+        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 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,
+        })
+    }
+
+    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 interface = Interface::new(abi);
+        let contract = ContractInstance::new(self.address, provider, interface);
+
+        let receipt = contract
+            .function(func, params)?
+            .send()
+            .await?
+            .with_required_confirmations(1)
+            .get_receipt()
+            .await?;
+
+        Ok(receipt)
+    }
+
+    pub async fn deploy_all() -> anyhow::Result<Vec<Self>> {
+        let mut contracts = Vec::new();
+        status!("contracts", "Deploying contracts");
+        for contract in &*CONTRACTS {
+            let mut contract = contract.clone();
+            if !contract.exists().await {
+                status!(
+                    "contracts",
+                    "Contract {} does not exist, deploying",
+                    contract.name
+                );
+                let old_address = contract.address;
+                contract = Self::deploy(&contract.name).await?;
+                if old_address != contract.address {
+                    error!(
+                        "contracts",
+                        "Contract address for {} changed from {:?} to {:?}",
+                        contract.name,
+                        old_address,
+                        contract.address
+                    );
+                } else {
+                    status!(
+                        "contracts",
+                        "Deployed contract {} at {:?}",
+                        contract.name,
+                        contract.address
+                    );
+                }
+                // Some tests want 10 calls to `emitTrigger` in place
+                if contract.name == "SimpleContract" {
+                    status!("contracts", "Calling SimpleContract.emitTrigger 10 times");
+                    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 {
+                status!(
+                    "contracts",
+                    "Contract {} exists at {:?}",
+                    contract.name,
+                    contract.address
+                );
+            }
+            contracts.push(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/docker_utils.rs b/tests/src/docker_utils.rs
deleted file mode 100644
index a02900b0e0c..00000000000
--- a/tests/src/docker_utils.rs
+++ /dev/null
@@ -1,281 +0,0 @@
-use bollard::image::CreateImageOptions;
-use bollard::models::HostConfig;
-use bollard::{container, Docker};
-use futures::stream::FuturesUnordered;
-use futures::StreamExt;
-use std::collections::HashMap;
-use tokio::time::{sleep, Duration};
-
-use crate::helpers::{contains_subslice, MappedPorts};
-
-type DockerError = bollard::errors::Error;
-
-const POSTGRES_IMAGE: &str = "postgres:latest";
-const IPFS_IMAGE: &str = "ipfs/go-ipfs:v0.10.0";
-const GANACHE_IMAGE: &str = "trufflesuite/ganache-cli:latest";
-
-pub async fn pull_service_images() {
-    let client =
-        Docker::connect_with_local_defaults().expect("Failed to connect to docker daemon.");
-
-    let image_names = [POSTGRES_IMAGE, IPFS_IMAGE, GANACHE_IMAGE];
-
-    image_names
-        .iter()
-        .map(|image_name| pull_image(&client, image_name))
-        // .await them in no specific order.
-        .collect::<FuturesUnordered<_>>()
-        .collect::<Vec<_>>()
-        .await;
-}
-
-async fn pull_image(client: &Docker, image_name: &str) {
-    let options = Some(CreateImageOptions {
-        from_image: image_name,
-        ..Default::default()
-    });
-
-    let mut stream = client.create_image(options, None, None);
-
-    while let Some(res) = stream.next().await {
-        if let Err(err) = res {
-            panic!("Error when pulling docker image `{}`: {}", image_name, err)
-        }
-    }
-}
-
-pub async fn kill_and_remove(client: &Docker, container_name: &str) -> Result<(), DockerError> {
-    client.kill_container::<&str>(container_name, None).await?;
-    client.remove_container(container_name, None).await
-}
-
-/// Represents all possible service containers to be spawned
-#[derive(Debug, Copy, Clone)]
-pub enum ServiceContainerKind {
-    Postgres,
-    Ipfs,
-    Ganache,
-}
-
-impl ServiceContainerKind {
-    fn config(&self) -> container::Config<&'static str> {
-        let host_config = HostConfig {
-            publish_all_ports: Some(true),
-            ..Default::default()
-        };
-
-        match self {
-            Self::Postgres => container::Config {
-                image: Some(POSTGRES_IMAGE),
-                env: Some(vec![
-                    "POSTGRES_PASSWORD=password",
-                    "POSTGRES_USER=postgres",
-                    "POSTGRES_INITDB_ARGS=-E UTF8 --locale=C",
-                ]),
-                host_config: Some(host_config),
-                cmd: Some(vec![
-                    "postgres",
-                    "-N",
-                    "1000",
-                    "-cshared_preload_libraries=pg_stat_statements",
-                ]),
-                ..Default::default()
-            },
-
-            Self::Ipfs => container::Config {
-                image: Some(IPFS_IMAGE),
-                host_config: Some(host_config),
-                ..Default::default()
-            },
-
-            Self::Ganache => container::Config {
-                image: Some(GANACHE_IMAGE),
-                cmd: Some(vec!["-d", "-l", "100000000000", "-g", "1"]),
-                host_config: Some(host_config),
-                ..Default::default()
-            },
-        }
-    }
-
-    pub fn name(&self) -> &str {
-        use ServiceContainerKind::*;
-        match self {
-            Postgres => "graph_node_integration_test_postgres",
-            Ipfs => "graph_node_integration_test_ipfs",
-            Ganache => "graph_node_integration_test_ganache",
-        }
-    }
-}
-
-/// Handles the connection to the docker daemon and keeps track the service running inside it.
-pub struct ServiceContainer {
-    client: Docker,
-    container_name: String,
-}
-
-impl ServiceContainer {
-    pub async fn start(service: ServiceContainerKind) -> Result<Self, DockerError> {
-        let client =
-            Docker::connect_with_local_defaults().expect("Failed to connect to docker daemon.");
-        let container_name =
-            format!("{}-{}", service.name(), uuid::Uuid::new_v4()).replace('-', "_");
-
-        let docker_test_client = Self {
-            container_name: container_name.clone(),
-            client,
-        };
-
-        docker_test_client
-            .client
-            .create_container(
-                Some(container::CreateContainerOptions {
-                    name: container_name.clone(),
-                }),
-                service.config(),
-            )
-            .await?;
-
-        docker_test_client
-            .client
-            .start_container::<&'static str>(&container_name, None)
-            .await?;
-
-        Ok(docker_test_client)
-    }
-
-    pub fn container_name(&self) -> &str {
-        &self.container_name
-    }
-
-    pub async fn stop(&self) -> Result<(), DockerError> {
-        kill_and_remove(&self.client, self.container_name()).await
-    }
-
-    pub async fn exposed_ports(&self) -> Result<MappedPorts, DockerError> {
-        use bollard::models::ContainerSummaryInner;
-
-        let results = {
-            let mut filters = HashMap::new();
-            filters.insert("name".to_string(), vec![self.container_name().to_string()]);
-            let options = Some(container::ListContainersOptions {
-                filters,
-                limit: Some(1),
-                ..Default::default()
-            });
-            self.client.list_containers(options).await?
-        };
-
-        let ports = match &results.as_slice() {
-            &[ContainerSummaryInner {
-                ports: Some(ports), ..
-            }] => ports,
-            unexpected_response => panic!(
-                "Received a unexpected_response from docker API: {:#?}",
-                unexpected_response
-            ),
-        };
-
-        Ok(to_mapped_ports(ports.clone()))
-    }
-
-    /// halts execution until a trigger message is detected on stdout or, optionally,
-    /// waits for a specified amount of time after the message appears.
-    pub async fn wait_for_message(
-        &self,
-        trigger_message: &[u8],
-        hard_wait: Duration,
-    ) -> Result<&Self, DockerError> {
-        // listen to container logs
-        let mut stream = self.client.logs::<String>(
-            &self.container_name,
-            Some(container::LogsOptions {
-                follow: true,
-                stdout: true,
-                stderr: true,
-                ..Default::default()
-            }),
-        );
-
-        // halt execution until a message is received
-        loop {
-            match stream.next().await {
-                Some(Ok(log_line)) => {
-                    if contains_subslice(log_line.to_string().as_bytes(), trigger_message) {
-                        break;
-                    }
-                }
-                Some(Err(error)) => return Err(error),
-                None => panic!("stream ended before expected message could be detected"),
-            }
-        }
-
-        sleep(hard_wait).await;
-        Ok(self)
-    }
-
-    /// Calls `docker exec` on the container to create a test database.
-    pub async fn create_postgres_database(
-        docker: &ServiceContainer,
-        db_name: &str,
-    ) -> Result<(), DockerError> {
-        const EXEC_TRIES: usize = 10;
-
-        use bollard::exec;
-
-        for attempt in 1..=EXEC_TRIES {
-            // 1. Create Exec
-            let config = exec::CreateExecOptions {
-                cmd: Some(vec!["createdb", "-E", "UTF8", "--locale=C", db_name]),
-                user: Some("postgres"),
-                attach_stdout: Some(true),
-                ..Default::default()
-            };
-
-            let message = docker
-                .client
-                .create_exec(docker.container_name(), config)
-                .await?;
-
-            // 2. Start Exec
-            let mut stream = docker.client.start_exec(&message.id, None);
-            while let Some(_) = stream.next().await { /* consume stream */ }
-
-            // 3. Inspect exec
-            let inspect = docker.client.inspect_exec(&message.id).await?;
-            match inspect.exit_code {
-                Some(0) => return Ok(()),
-                code if attempt < EXEC_TRIES => {
-                    println!(
-                        "failed to run 'createdb' (exit code: {:?}) Will try again, attempt {attempt} of {EXEC_TRIES}",
-                        code
-                    );
-                    tokio::time::sleep(Duration::from_secs(5)).await;
-                }
-                code => panic!(
-                    "failed to run 'createdb' command using docker exec (exit code: {:?})",
-                    code
-                ),
-            }
-        }
-        Ok(())
-    }
-}
-
-fn to_mapped_ports(input: Vec<bollard::models::Port>) -> MappedPorts {
-    let mut hashmap = HashMap::new();
-
-    for port in &input {
-        if let bollard::models::Port {
-            private_port,
-            public_port: Some(public_port),
-            ..
-        } = port
-        {
-            hashmap.insert(*private_port as u16, *public_port as u16);
-        }
-    }
-    if hashmap.is_empty() {
-        panic!("Container exposed no ports. Input={:?}", input)
-    }
-    hashmap
-}
diff --git a/tests/src/fixture/ethereum.rs b/tests/src/fixture/ethereum.rs
index e60f906f9a3..bba946a9ae9 100644
--- a/tests/src/fixture/ethereum.rs
+++ b/tests/src/fixture/ethereum.rs
@@ -3,25 +3,33 @@ use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
 use super::{
-    test_ptr, MutexBlockStreamBuilder, NoopAdapterSelector, NoopRuntimeAdapter,
-    StaticBlockRefetcher, StaticStreamBuilder, Stores, TestChain, NODE_ID,
+    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::firehose::{FirehoseEndpoint, FirehoseEndpoints, SubgraphLimit};
-use graph::prelude::ethabi::ethereum_types::H256;
-use graph::prelude::web3::types::{Address, Log, Transaction, H160};
-use graph::prelude::{ethabi, tiny_keccak, LightEthereumBlock, LoggerFactory, NodeId};
-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, chain::ChainSettings};
 use graph_chain_ethereum::{
     chain::BlockFinality,
     trigger::{EthereumBlockTriggerType, EthereumTrigger},
 };
-use graph_chain_ethereum::{Chain, ENV_VARS};
-use graph_mock::MockMetricsRegistry;
 
 pub async fn chain(
+    test_name: &str,
     blocks: Vec<BlockWithTriggers<Chain>>,
     stores: &Stores,
     triggers_adapter: Option<Arc<dyn TriggersAdapterSelector<Chain>>>,
@@ -30,34 +38,24 @@ pub async fn chain(
         triggers_in_block_sleep: Duration::ZERO,
         x: PhantomData,
     }));
-    let logger = graph::log::logger(true);
-    let mock_registry = Arc::new(MockMetricsRegistry::new());
-    let logger_factory = LoggerFactory::new(logger.cheap_clone(), None, mock_registry.clone());
-    let node_id = NodeId::new(NODE_ID).unwrap();
-
-    let chain_store = stores.chain_store.cheap_clone();
-
-    // This is needed bacause the stream builder only works for firehose and this will only be called if there
-    // are > 1 firehose endpoints. The endpoint itself is never used because it's mocked.
-    let firehose_endpoints: FirehoseEndpoints = vec![Arc::new(FirehoseEndpoint::new(
-        "",
-        "https://example.com",
-        None,
-        true,
-        false,
-        SubgraphLimit::Unlimited,
-    ))]
-    .into();
+
+    let CommonChainConfig {
+        logger_factory,
+        mock_registry,
+        chain_store,
+        firehose_endpoints,
+    } = CommonChainConfig::new(test_name, stores).await;
 
     let client = Arc::new(ChainClient::<Chain>::new_firehose(firehose_endpoints));
 
     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,
@@ -66,10 +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,
+        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 {
@@ -80,61 +80,155 @@ 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::Every)],
+        block: BlockFinality::Final(Arc::new(LightEthereumBlock::new(block))),
+        trigger_data: vec![Trigger::Chain(EthereumTrigger::Block(
+            ptr,
+            EthereumBlockTriggerType::End,
+        ))],
     }
 }
 
-pub fn empty_block(
+pub fn generate_empty_blocks_for_range(
     parent_ptr: BlockPtr,
-    ptr: BlockPtr,
-) -> BlockWithTriggers<graph_chain_ethereum::Chain> {
+    start: i32,
+    end: i32,
+    add_to_hash: u64, // Use to differentiate forks
+) -> Vec<BlockWithTriggers<Chain>> {
+    let mut blocks: Vec<BlockWithTriggers<Chain>> = vec![];
+
+    for i in start..(end + 1) {
+        let parent_ptr = blocks.last().map(|b| b.ptr()).unwrap_or(parent_ptr.clone());
+        let ptr = BlockPtr {
+            number: i,
+            hash: B256::from(U256::from(i as u64 + add_to_hash)).into(),
+        };
+        blocks.push(empty_block(parent_ptr, ptr));
+    }
+
+    blocks
+}
+
+pub fn empty_block(parent_ptr: BlockPtr, ptr: BlockPtr) -> BlockWithTriggers<Chain> {
     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::Every)],
+        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>) {
-    block.trigger_data.push(EthereumTrigger::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,
-        }),
-        None,
-    ))
+    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)")],
+                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(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(Trigger::Chain(EthereumTrigger::Block(
+            block.ptr(),
+            EthereumBlockTriggerType::End,
+        )))
 }
diff --git a/tests/src/fixture/mod.rs b/tests/src/fixture/mod.rs
index 7feaf6b5c58..90949c81be2 100644
--- a/tests/src/fixture/mod.rs
+++ b/tests/src/fixture/mod.rs
@@ -1,48 +1,65 @@
 pub mod ethereum;
 
+use std::collections::{BTreeSet, HashMap};
 use std::marker::PhantomData;
+use std::path::PathBuf;
 use std::sync::Mutex;
-use std::time::Duration;
+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::store::{BlockStore, DeploymentLocator};
-use graph::data::graphql::effort::LoadManager;
+use graph::components::link_resolver::{
+    ArweaveClient, ArweaveClientError, ArweaveResolver, FileLinkResolver, FileSizeLimit,
+    LinkResolverContext,
+};
+use graph::components::metrics::MetricsRegistry;
+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::ipfs_client::IpfsClient;
-use graph::prelude::ethabi::ethereum_types::H256;
+use graph::firehose::{FirehoseEndpoint, FirehoseEndpoints, SubgraphLimit};
+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, r, ApiVersion, BigInt, BlockNumber, DeploymentHash, GraphQlRunner as _,
-    LoggerFactory, MetricsRegistry, NodeId, QueryError, SubgraphAssignmentProvider, SubgraphName,
+    ApiVersion, BigInt, BlockNumber, DeploymentHash, GraphQlRunner as _, IpfsResolver,
+    LinkResolver, LoggerFactory, NodeId, QueryError, SubgraphCountMetric, SubgraphName,
     SubgraphRegistrar, SubgraphStore as _, SubgraphVersionSwitchingMode, TriggerProcessor,
+    lazy_static, q, r,
 };
-use graph::slog::crit;
-use graph_core::polling_monitor::ipfs_service;
-use graph_core::{
-    LinkResolver, SubgraphAssignmentProvider as IpfsSubgraphAssignmentProvider,
-    SubgraphInstanceManager, SubgraphRegistrar as IpfsSubgraphRegistrar, SubgraphTriggerProcessor,
-};
-use graph_mock::MockMetricsRegistry;
+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_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::{info, o, Discard, Logger};
+use slog::{Discard, Logger, crit, debug, info, o};
 use std::env::VarError;
 use std::pin::Pin;
 use std::sync::Arc;
@@ -57,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(),
@@ -65,39 +82,83 @@ 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,
+}
+
+impl CommonChainConfig {
+    async fn new(test_name: &str, stores: &Stores) -> Self {
+        let logger = test_logger(test_name);
+        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 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,
+        }
+    }
+}
 
 pub struct TestChain<C: Blockchain> {
     pub chain: Arc<C>,
     pub block_stream_builder: Arc<MutexBlockStreamBuilder<C>>,
 }
 
-impl<C: Blockchain> TestChain<C> {
-    pub fn set_block_stream(&self, blocks: Vec<BlockWithTriggers<C>>)
-    where
-        C::TriggerData: Clone,
-    {
+impl TestChainTrait<Chain> for TestChain<Chain> {
+    fn set_block_stream(&self, blocks: Vec<BlockWithTriggers<Chain>>) {
         let static_block_stream = Arc::new(StaticStreamBuilder { chain: blocks });
         *self.block_stream_builder.0.lock().unwrap() = static_block_stream;
     }
+
+    fn chain(&self) -> Arc<Chain> {
+        self.chain.clone()
+    }
+}
+
+pub trait TestChainTrait<C: Blockchain> {
+    fn set_block_stream(&self, blocks: Vec<BlockWithTriggers<C>>);
+
+    fn chain(&self) -> Arc<C>;
 }
 
 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)]
@@ -129,48 +190,68 @@ 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 = self.logger.cheap_clone();
-        let deployment = self.deployment.cheap_clone();
-
-        // 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())
-            .await
-            .unwrap();
+        let (logger, deployment, raw) = self.get_runner_context().await;
+        let tp: Box<dyn TriggerProcessor<_, _>> =
+            Box::new(graph_core::subgraph::SubgraphTriggerProcessor {});
 
-        let raw: serde_yaml::Mapping = serde_yaml::from_slice(&file_bytes).unwrap();
-        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()
     }
 
+    pub async fn get_runner_context(&self) -> (Logger, DeploymentLocator, serde_yaml::Mapping) {
+        let logger = self.logger.cheap_clone();
+        let deployment = self.deployment.cheap_clone();
+
+        // Stolen from the IPFS provider, there's prolly a nicer way to re-use it
+        let file_bytes = self
+            .link_resolver
+            .cat(
+                &LinkResolverContext::new(&deployment.hash, &logger),
+                &deployment.hash.to_ipfs_link(),
+            )
+            .await
+            .unwrap();
+
+        let raw: serde_yaml::Mapping = serde_yaml::from_slice(&file_bytes).unwrap();
+
+        (logger, deployment, raw)
+    }
+
     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);
 
         wait_for_sync(
             &self.logger,
-            &self.store,
+            self.store.clone(),
             &self.deployment.clone(),
             stop_block,
         )
@@ -180,16 +261,18 @@ 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,
-            &self.store,
+            self.store.clone(),
             &self.deployment.clone(),
             stop_block,
         )
@@ -199,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()
     }
@@ -227,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()
@@ -242,25 +321,35 @@ 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>,
-    network_store: Arc<Store>,
+    pub network_store: Arc<Store>,
     chain_store: Arc<ChainStore>,
 }
 
@@ -270,7 +359,13 @@ graph::prelude::lazy_static! {
     pub static ref STORE_MUTEX: Mutex<()> = Mutex::new(());
 }
 
-pub async fn stores(store_config_path: &str) -> Stores {
+fn test_logger(test_name: &str) -> Logger {
+    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 = {
@@ -284,29 +379,36 @@ pub async fn stores(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 = graph::log::logger(true);
-    let mock_registry: Arc<dyn MetricsRegistry> = Arc::new(MockMetricsRegistry::new());
+    let logger = test_logger(test_name);
+    let mock_registry: Arc<MetricsRegistry> = Arc::new(MetricsRegistry::mock());
     let node_id = NodeId::new(NODE_ID).unwrap();
     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(),
-        (vec![ChainIdentifier {
-            net_version: "".into(),
-            genesis_block_hash: test_ptr(0).hash,
-        }]),
-    )];
-    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,
@@ -316,108 +418,247 @@ pub async fn stores(store_config_path: &str) -> Stores {
     }
 }
 
+pub struct TestInfo {
+    pub test_dir: String,
+    pub test_name: String,
+    pub subgraph_name: SubgraphName,
+    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>(
-    subgraph_name: SubgraphName,
-    hash: &DeploymentHash,
+    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: &TestChain<C>,
+    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,
         None => EnvVars::from_env().unwrap(),
     });
 
-    let logger = graph::log::logger(true);
-    let mock_registry: Arc<dyn MetricsRegistry> = Arc::new(MockMetricsRegistry::new());
+    let logger = test_logger(&test_info.test_name);
+    let mock_registry: Arc<MetricsRegistry> = Arc::new(MetricsRegistry::mock());
     let logger_factory = LoggerFactory::new(logger.clone(), None, mock_registry.clone());
     let node_id = NodeId::new(NODE_ID).unwrap();
 
     // Make sure we're starting from a clean state.
     let subgraph_store = stores.network_store.subgraph_store();
-    cleanup(&subgraph_store, &subgraph_name, 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.clone());
+    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<dyn ArweaveResolver> =
+        arweave_resolver.unwrap_or_else(|| Arc::new(ArweaveClient::default()));
+    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 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(),
         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,
+    ));
+
     // Graphql runner
-    let subscription_manager = Arc::new(PanicSubscriptionManager {});
-    let load_manager = LoadManager::new(&logger, Vec::new(), mock_registry.clone());
+    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(),
+        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(subgraph_registrar.as_ref(), subgraph_name.clone())
-        .await
-        .expect("unable to create subgraph");
+    SubgraphRegistrar::create_subgraph(
+        subgraph_registrar.as_ref(),
+        test_info.subgraph_name.clone(),
+    )
+    .await
+    .expect("unable to create subgraph");
 
     let deployment = SubgraphRegistrar::create_subgraph_version(
         subgraph_registrar.as_ref(),
-        subgraph_name.clone(),
-        hash.clone(),
+        test_info.subgraph_name.clone(),
+        test_info.hash.clone(),
         node_id.clone(),
         None,
         None,
         graft_block,
+        None,
+        false,
     )
     .await
     .expect("failed to create subgraph version");
@@ -427,63 +668,93 @@ pub async fn setup<C: Blockchain>(
         provider: subgraph_provider,
         store: subgraph_store,
         deployment,
-        subgraph_name,
+        subgraph_name: test_info.subgraph_name.clone(),
         graphql_runner,
         instance_manager: subgraph_instance_manager,
         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(())
 }
 
 pub async fn wait_for_sync(
     logger: &Logger,
-    store: &SubgraphStore,
+    store: Arc<SubgraphStore>,
     deployment: &DeploymentLocator,
     stop_block: BlockPtr,
 ) -> Result<(), SubgraphError> {
-    let mut err_count = 0;
-    while err_count < 10 {
-        tokio::time::sleep(Duration::from_millis(1000)).await;
+    // We wait one second between checks for the subgraph to sync. That
+    // means we wait up to a 30 seconds here by default.
+    lazy_static! {
+        static ref MAX_WAIT: Duration = Duration::from_secs(
+            std::env::var("RUNNER_TESTS_WAIT_FOR_SYNC_SECS")
+                .map(|val| val.parse().unwrap())
+                .unwrap_or(30)
+        );
+    }
+    const WAIT_TIME: Duration = Duration::from_secs(1);
+
+    /// We flush here to speed up how long the write queue waits before it
+    /// considers a batch complete and writable. Without flushing, we would
+    /// have to wait for `GRAPH_STORE_WRITE_BATCH_DURATION` before all
+    /// changes have been written to the database
+    async fn flush(logger: &Logger, store: &Arc<SubgraphStore>, deployment: &DeploymentLocator) {
+        store
+            .clone()
+            .writable(logger.clone(), deployment.id, Arc::new(vec![]))
+            .await
+            .unwrap()
+            .flush()
+            .await
+            .unwrap();
+    }
+
+    let start = Instant::now();
+
+    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,
             res => {
                 info!(&logger, "{:?}", res);
-                err_count += 1;
                 continue;
             }
         };
-
-        let status = store.status_for_id(deployment.id);
+        info!(logger, "TEST: sync status: {:?}", block_ptr);
+        let status = store.status_for_id(deployment.id).await;
 
         if let Some(fatal_error) = status.fatal_error {
-            if fatal_error.block_ptr.as_ref().unwrap() == &stop_block {
-                return Err(fatal_error);
-            }
+            return Err(fatal_error);
         }
 
         if block_ptr == stop_block {
             info!(logger, "TEST: reached stop block");
-            break;
+            return Ok(());
         }
     }
 
-    Ok(())
+    // We only get here if we timed out waiting for the subgraph to reach
+    // the stop block
+    panic!("Sync did not complete within {}s", MAX_WAIT.as_secs());
 }
 
 struct StaticBlockRefetcher<C: Blockchain> {
@@ -537,14 +808,27 @@ impl<C: Blockchain> BlockStreamBuilder<C> for MutexBlockStreamBuilder<C> {
 
     async fn build_polling(
         &self,
-        _chain: Arc<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
     }
 }
 
@@ -587,25 +871,40 @@ where
 
     async fn build_polling(
         &self,
-        _chain: Arc<C>,
+        _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> {}
+impl<C: Blockchain> BlockStream<C> for StaticStream<C> {
+    fn buffer_size_hint(&self) -> usize {
+        1
+    }
+}
 
 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)
@@ -615,32 +914,49 @@ 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,
 {
+    struct ForkDb<B: Block> {
+        blocks: HashMap<BlockPtr, B>,
+    }
+
+    impl<B: Block> ForkDb<B> {
+        fn common_ancestor(&self, a: BlockPtr, b: BlockPtr) -> Option<&B> {
+            let mut a = self.blocks.get(&a).unwrap();
+            let mut b = self.blocks.get(&b).unwrap();
+            while a.number() > b.number() {
+                a = self.blocks.get(&a.parent_ptr()?).unwrap();
+            }
+            while b.number() > a.number() {
+                b = self.blocks.get(&b.parent_ptr()?).unwrap();
+            }
+            while a.hash() != b.hash() {
+                a = self.blocks.get(&a.parent_ptr()?).unwrap();
+                b = self.blocks.get(&b.parent_ptr()?).unwrap();
+            }
+            Some(a)
+        }
+    }
+
+    let fork_db = ForkDb {
+        blocks: blocks.iter().map(|b| (b.ptr(), b.block.clone())).collect(),
+    };
+
     // See also: static-stream-builder
     stream! {
-        let current_block = current_idx.map(|idx| &blocks[idx]);
-        let mut current_ptr = current_block.map(|b| b.ptr());
-        let mut current_parent_ptr = current_block.and_then(|b| b.parent_ptr());
+        let mut current_ptr = current_idx.map(|idx| blocks[idx].ptr());
         let skip = current_idx.map(|idx| idx + 1).unwrap_or(0);
         let mut blocks_iter = blocks.iter().skip(skip).peekable();
         while let Some(&block) = blocks_iter.peek() {
             if block.parent_ptr() == current_ptr {
                 current_ptr = Some(block.ptr());
-                current_parent_ptr = block.parent_ptr();
                 blocks_iter.next(); // Block consumed, advance the iterator.
                 yield Ok(BlockStreamEvent::ProcessBlock(block.clone(), FirehoseCursor::None));
             } else {
-                let revert_to = current_parent_ptr.unwrap();
+                let revert_to = fork_db.common_ancestor(block.ptr(), current_ptr.unwrap()).unwrap().ptr();
                 current_ptr = Some(revert_to.clone());
-                current_parent_ptr = blocks
-                    .iter()
-                    .find(|b| b.ptr() == revert_to)
-                    .unwrap()
-                    .block
-                    .parent_ptr();
                 yield Ok(BlockStreamEvent::Revert(revert_to, FirehoseCursor::None));
             }
         }
@@ -652,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,
@@ -720,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/helpers.rs b/tests/src/helpers.rs
index 21d520c00d2..50403d46eea 100644
--- a/tests/src/helpers.rs
+++ b/tests/src/helpers.rs
@@ -1,27 +1,13 @@
-use std::collections::HashMap;
-use std::ffi::OsStr;
-use std::net::TcpListener;
-use std::path::Path;
+use std::fs::File;
+use std::io::{BufReader, Write};
+use std::path::PathBuf;
 use std::process::Command;
-use std::sync::atomic::AtomicU16;
 
-use anyhow::Context;
-
-const POSTGRESQL_DEFAULT_PORT: u16 = 5432;
-const GANACHE_DEFAULT_PORT: u16 = 8545;
-const IPFS_DEFAULT_PORT: u16 = 5001;
-
-/// Maps `Service => Host` exposed ports.
-pub type MappedPorts = HashMap<u16, u16>;
-
-/// Strip parent directories from filenames
-pub fn basename(path: &impl AsRef<Path>) -> String {
-    path.as_ref()
-        .file_name()
-        .map(OsStr::to_string_lossy)
-        .map(String::from)
-        .expect("failed to infer basename for path.")
-}
+use crate::output::OutputConfig;
+use anyhow::{Context, bail};
+use graph::itertools::Itertools;
+use graph::prelude::serde_json::{Value, json};
+use graph::prelude::{reqwest, serde_json};
 
 /// Parses stdout bytes into a prefixed String
 pub fn pretty_output(blob: &[u8], prefix: &str) -> String {
@@ -32,85 +18,56 @@ pub fn pretty_output(blob: &[u8], prefix: &str) -> String {
         .join("\n")
 }
 
-/// Finds and returns a free port. Ports are never *guaranteed* to be free because of
-/// [TOCTOU](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use) race
-/// conditions.
-///
-/// This function guards against conflicts coming from other callers, so you
-/// will only get port conflicts from external resources.
-fn get_free_port() -> u16 {
-    // We start cycling through ports at 10000, which is high enough in the port
-    // space to to cause few conflicts.
-    const RANGE_START: u16 = 10_000;
-    static COUNTER: AtomicU16 = AtomicU16::new(RANGE_START);
-
-    loop {
-        let ordering = std::sync::atomic::Ordering::SeqCst;
-        let port = COUNTER.fetch_add(1, ordering);
-        if port < RANGE_START {
-            // We've wrapped around, start over.
-            COUNTER.store(RANGE_START, ordering);
-            continue;
-        }
+/// A file in the `tests` crate root
+#[derive(Debug, Clone)]
+pub struct TestFile {
+    pub relative: String,
+    pub path: PathBuf,
+}
 
-        let bind = TcpListener::bind(("127.0.0.1", port));
-        if bind.is_ok() {
-            return port;
+impl TestFile {
+    /// Create a new file where `path` is taken relative to the `tests` crate root
+    pub fn new(relative: &str) -> Self {
+        let cwd = std::env::current_dir().unwrap().canonicalize().unwrap();
+        let path = cwd.join(relative);
+        Self {
+            relative: relative.to_string(),
+            path,
         }
     }
-}
 
-#[derive(Debug, Copy, Clone)]
-pub struct GraphNodePorts {
-    pub http: u16,
-    pub index: u16,
-    pub ws: u16,
-    pub admin: u16,
-    pub metrics: u16,
-}
+    pub fn create(&self) -> File {
+        std::fs::File::create(&self.path).unwrap()
+    }
 
-impl GraphNodePorts {
-    /// Populates all values with random free ports.
-    pub fn random_free() -> GraphNodePorts {
-        Self {
-            http: get_free_port(),
-            index: get_free_port(),
-            ws: get_free_port(),
-            admin: get_free_port(),
-            metrics: get_free_port(),
-        }
+    pub fn read(&self) -> anyhow::Result<File> {
+        std::fs::File::open(&self.path)
+            .with_context(|| format!("Failed to open file {}", self.path.to_str().unwrap()))
     }
-}
 
-// Build a postgres connection string
-pub fn make_postgres_uri(db_name: &str, postgres_ports: &MappedPorts) -> String {
-    let port = postgres_ports
-        .get(&POSTGRESQL_DEFAULT_PORT)
-        .expect("failed to fetch Postgres port from mapped ports");
-    format!(
-        "postgresql://{user}:{password}@{host}:{port}/{database_name}",
-        user = "postgres",
-        password = "password",
-        host = "localhost",
-        port = port,
-        database_name = db_name,
-    )
-}
+    pub fn reader(&self) -> anyhow::Result<BufReader<File>> {
+        Ok(BufReader::new(self.read()?))
+    }
+
+    pub fn newer(&self, other: &TestFile) -> bool {
+        self.path.metadata().unwrap().modified().unwrap()
+            > other.path.metadata().unwrap().modified().unwrap()
+    }
 
-pub fn make_ipfs_uri(ipfs_ports: &MappedPorts) -> String {
-    let port = ipfs_ports
-        .get(&IPFS_DEFAULT_PORT)
-        .expect("failed to fetch IPFS port from mapped ports");
-    format!("http://{host}:{port}", host = "localhost", port = port)
+    pub fn append(&self, name: &str) -> Self {
+        let mut path = self.path.clone();
+        path.push(name);
+        Self {
+            relative: format!("{}/{}", self.relative, name),
+            path,
+        }
+    }
 }
 
-// Build a Ganache connection string. Returns the port number and the URI.
-pub fn make_ganache_uri(ganache_ports: &MappedPorts) -> (u16, String) {
-    let port = ganache_ports
-        .get(&GANACHE_DEFAULT_PORT)
-        .expect("failed to fetch Ganache port from mapped ports");
-    let uri = format!("test:http://{host}:{port}", host = "localhost", port = port);
-    (*port, uri)
+impl std::fmt::Display for TestFile {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.relative)
+    }
 }
 
 pub fn contains_subslice<T: PartialEq>(data: &[T], needle: &[T]) -> bool {
@@ -124,14 +81,76 @@ 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()
 }
+
+/// Run a command, check that it succeeded and return its stdout and stderr
+/// in a friendly error format for display
+pub async fn run_checked(cmd: &mut tokio::process::Command) -> anyhow::Result<()> {
+    let std_cmd = cmd.as_std();
+    let cmdline = format!(
+        "{} {}",
+        std_cmd.get_program().to_str().unwrap(),
+        std_cmd
+            .get_args()
+            .map(|arg| arg.to_str().unwrap())
+            .join(" ")
+    );
+    let output = cmd
+        .output()
+        .await
+        .with_context(|| format!("Command failed: {cmdline}"))?;
+
+    if output.status.success() {
+        Ok(())
+    } else {
+        let stdout = String::from_utf8_lossy(&output.stdout);
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        bail!(
+            "Command failed: {}\ncmdline: {cmdline}\nstdout: {stdout}\nstderr: {stderr}",
+            output.status,
+        )
+    }
+}
+
+pub async fn graphql_query(endpoint: &str, query: &str) -> anyhow::Result<Value> {
+    graphql_query_with_vars(endpoint, query, Value::Null).await
+}
+
+pub async fn graphql_query_with_vars(
+    endpoint: &str,
+    query: &str,
+    vars: Value,
+) -> anyhow::Result<Value> {
+    let query = if vars == Value::Null {
+        json!({ "query": query }).to_string()
+    } else {
+        json!({ "query": query, "variables": vars }).to_string()
+    };
+    let client = reqwest::Client::new();
+    let res = client
+        .post(endpoint)
+        .header("Content-Type", "application/json")
+        .body(query)
+        .send()
+        .await?;
+    let text = res.text().await?;
+    let body: Value = serde_json::from_str(&text)?;
+
+    Ok(body)
+}
diff --git a/tests/src/lib.rs b/tests/src/lib.rs
index 3a3b4a87659..860f6da714d 100644
--- a/tests/src/lib.rs
+++ b/tests/src/lib.rs
@@ -1,3 +1,12 @@
-pub mod docker_utils;
+pub mod config;
+pub mod contract;
 pub mod fixture;
 pub mod helpers;
+#[macro_use]
+pub mod macros;
+pub mod output;
+pub mod recipe;
+pub mod subgraph;
+
+pub use config::{CONFIG, Config, DbConfig, EthConfig};
+pub use output::OutputConfig;
diff --git a/tests/src/macros.rs b/tests/src/macros.rs
new file mode 100644
index 00000000000..74999b1f64b
--- /dev/null
+++ b/tests/src/macros.rs
@@ -0,0 +1,22 @@
+// The colored output here is very primitive and only works for ANSI
+// terminals. We'd like to use ansterm and owo_style like cargo does (see
+// https://docs.rs/anstream/0.6.4/anstream/) but that requeires Rust 1.70.0
+// and we are stuck on 1.68
+
+#[macro_export]
+macro_rules! status {
+    ($prefix:expr, $($arg:tt)*) => {
+        let msg = format!($($arg)*);
+        println!("\x1b[1;32m{:>30}\x1b[0m {}", $prefix, msg);
+        std::io::Write::flush(&mut std::io::stdout()).unwrap();
+    }
+}
+
+#[macro_export]
+macro_rules! error {
+    ($prefix:expr, $($arg:tt)*) => {
+        let msg = format!($($arg)*);
+        println!("\x1b[1;31m{:>30}\x1b[0m {}", $prefix, msg);
+        std::io::Write::flush(&mut std::io::stdout()).unwrap();
+    }
+}
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
new file mode 100644
index 00000000000..43c970fbd40
--- /dev/null
+++ b/tests/src/subgraph.rs
@@ -0,0 +1,247 @@
+use std::{
+    fs,
+    io::{Read as _, Write as _},
+    time::{Duration, Instant},
+};
+
+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::{
+    CONFIG,
+    contract::Contract,
+    helpers::{TestFile, graphql_query, graphql_query_with_vars, run_checked},
+};
+
+#[derive(Clone, Debug)]
+pub struct Subgraph {
+    pub name: String,
+    pub deployment: String,
+    pub synced: bool,
+    pub healthy: bool,
+}
+
+impl Subgraph {
+    pub fn dir(name: &str) -> TestFile {
+        TestFile::new(&format!("integration-tests/{name}"))
+    }
+
+    pub async fn patch(dir: &TestFile, contracts: &[Contract]) -> anyhow::Result<()> {
+        let mut orig = String::new();
+        dir.append("subgraph.yaml")
+            .read()?
+            .read_to_string(&mut orig)
+            .unwrap();
+        for contract in contracts {
+            let repl = format!("@{}@", contract.name);
+            let addr = format!("{:?}", contract.address);
+            orig = orig.replace(&repl, &addr);
+        }
+
+        let mut patched = dir.append("subgraph.yaml.patched").create();
+        patched.write_all(orig.as_bytes()).unwrap();
+        Ok(())
+    }
+
+    /// 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
+            .arg("create")
+            .arg("--node")
+            .arg(CONFIG.graph_node.admin_uri())
+            .arg(&name)
+            .current_dir(&dir.path);
+
+        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);
+        let cmd = prog
+            .arg("deploy")
+            .arg("--node")
+            .arg(CONFIG.graph_node.admin_uri())
+            .arg("--version-label")
+            .arg("v0.0.1")
+            .arg("--ipfs")
+            .arg(&CONFIG.graph_node.ipfs_uri)
+            .arg(&name)
+            .arg("subgraph.yaml.patched")
+            .current_dir(&dir.path);
+        run_checked(cmd).await?;
+
+        Ok(name)
+    }
+
+    /// Wait until the subgraph has synced or failed
+    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?
+                && (subgraph.synced || !subgraph.healthy)
+            {
+                return Ok(subgraph);
+            }
+            sleep(Duration::from_millis(2000)).await;
+        }
+        Err(anyhow!("Subgraph {} never synced or failed", name))
+    }
+
+    pub async fn status(name: &str) -> anyhow::Result<Option<Subgraph>> {
+        #[derive(Deserialize)]
+        struct Status {
+            pub subgraph: String,
+            pub health: String,
+            pub synced: bool,
+        }
+
+        let query = format!(
+            r#"query {{ status: indexingStatusesForSubgraphName(subgraphName: "{}") {{
+              subgraph health synced
+            }} }}"#,
+            name
+        );
+        let body = graphql_query(&CONFIG.graph_node.index_node_uri(), &query).await?;
+        let status = &body["data"]["status"];
+        if status.is_null() || status.as_array().unwrap().is_empty() {
+            return Ok(None);
+        }
+        let status: Status = serde_json::from_value(status[0].clone())?;
+        let subgraph = Subgraph {
+            name: name.to_string(),
+            deployment: status.subgraph,
+            synced: status.synced,
+            healthy: status.health == "healthy",
+        };
+        Ok(Some(subgraph))
+    }
+
+    /// Make a GraphQL query to the subgraph's data API
+    pub async fn query(&self, text: &str) -> anyhow::Result<Value> {
+        let endpoint = format!(
+            "{}/subgraphs/name/{}",
+            CONFIG.graph_node.http_uri(),
+            self.name
+        );
+        graphql_query(&endpoint, text).await
+    }
+
+    /// Make a GraphQL query to the index node API
+    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 c9b68d6cc35..4f3457cda41 100644
--- a/tests/tests/integration_tests.rs
+++ b/tests/tests/integration_tests.rs
@@ -9,493 +9,1852 @@
 //! tasks are really worth parallelizing, and applying this trick
 //! indiscriminately will only result in messy code and diminishing returns.
 
-use anyhow::Context;
-use futures::{StreamExt, TryStreamExt};
-use graph_tests::docker_utils::{pull_service_images, ServiceContainer, ServiceContainerKind};
-use graph_tests::helpers::{
-    basename, make_ganache_uri, make_ipfs_uri, make_postgres_uri, pretty_output, GraphNodePorts,
-    MappedPorts,
+use std::collections::HashMap;
+use std::future::Future;
+use std::pin::Pin;
+use std::time::{Duration, Instant};
+
+use anyhow::{Context, Result, anyhow, bail};
+use graph::components::subgraph::{
+    ProofOfIndexing, ProofOfIndexingEvent, ProofOfIndexingFinisher, ProofOfIndexingVersion,
 };
-use std::fs;
-use std::num::NonZeroUsize;
-use std::path::{Path, PathBuf};
-use std::sync::Arc;
-use std::time::Duration;
-use tokio::io::AsyncReadExt;
-use tokio::process::{Child, Command};
-
-/// All directories containing integration tests to run.
-///
-/// Hardcoding these paths seems "wrong", and we very well could obtain this
-/// list with some directory listing magic. That would, however, also
-/// require us to filter out `node_modules`, support files, etc.. Hardly worth
-/// it.
-pub const INTEGRATION_TEST_DIRS: &[&str] = &[
-    "api-version-v0-0-4",
-    "ganache-reverts",
-    "host-exports",
-    "non-fatal-errors",
-    "overloaded-contract-functions",
-    "poi-for-failed-subgraph",
-    "remove-then-update",
-    "value-roundtrip",
-];
+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::subgraph::Subgraph;
+use graph_tests::{CONFIG, error, status};
+use tokio::process::Child;
+use tokio::task::JoinError;
+use tokio::time::sleep;
 
-#[derive(Debug, Clone)]
-struct IntegrationTestSettings {
-    n_parallel_tests: u64,
-    ganache_hard_wait: Duration,
-    ipfs_hard_wait: Duration,
-    postgres_hard_wait: Duration,
+const SUBGRAPH_LAST_GRAFTING_BLOCK: i32 = 3;
+
+type TestFn = Box<
+    dyn FnOnce(TestContext) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + Send>>
+        + Sync
+        + Send,
+>;
+
+pub struct TestContext {
+    pub subgraph: Subgraph,
 }
 
-impl IntegrationTestSettings {
-    /// Automatically fills in missing env. vars. with defaults.
-    ///
-    /// # Panics
-    ///
-    /// Panics if any of the env. vars. is set incorrectly.
-    pub fn from_env() -> Self {
-        Self {
-            n_parallel_tests: parse_numeric_environment_variable("N_CONCURRENT_TESTS").unwrap_or(
-                // Lots of I/O going on in these tests, so we spawn twice as
-                // many jobs as suggested.
-                2 * std::thread::available_parallelism()
-                    .map(NonZeroUsize::get)
-                    .unwrap_or(2) as u64,
-            ),
-            ganache_hard_wait: Duration::from_secs(
-                parse_numeric_environment_variable("TESTS_GANACHE_HARD_WAIT_SECONDS").unwrap_or(0),
-            ),
-            ipfs_hard_wait: Duration::from_secs(
-                parse_numeric_environment_variable("TESTS_IPFS_HARD_WAIT_SECONDS").unwrap_or(0),
-            ),
-            postgres_hard_wait: Duration::from_secs(
-                parse_numeric_environment_variable("TESTS_POSTGRES_HARD_WAIT_SECONDS").unwrap_or(0),
-            ),
+pub enum TestStatus {
+    Ok,
+    Err(anyhow::Error),
+    Panic(JoinError),
+}
+
+pub struct TestResult {
+    pub name: String,
+    pub subgraph: Option<Subgraph>,
+    pub status: TestStatus,
+}
+
+impl TestResult {
+    pub fn success(&self) -> bool {
+        matches!(self.status, TestStatus::Ok)
+    }
+
+    fn print_subgraph(&self) {
+        if let Some(subgraph) = &self.subgraph {
+            println!("    Subgraph: {}", subgraph.deployment);
+        }
+    }
+
+    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";
+        const NC: &str = "\x1b[0m";
+
+        match &self.status {
+            TestStatus::Ok => {
+                println!("* {GREEN}Test {} succeeded{NC}", self.name);
+                self.print_subgraph();
+            }
+            TestStatus::Err(e) => {
+                println!("* {RED}Test {} failed{NC}", self.name);
+                self.print_subgraph();
+                println!("    {:?}", e);
+            }
+            TestStatus::Panic(e) => {
+                if e.is_cancelled() {
+                    println!("* {RED}Test {} was cancelled{NC}", self.name)
+                } else if e.is_panic() {
+                    println!("* {RED}Test {} failed{NC}", self.name);
+                } else {
+                    println!("* {RED}Test {} exploded mysteriously{NC}", self.name)
+                }
+                self.print_subgraph();
+            }
         }
     }
 }
 
-/// An aggregator of all configuration and settings required to run a single
-/// integration test.
-#[derive(Debug)]
-struct IntegrationTestRecipe {
-    postgres_uri: String,
-    ipfs_uri: String,
-    ganache_port: u16,
-    ganache_uri: String,
-    graph_node_ports: GraphNodePorts,
-    graph_node_bin: Arc<PathBuf>,
-    test_directory: PathBuf,
+#[derive(Debug, Clone)]
+pub enum SourceSubgraph {
+    Subgraph(String),
+    WithAlias((String, String)), // (alias, test_name)
 }
 
-impl IntegrationTestRecipe {
-    fn test_name(&self) -> String {
-        basename(&self.test_directory)
+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,
+        }
     }
 
-    fn graph_node_admin_uri(&self) -> String {
-        format!("http://localhost:{}/", self.graph_node_ports.admin)
+    #[allow(dead_code)] // Used by gnd_tests.rs
+    pub fn alias(&self) -> Option<&str> {
+        match self {
+            Self::Subgraph(_) => None,
+            Self::WithAlias((alias, _)) => Some(alias),
+        }
     }
 }
 
-/// Info about a finished test command
-#[derive(Debug)]
-struct IntegrationTestResult {
-    success: bool,
-    _exit_status_code: Option<i32>,
-    output: Output,
+pub struct TestCase {
+    pub name: String,
+    pub test: TestFn,
+    pub source_subgraph: Option<Vec<SourceSubgraph>>,
 }
 
-#[derive(Debug)]
-struct Output {
-    stdout: Option<String>,
-    stderr: Option<String>,
+impl TestCase {
+    pub fn new<T>(name: &str, test: fn(TestContext) -> T) -> Self
+    where
+        T: Future<Output = Result<(), anyhow::Error>> + Send + 'static,
+    {
+        Self {
+            name: name.to_string(),
+            test: Box::new(move |ctx| Box::pin(test(ctx))),
+            source_subgraph: None,
+        }
+    }
+
+    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(subgraph_name, contracts, None).await {
+            Ok(name) => name,
+            Err(e) => {
+                error!(&self.name, "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) => {
+                error!(&self.name, "Subgraph never synced or failed");
+                return TestResult {
+                    name: self.name.clone(),
+                    subgraph: None,
+                    status: TestStatus::Err(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);
+        }
+
+        let ctx = TestContext {
+            subgraph: subgraph.clone(),
+        };
+
+        status!(&self.name, "Starting test");
+        let subgraph2 = subgraph.clone();
+        let res = tokio::spawn(async move { (self.test)(ctx).await }).await;
+        let status = match res {
+            Ok(Ok(())) => {
+                status!(&self.name, "Test succeeded");
+                TestStatus::Ok
+            }
+            Ok(Err(e)) => {
+                error!(&self.name, "Test failed");
+                TestStatus::Err(e)
+            }
+            Err(e) => {
+                error!(&self.name, "Test panicked");
+                TestStatus::Panic(e)
+            }
+        };
+        TestResult {
+            name: self.name.clone(),
+            subgraph: Some(subgraph2),
+            status,
+        }
+    }
+
+    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")),
+                    };
+                }
+            };
+
+        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()));
+                }
+            }
+        }
+        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(mappings)
+    }
 }
 
-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)?;
+/// Run the given `query` against the `subgraph` and check that the result
+/// has no errors and that the `data` portion of the response matches the
+/// `exp` value.
+pub async fn query_succeeds(
+    title: &str,
+    subgraph: &Subgraph,
+    query: &str,
+    exp: Value,
+) -> anyhow::Result<()> {
+    let resp = subgraph.query(query).await?;
+    match resp.get("errors") {
+        None => { /* nothing to do */ }
+        Some(errors) => {
+            bail!(
+                "query for `{}` returned GraphQL errors: {:?}",
+                title,
+                errors
+            );
         }
-        if let Some(ref stderr) = self.stderr {
-            write!(f, "{}", stderr)?
+    }
+    match resp.get("data") {
+        None => {
+            bail!("query for `{}` returned no data", title);
+        }
+        Some(data) => {
+            if &exp != data {
+                bail!(
+                    "query for `{title}` returned unexpected data:  \nexpected: {exp:?}\n  returned: {data:?}",
+                );
+            }
         }
-        Ok(())
     }
+    Ok(())
 }
 
-// The results of a finished integration test
-#[derive(Debug)]
-struct IntegrationTestSummary {
-    test_recipe: IntegrationTestRecipe,
-    test_command_result: IntegrationTestResult,
-    graph_node_output: Output,
+/*
+* 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_int8(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": "9223372036854775807",
+          },
+        ],
+    });
+    assert_eq!(None, resp.get("errors"));
+    assert_eq!(exp, resp["data"]);
+
+    Ok(())
 }
 
-impl IntegrationTestSummary {
-    fn print_outcome(&self) {
-        let status = match self.test_command_result.success {
-            true => "SUCCESS",
-            false => "FAILURE",
-        };
-        println!("- Test: {}: {}", status, self.test_recipe.test_name())
-    }
-
-    fn print_failure(&self) {
-        if self.test_command_result.success {
-            return;
-        }
-        let test_name = self.test_recipe.test_name();
-        println!("=============");
-        println!("\nFailed test: {}", test_name);
-        println!("-------------");
-        println!("{:#?}", self.test_recipe);
-        println!("-------------");
-        println!("\nFailed test command output:");
-        println!("---------------------------");
-        println!("{}", self.test_command_result.output);
-        println!("--------------------------");
-        println!("graph-node command output:");
-        println!("--------------------------");
-        println!("{}", self.graph_node_output);
-    }
+/*
+* 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(())
 }
 
-/// The main test entrypoint.
-#[tokio::test]
-async fn parallel_integration_tests() -> anyhow::Result<()> {
-    let test_settings = IntegrationTestSettings::from_env();
-
-    let current_working_dir =
-        std::env::current_dir().context("failed to identify working directory")?;
-    let yarn_workspace_dir = current_working_dir.join("integration-tests");
-    let test_dirs = INTEGRATION_TEST_DIRS
-        .iter()
-        .map(|p| yarn_workspace_dir.join(PathBuf::from(p)))
-        .collect::<Vec<PathBuf>>();
+pub async fn test_block_handlers(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
 
-    // Show discovered tests.
-    println!("Found {} integration test(s):", test_dirs.len());
-    for dir in &test_dirs {
-        println!("  - {}", basename(dir));
+    // test non-filtered blockHandler
+    let exp = json!({
+        "blocks": [
+        { "id": "1", "number": "1" },
+        { "id": "2", "number": "2" },
+        { "id": "3", "number": "3" },
+        { "id": "4", "number": "4" },
+        { "id": "5", "number": "5" },
+        { "id": "6", "number": "6" },
+        { "id": "7", "number": "7" },
+        { "id": "8", "number": "8" },
+        { "id": "9", "number": "9" },
+        { "id": "10", "number": "10" },
+      ]
+    });
+    query_succeeds(
+        "test non-filtered blockHandler",
+        &subgraph,
+        "{ blocks(orderBy: number, first: 10) { id number } }",
+        exp,
+    )
+    .await?;
+
+    // test query
+    let mut values = Vec::new();
+    for i in 0..=10 {
+        values.push(json!({ "id": i.to_string(), "value": i.to_string() }));
     }
+    let exp = json!({ "foos": Value::Array(values) });
+    query_succeeds(
+        "test query",
+        &subgraph,
+        "{ foos(orderBy: value, skip: 1) { id value } }",
+        exp,
+    )
+    .await?;
 
-    tokio::join!(
-        // Pull the required Docker images.
-        pull_service_images(),
-        // Run `yarn` command to build workspace.
-        run_yarn_command(&yarn_workspace_dir),
-    );
+    // should call intialization handler first
+    let exp = json!({
+      "foo": { "id": "initialize", "value": "-1" },
+    });
+    query_succeeds(
+        "should call intialization handler first",
+        &subgraph,
+        "{ foo( id: \"initialize\" ) { id value } }",
+        exp,
+    )
+    .await?;
 
-    println!("Starting PostgreSQL and IPFS containers...");
+    // test blockHandler with polling filter
+    let exp = json!({
+        "blockFromPollingHandlers": [
+        { "id": "1", "number": "1" },
+        { "id": "4", "number": "4" },
+        { "id": "7", "number": "7" },
+      ]
+    });
+    query_succeeds(
+        "test blockHandler with polling filter",
+        &subgraph,
+        "{ blockFromPollingHandlers(orderBy: number, first: 3) { id number } }",
+        exp,
+    )
+    .await?;
 
-    // Not only do we start the containers, but we also need to wait for
-    // them to be up and running and ready to accept connections.
-    let (postgres, ipfs) = tokio::try_join!(
-        ServiceDependency::start(
-            ServiceContainerKind::Postgres,
-            "database system is ready to accept connections",
-            test_settings.postgres_hard_wait
-        ),
-        ServiceDependency::start(
-            ServiceContainerKind::Ipfs,
-            "Daemon is ready",
-            test_settings.ipfs_hard_wait
-        ),
-    )?;
+    // test other blockHandler with polling filter
+    let exp = json!({
+        "blockFromOtherPollingHandlers": [
+        { "id": "2", "number": "2" },
+        { "id": "4", "number": "4" },
+        { "id": "6", "number": "6" },
+      ]
+    });
+    query_succeeds(
+        "test other blockHandler with polling filter",
+        &subgraph,
+        "{ blockFromOtherPollingHandlers(orderBy: number, first: 3) { id number } }",
+        exp,
+    )
+    .await?;
 
-    println!(
-        "Containers are ready! Running tests with N_CONCURRENT_TESTS={} ...",
-        test_settings.n_parallel_tests
-    );
+    // test initialization handler
+    let exp = json!({
+        "initializes": [
+        { "id": "1", "block": "1" },
+      ]
+    });
+    query_succeeds(
+        "test initialization handler",
+        &subgraph,
+        "{ initializes(orderBy: block, first: 10) { id block } }",
+        exp,
+    )
+    .await?;
 
-    let graph_node = Arc::new(
-        fs::canonicalize("../target/debug/graph-node")
-            .context("failed to infer `graph-node` program location. (Was it built already?)")?,
+    // test subgraphFeatures endpoint returns handlers correctly
+    let subgraph_features = Subgraph::query_with_vars(
+        "query GetSubgraphFeatures($deployment: String!) {
+          subgraphFeatures(subgraphId: $deployment) {
+            specVersion
+            apiVersion
+            features
+            dataSources
+            network
+            handlers
+          }
+        }",
+        json!({ "deployment": subgraph.deployment }),
+    )
+    .await?;
+    let handlers = &subgraph_features["data"]["subgraphFeatures"]["handlers"];
+    assert!(
+        handlers.is_array(),
+        "subgraphFeatures.handlers must be an array"
     );
+    let handlers = handlers.as_array().unwrap();
+    for handler in [
+        "block_filter_polling",
+        "block_filter_once",
+        "block",
+        "event",
+    ] {
+        assert!(
+            handlers.contains(&Value::String(handler.to_string())),
+            "handlers {:?} must contain {}",
+            handlers,
+            handler
+        );
+    }
 
-    let stream = tokio_stream::iter(test_dirs)
-        .map(|dir| {
-            run_integration_test(
-                dir,
-                postgres.clone(),
-                ipfs.clone(),
-                graph_node.clone(),
-                test_settings.ganache_hard_wait,
-            )
-        })
-        .buffered(test_settings.n_parallel_tests as usize);
-
-    let test_results: Vec<IntegrationTestSummary> = stream.try_collect().await?;
-    let failed = test_results.iter().any(|r| !r.test_command_result.success);
-
-    // All tests have finished; we don't need the containers anymore.
-    tokio::try_join!(
-        async {
-            postgres
-                .container
-                .stop()
-                .await
-                .context("failed to stop container with Postgres")
-        },
-        async {
-            ipfs.container
-                .stop()
-                .await
-                .context("failed to stop container with IPFS")
-        },
-    )?;
-
-    // print failures
-    for failed_test in test_results
-        .iter()
-        .filter(|t| !t.test_command_result.success)
-    {
-        failed_test.print_failure()
+    Ok(())
+}
+
+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!({
+        "calls": [
+            {
+                "id": "100",
+                "reverted": true,
+                "returnValue": Value::Null,
+            },
+            {
+                "id": "9",
+                "reverted": false,
+                "returnValue": "10",
+            },
+        ],
+    });
+    query_succeeds(
+        "all overloads of the contract function are called",
+        &subgraph,
+        "{ calls(orderBy: id) { id reverted returnValue } }",
+        exp,
+    )
+    .await?;
+
+    Ok(())
+}
+
+async fn test_host_exports(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+    Ok(())
+}
+
+async fn test_non_fatal_errors(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(!subgraph.healthy);
+
+    let query = "query GetSubgraphFeatures($deployment: String!) {
+        subgraphFeatures(subgraphId: $deployment) {
+          specVersion
+          apiVersion
+          features
+          dataSources
+          network
+          handlers
+        }
+      }";
+
+    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",
+      "apiVersion": "0.0.6",
+      "features": ["nonFatalErrors"],
+      "dataSources": ["ethereum/contract"],
+      "handlers": ["block"],
+      "network": "test",
+    });
+    assert_eq!(&exp, subgraph_features);
+
+    let resp = subgraph
+        .query("{ foos(orderBy: id, subgraphError: allow) { id } }")
+        .await?;
+    let exp = json!([ { "message": "indexing_error" }]);
+    assert_eq!(&exp, &resp["errors"]);
+
+    // Importantly, "1" and "11" are not present because their handlers erroed.
+    let exp = json!({
+                "foos": [
+                    { "id": "0" },
+                    { "id": "00" }]});
+    assert_eq!(&exp, &resp["data"]);
+
+    Ok(())
+}
+
+async fn test_overloaded_functions(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    // all overloads of the contract function are called
+    assert!(subgraph.healthy);
+
+    let exp = json!({
+        "calls": [
+            {
+                "id": "bytes32 -> uint256",
+                "value": "256",
+            },
+            {
+                "id": "string -> string",
+                "value": "string -> string",
+            },
+            {
+                "id": "uint256 -> string",
+                "value": "uint256 -> string",
+            },
+        ],
+    });
+    query_succeeds(
+        "all overloads of the contract function are called",
+        &subgraph,
+        "{ calls(orderBy: id) { id value } }",
+        exp,
+    )
+    .await?;
+    Ok(())
+}
+
+pub async fn test_value_roundtrip(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+
+    let exp = json!({
+        "foos": [{ "id": "0", "value": "bla" }],
+        "foos_0": []
+    });
+
+    let query = "{
+        foos_0: foos(orderBy: id, block: { number: 0 }) { id }
+        foos(orderBy: id) { id value }
+      }";
+
+    query_succeeds("test query", &subgraph, query, exp).await?;
+
+    Ok(())
+}
+
+async fn test_remove_then_update(ctx: TestContext) -> anyhow::Result<()> {
+    let subgraph = ctx.subgraph;
+    assert!(subgraph.healthy);
+
+    let exp = json!({
+        "foos": [{ "id": "0", "removed": true, "value": null}]
+    });
+    let query = "{ foos(orderBy: id) { id value removed } }";
+    query_succeeds(
+        "all overloads of the contract function are called",
+        &subgraph,
+        query,
+        exp,
+    )
+    .await?;
+
+    Ok(())
+}
+
+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())
     }
 
-    // print test result summary
-    println!("\nTest results:");
-    for test_result in &test_results {
-        test_result.print_outcome()
+    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);
     }
 
-    if failed {
-        Err(anyhow::anyhow!("Some tests have failed"))
-    } else {
-        Ok(())
+    // 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(())
 }
 
-#[derive(Clone)]
-struct ServiceDependency {
-    container: Arc<ServiceContainer>,
-    ports: Arc<MappedPorts>,
+/// 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
 }
 
-impl ServiceDependency {
-    async fn start(
-        service: ServiceContainerKind,
-        wait_msg: &str,
-        hard_wait: Duration,
-    ) -> anyhow::Result<Self> {
-        let service = ServiceContainer::start(service).await.context(format!(
-            "Failed to start container service `{}`",
-            service.name()
-        ))?;
-
-        service
-            .wait_for_message(wait_msg.as_bytes(), hard_wait)
-            .await
-            .context(format!(
-                "failed to wait for {} container to be ready to accept connections",
-                service.container_name()
-            ))?;
-
-        let ports = service.exposed_ports().await.context(format!(
-            "failed to obtain exposed ports for the `{}` container",
-            service.container_name()
-        ))?;
-
-        Ok(Self {
-            container: Arc::new(service),
-            ports: Arc::new(ports),
+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) {
+          subgraph
+          health
+          entityCount
+          chains {
+            network
+            latestBlock { number hash }
+          } } }"#;
+
+    const FETCH_POI: &str = r#"
+    query proofOfIndexing($subgraph: String!, $blockNumber: Int!, $blockHash: String!) {
+        proofOfIndexing(
+          subgraph: $subgraph,
+          blockNumber: $blockNumber,
+          blockHash: $blockHash
+        ) } "#;
+
+    // Wait up to 5 minutes for the subgraph to write the failure
+    const STATUS_WAIT: Duration = Duration::from_secs(300);
+
+    assert!(!subgraph.healthy);
+
+    struct Status {
+        health: String,
+        entity_count: String,
+        latest_block: Value,
+    }
+
+    async fn fetch_status(subgraph: &Subgraph) -> anyhow::Result<Status> {
+        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());
+        let status = &statuses[0];
+        let health = status["health"].as_str().unwrap();
+        let entity_count = status["entityCount"].as_str().unwrap();
+        let latest_block = &status["chains"][0]["latestBlock"];
+        Ok(Status {
+            health: health.to_string(),
+            entity_count: entity_count.to_string(),
+            latest_block: latest_block.clone(),
         })
     }
-}
 
-/// Prepare and run the integration test
-async fn run_integration_test(
-    test_directory: PathBuf,
-    postgres: ServiceDependency,
-    ipfs: ServiceDependency,
-    graph_node_bin: Arc<PathBuf>,
-    ganache_hard_wait: Duration,
-) -> anyhow::Result<IntegrationTestSummary> {
-    let db_name =
-        format!("{}-{}", basename(&test_directory), uuid::Uuid::new_v4()).replace('-', "_");
-
-    let (ganache, _) = tokio::try_join!(
-        // Start a dedicated Ganache container for this test.
-        async {
-            ServiceDependency::start(
-                ServiceContainerKind::Ganache,
-                "Listening on ",
-                ganache_hard_wait,
-            )
-            .await
-            .context("failed to start Ganache container")
-        },
-        // PostgreSQL is up and running, but we still need to create the database.
-        async {
-            ServiceContainer::create_postgres_database(&postgres.container, &db_name)
-                .await
-                .context("failed to create the test database.")
-        }
-    )?;
-
-    // Build URIs.
-    let postgres_uri = { make_postgres_uri(&db_name, &postgres.ports) };
-    let ipfs_uri = make_ipfs_uri(&ipfs.ports);
-    let (ganache_port, ganache_uri) = make_ganache_uri(&ganache.ports);
-
-    let test_recipe = IntegrationTestRecipe {
-        postgres_uri,
-        ipfs_uri,
-        ganache_uri,
-        ganache_port,
-        graph_node_bin,
-        graph_node_ports: GraphNodePorts::random_free(),
-        test_directory,
+    let start = Instant::now();
+    let status = {
+        let mut status = fetch_status(&subgraph).await?;
+        while status.latest_block.is_null() && start.elapsed() < STATUS_WAIT {
+            sleep(Duration::from_secs(1)).await;
+            status = fetch_status(&subgraph).await?;
+        }
+        status
     };
+    if status.latest_block.is_null() {
+        bail!("Subgraph never wrote the failed block");
+    }
 
-    // Spawn graph-node.
-    let mut graph_node_child_command = run_graph_node(&test_recipe)?;
-
-    println!("Test started: {}", basename(&test_recipe.test_directory));
-    let result = run_test_command(&test_recipe).await?;
-
-    let (graph_node_output, _) = tokio::try_join!(
-        async {
-            // Stop graph-node and read its output.
-            stop_graph_node(&mut graph_node_child_command)
-                .await
-                .context("failed to stop graph-node")
-        },
-        async {
-            // Stop Ganache.
-            ganache
-                .container
-                .stop()
-                .await
-                .context("failed to stop container service for Ganache")
-        }
-    )?;
-
-    Ok(IntegrationTestSummary {
-        test_recipe,
-        test_command_result: result,
-        graph_node_output,
-    })
+    assert_eq!("1", status.entity_count);
+    assert_eq!("failed", status.health);
+
+    let calls = subgraph
+        .query("{ calls(subgraphError: allow)  { id value } }")
+        .await?;
+    // We have indexing errors
+    assert!(calls.get("errors").is_some());
+
+    let calls = &calls["data"]["calls"];
+    assert_eq!(0, calls.as_array().unwrap().len());
+
+    let block_number: u64 = status.latest_block["number"].as_str().unwrap().parse()?;
+    let vars = json!({
+        "subgraph": subgraph.deployment,
+        "blockNumber": block_number,
+        "blockHash": status.latest_block["hash"],
+    });
+    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(())
 }
 
-/// Runs a command for a integration test
-async fn run_test_command(
-    test_recipe: &IntegrationTestRecipe,
-) -> anyhow::Result<IntegrationTestResult> {
-    let output = Command::new("yarn")
-        .arg("test")
-        .env("GANACHE_TEST_PORT", test_recipe.ganache_port.to_string())
-        .env("GRAPH_NODE_ADMIN_URI", test_recipe.graph_node_admin_uri())
-        .env(
-            "GRAPH_NODE_HTTP_PORT",
-            test_recipe.graph_node_ports.http.to_string(),
-        )
-        .env(
-            "GRAPH_NODE_INDEX_PORT",
-            test_recipe.graph_node_ports.index.to_string(),
-        )
-        .env("IPFS_URI", &test_recipe.ipfs_uri)
-        .current_dir(&test_recipe.test_directory)
-        .output()
-        .await
-        .context("failed to run test command")?;
-
-    let test_name = test_recipe.test_name();
-    let stdout_tag = format!("[{}:stdout] ", test_name);
-    let stderr_tag = format!("[{}:stderr] ", test_name);
-
-    Ok(IntegrationTestResult {
-        _exit_status_code: output.status.code(),
-        success: output.status.success(),
-        output: Output {
-            stdout: Some(pretty_output(&output.stdout, &stdout_tag)),
-            stderr: Some(pretty_output(&output.stderr, &stderr_tag)),
-        },
-    })
+#[allow(dead_code)]
+async fn test_missing(_sg: Subgraph) -> anyhow::Result<()> {
+    Err(anyhow!("This test is missing"))
 }
 
-fn run_graph_node(recipe: &IntegrationTestRecipe) -> anyhow::Result<Child> {
-    use std::process::Stdio;
-
-    let mut command = Command::new(recipe.graph_node_bin.as_os_str());
-    command
-        .stdout(Stdio::piped())
-        .stderr(Stdio::piped())
-        .arg("--postgres-url")
-        .arg(&recipe.postgres_uri)
-        .arg("--ethereum-rpc")
-        .arg(&recipe.ganache_uri)
-        .arg("--ipfs")
-        .arg(&recipe.ipfs_uri)
-        .arg("--http-port")
-        .arg(recipe.graph_node_ports.http.to_string())
-        .arg("--index-node-port")
-        .arg(recipe.graph_node_ports.index.to_string())
-        .arg("--ws-port")
-        .arg(recipe.graph_node_ports.ws.to_string())
-        .arg("--admin-port")
-        .arg(recipe.graph_node_ports.admin.to_string())
-        .arg("--metrics-port")
-        .arg(recipe.graph_node_ports.metrics.to_string());
-
-    command
-        .spawn()
-        .context("failed to start graph-node command.")
+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(())
 }
 
-async fn stop_graph_node(child: &mut Child) -> anyhow::Result<Output> {
-    child.kill().await.context("Failed to kill graph-node")?;
+/// 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"]
+            );
+        };
 
-    // capture stdio
-    let stdout = match child.stdout.take() {
-        Some(mut data) => Some(process_stdio(&mut data, "[graph-node:stdout] ").await?),
-        None => None,
+        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")
     };
-    let stderr = match child.stderr.take() {
-        Some(mut data) => Some(process_stdio(&mut data, "[graph-node:stderr] ").await?),
-        None => None,
+
+    // 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")
     };
 
-    Ok(Output { stdout, stderr })
+    // 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 process_stdio<T: AsyncReadExt + Unpin>(
-    stdio: &mut T,
-    prefix: &str,
-) -> anyhow::Result<String> {
-    let mut buffer: Vec<u8> = Vec::new();
-    stdio
-        .read_to_end(&mut buffer)
-        .await
-        .context("failed to read stdio")?;
-    Ok(pretty_output(&buffer, prefix))
+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(())
 }
 
-/// run yarn to build everything
-async fn run_yarn_command(base_directory: &impl AsRef<Path>) {
-    let timer = std::time::Instant::now();
-    println!("Running `yarn` command in integration tests root directory.");
-    let output = Command::new("yarn")
-        .current_dir(base_directory)
-        .output()
+/// The main test entrypoint.
+#[graph::test]
+async fn integration_tests() -> anyhow::Result<()> {
+    let test_name_to_run = std::env::var("TEST_CASE").ok();
+
+    let cases = vec![
+        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),
+        TestCase::new("poi-for-failed-subgraph", test_poi_for_failed_subgraph),
+        TestCase::new("remove-then-update", test_remove_then_update),
+        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
-        .expect("failed to run yarn command");
+        .context("Failed to mine initial blocks for grafting test")?;
+
+    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()
+    );
 
-    if output.status.success() {
-        println!("`yarn` command finished in {}s", timer.elapsed().as_secs());
-        return;
+    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(())
     }
-    println!("Yarn command failed.");
-    println!("{}", pretty_output(&output.stdout, "[yarn:stdout]"));
-    println!("{}", pretty_output(&output.stderr, "[yarn:stderr]"));
-    panic!("Yarn command failed.")
 }
 
-fn parse_numeric_environment_variable(environment_variable_name: &str) -> Option<u64> {
-    std::env::var(environment_variable_name)
-        .ok()
-        .and_then(|x| x.parse().ok())
+pub async fn stop_graph_node(child: &mut Child) -> anyhow::Result<()> {
+    child.kill().await.context("Failed to kill graph-node")?;
+
+    Ok(())
 }
diff --git a/tests/tests/runner_tests.rs b/tests/tests/runner_tests.rs
index 09656faf8f3..1d44657c441 100644
--- a/tests/tests/runner_tests.rs
+++ b/tests/tests/runner_tests.rs
@@ -1,66 +1,81 @@
+use std::collections::HashMap;
 use std::marker::PhantomData;
-use std::process::Command;
-use std::sync::atomic::{self, AtomicBool};
+use std::str::FromStr;
 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::{
-    CheapClone, DeploymentHash, SubgraphAssignmentProvider, SubgraphName, SubgraphStore,
-};
-use graph_tests::fixture::ethereum::{chain, empty_block, genesis, push_test_log};
-use graph_tests::fixture::{
-    self, stores, test_ptr, test_ptr_reorged, MockAdapterSelector, NoopAdapterSelector, Stores,
+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_command, push_test_log,
+    push_test_polling_trigger,
 };
-use graph_tests::helpers::run_cmd;
-use slog::{o, Discard, Logger};
-
-struct RunnerTestRecipe {
-    stores: Stores,
-    subgraph_name: SubgraphName,
-    hash: DeploymentHash,
-}
-
-impl RunnerTestRecipe {
-    async fn new(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("./runner-tests/config.simple.toml"),
-            build_subgraph(&test_dir)
-        );
+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},
+};
 
-        Self {
-            stores,
-            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 = {
+        if err.subgraph_id != expected.subgraph_id
+            || err.block_ptr != expected.block_ptr
+            || err.handler != expected.handler
+            || err.deterministic != expected.deterministic
+        {
+            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.first() == split_expected.first()
         }
+    };
+
+    if !equal {
+        // Will fail
+        let mut err_no_trace = err.clone();
+        err_no_trace.message = expected.message.split("\\twasm backtrace:").collect();
+        assert_eq!(&err_no_trace, expected);
     }
 }
 
-#[tokio::test]
+#[graph::test]
 async fn data_source_revert() -> anyhow::Result<()> {
-    let RunnerTestRecipe {
-        stores,
-        subgraph_name,
-        hash,
-    } = RunnerTestRecipe::new("data-source-revert").await;
+    *TEST_WITH_NO_REORG.lock().unwrap() = true;
+
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("data_source_revert", "data-source-revert").await;
 
     let blocks = {
         let block0 = genesis();
         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));
@@ -69,36 +84,42 @@ async fn data_source_revert() -> anyhow::Result<()> {
         vec![block0, block1, block1_reorged, block2, block3, block4]
     };
 
-    let chain = chain(blocks.clone(), &stores, None).await;
-    let ctx = fixture::setup(subgraph_name.clone(), &hash, &stores, &chain, None, None).await;
+    let chain = chain(&test_info.test_name, blocks.clone(), &stores, None).await;
+
+    let base_ctx = fixture::setup(&test_info, &stores, &chain, None, None).await;
 
     let stop_block = test_ptr(2);
-    ctx.start_and_sync_to(stop_block).await;
-    ctx.provider.stop(ctx.deployment.clone()).await.unwrap();
+    base_ctx.start_and_sync_to(stop_block).await;
+    base_ctx
+        .provider
+        .stop_subgraph(base_ctx.deployment.clone())
+        .await;
 
     // Test loading data sources from DB.
     let stop_block = test_ptr(3);
-    ctx.start_and_sync_to(stop_block).await;
+    base_ctx.start_and_sync_to(stop_block).await;
 
     // Test grafted version
     let subgraph_name = SubgraphName::new("data-source-revert-grafted").unwrap();
-    let hash =
-        build_subgraph_with_yarn_cmd("./runner-tests/data-source-revert", "deploy:test-grafted")
-            .await;
-    let graft_block = Some(test_ptr(3));
-    let ctx = fixture::setup(
-        subgraph_name.clone(),
-        &hash,
-        &stores,
-        &chain,
-        graft_block,
-        None,
+    let hash = build_subgraph_with_pnpm_cmd_and_arg(
+        "./runner-tests/data-source-revert",
+        "deploy:test-grafted",
+        Some(&test_info.hash),
     )
     .await;
+    let test_info = TestInfo {
+        test_dir: test_info.test_dir.clone(),
+        test_name: test_info.test_name.clone(),
+        subgraph_name,
+        hash,
+    };
+
+    let graft_block = Some(test_ptr(3));
+    let grafted_ctx = fixture::setup(&test_info, &stores, &chain, graft_block, None).await;
     let stop_block = test_ptr(4);
-    ctx.start_and_sync_to(stop_block).await;
+    grafted_ctx.start_and_sync_to(stop_block).await;
 
-    let query_res = ctx
+    let query_res = grafted_ctx
         .query(r#"{ dataSourceCount(id: "4") { id, count } }"#)
         .await
         .unwrap();
@@ -111,23 +132,70 @@ async fn data_source_revert() -> anyhow::Result<()> {
         Some(object! { dataSourceCount: object!{ id: "4", count: 4 } })
     );
 
+    // This is an entirely different test, but running it here conveniently avoids race conditions
+    // since it uses the same deployment id.
+    data_source_long_revert().await.unwrap();
+
+    *TEST_WITH_NO_REORG.lock().unwrap() = false;
+
+    Ok(())
+}
+
+async fn data_source_long_revert() -> anyhow::Result<()> {
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("data_source_long_revert", "data-source-revert").await;
+
+    let blocks = {
+        let block0 = genesis();
+        let blocks_1_to_5 = generate_empty_blocks_for_range(block0.ptr(), 1, 5, 0);
+        let blocks_1_to_5_reorged = generate_empty_blocks_for_range(block0.ptr(), 1, 5, 1);
+
+        let mut blocks = vec![block0];
+        blocks.extend(blocks_1_to_5);
+        blocks.extend(blocks_1_to_5_reorged);
+        blocks
+    };
+    let last = blocks.last().unwrap().block.ptr();
+
+    let chain = chain(&test_info.test_name, blocks.clone(), &stores, None).await;
+    let ctx = fixture::setup(&test_info, &stores, &chain, None, None).await;
+
+    // We sync up to block 5 twice, after the first time there is a revert back to block 1.
+    // This tests reverts across more than than a single block.
+    for stop_block in [test_ptr(5), last.clone()] {
+        ctx.start_and_sync_to(stop_block.clone()).await;
+
+        let query_res = ctx
+            .query(r#"{ dataSourceCount(id: "5") { id, count } }"#)
+            .await
+            .unwrap();
+
+        // TODO: The semantically correct value for `count` would be 6. But because the test fixture
+        // uses a `NoopTriggersAdapter` the data sources are not reprocessed in the block in which they
+        // are created.
+        assert_eq!(
+            query_res,
+            Some(object! { dataSourceCount: object!{ id: "5", count: 5 } })
+        );
+    }
+
+    // Restart the subgraph once more, which runs more consistency checks on dynamic data sources.
+    ctx.start_and_sync_to(last).await;
+
     Ok(())
 }
 
-#[tokio::test]
+#[graph::test]
 async fn typename() -> anyhow::Result<()> {
-    let RunnerTestRecipe {
-        stores,
-        subgraph_name,
-        hash,
-    } = RunnerTestRecipe::new("typename").await;
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("typename", "typename").await;
 
     let blocks = {
         let block_0 = genesis();
         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));
@@ -137,21 +205,270 @@ async fn typename() -> anyhow::Result<()> {
 
     let stop_block = blocks.last().unwrap().block.ptr();
 
-    let chain = chain(blocks, &stores, None).await;
-    let ctx = fixture::setup(subgraph_name.clone(), &hash, &stores, &chain, None, None).await;
+    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;
 
     Ok(())
 }
 
-#[tokio::test]
-async fn file_data_sources() {
-    let RunnerTestRecipe {
-        stores,
-        subgraph_name,
-        hash,
-    } = RunnerTestRecipe::new("file-data-sources").await;
+#[graph::test]
+async fn api_version_0_0_7() {
+    let RunnerTestRecipe { stores, test_info } = RunnerTestRecipe::new_with_custom_cmd(
+        "api_version_0_0_7",
+        "api-version",
+        "deploy:test-0-0-7",
+    )
+    .await;
+
+    // Before apiVersion 0.0.8 we allowed setting fields not defined in the schema.
+    // This test tests that it is still possible for lower apiVersion subgraphs
+    // to set fields not defined in the schema.
+
+    let blocks = {
+        let block_0 = genesis();
+        let mut block_1 = empty_block(block_0.ptr(), test_ptr(1));
+        push_test_log(&mut block_1, "0.0.7");
+        vec![block_0, block_1]
+    };
+
+    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;
+
+    let query_res = ctx
+        .query(r#"{ testResults{ id, message } }"#)
+        .await
+        .unwrap();
+
+    assert_json_eq!(
+        query_res,
+        Some(object! {
+            testResults: vec![
+                object! { id: "0.0.7", message: "0.0.7" },
+            ]
+        })
+    );
+}
+
+#[graph::test]
+async fn api_version_0_0_8() {
+    let RunnerTestRecipe { stores, test_info } = RunnerTestRecipe::new_with_custom_cmd(
+        "api_version_0_0_8",
+        "api-version",
+        "deploy:test-0-0-8",
+    )
+    .await;
+
+    // From apiVersion 0.0.8 we disallow setting fields not defined in the schema.
+    // This test tests that it is not possible to set fields not defined in the schema.
+
+    let blocks = {
+        let block_0 = genesis();
+        let mut block_1 = empty_block(block_0.ptr(), test_ptr(1));
+        push_test_log(&mut block_1, "0.0.8");
+        vec![block_0, block_1]
+    };
+
+    let chain = chain(&test_info.test_name, blocks.clone(), &stores, None).await;
+    let ctx = fixture::setup(&test_info, &stores, &chain, None, None).await;
+    let stop_block = blocks.last().unwrap().block.ptr();
+    let err = ctx.start_and_sync_to_error(stop_block.clone()).await;
+    let message = "transaction 0000000000000000000000000000000000000000000000000000000000000000: Attempted to set undefined fields [invalid_field] for the entity type `TestResult`. Make sure those fields are defined in the schema.".to_string();
+    let expected_err = SubgraphError {
+        subgraph_id: ctx.deployment.hash.clone(),
+        message,
+        block_ptr: Some(stop_block),
+        handler: None,
+        deterministic: true,
+    };
+    assert_eq_ignore_backtrace(&err, &expected_err);
+}
+
+#[graph::test]
+async fn derived_loaders() {
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("derived_loaders", "derived-loaders").await;
+
+    let blocks = {
+        let block_0 = genesis();
+        let mut block_1 = empty_block(block_0.ptr(), test_ptr(1));
+        push_test_log(&mut block_1, "1_0");
+        push_test_log(&mut block_1, "1_1");
+        let mut block_2 = empty_block(block_1.ptr(), test_ptr(2));
+        push_test_log(&mut block_2, "2_0");
+        vec![block_0, block_1, block_2]
+    };
+
+    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;
+
+    // This test tests that derived loaders work correctly.
+    // The test fixture has 2 entities, `Bar` and `BBar`, which are derived from `Foo` and `BFoo`.
+    // Where `Foo` and `BFoo` are the same entity, but `BFoo` uses Bytes as the ID type.
+    // This test tests multiple edge cases of derived loaders:
+    // - The derived loader is used in the same handler as the entity is created.
+    // - The derived loader is used in the same block as the entity is created.
+    // - The derived loader is used in a later block than the entity is created.
+    // This is to test the cases where the entities are loaded from the store, `EntityCache.updates` and `EntityCache.handler_updates`
+    // It also tests cases where derived entities are updated and deleted when
+    // in same handler, same block and later block as the entity is created/updated.
+    // For more details on the test cases, see `tests/runner-tests/derived-loaders/src/mapping.ts`
+    // Where the test cases are documented in the code.
+
+    let query_res = ctx
+    .query(r#"{ testResult(id:"1_0", block: { number: 1 } ){ id barDerived{id value value2} bBarDerived{id value value2} } }"#)
+    .await
+    .unwrap();
+
+    assert_json_eq!(
+        query_res,
+        Some(object! {
+            testResult: object! {
+                id: "1_0",
+                barDerived: vec![
+                    object! {
+                        id: "0_1_0",
+                        value: "0",
+                        value2: "0"
+                    },
+                    object! {
+                        id: "1_1_0",
+                        value: "0",
+                        value2: "0"
+                    },
+                    object! {
+                        id: "2_1_0",
+                        value: "0",
+                        value2: "0"
+                    }
+                ],
+                bBarDerived: vec![
+                    object! {
+                        id: "0x305f315f30",
+                        value: "0",
+                        value2: "0"
+                    },
+                    object! {
+                        id: "0x315f315f30",
+                        value: "0",
+                        value2: "0"
+                    },
+                    object! {
+                        id: "0x325f315f30",
+                        value: "0",
+                        value2: "0"
+                    }
+                ]
+            }
+        })
+    );
+
+    let query_res = ctx
+    .query(r#"{ testResult(id:"1_1", block: { number: 1 } ){ id barDerived{id value value2} bBarDerived{id value value2} } }"#)
+    .await
+    .unwrap();
+
+    assert_json_eq!(
+        query_res,
+        Some(object! {
+            testResult: object! {
+                id: "1_1",
+                barDerived: vec![
+                    object! {
+                        id: "0_1_1",
+                        value: "1",
+                        value2: "0"
+                    },
+                    object! {
+                        id: "2_1_1",
+                        value: "0",
+                        value2: "0"
+                    }
+                ],
+                bBarDerived: vec![
+                    object! {
+                        id: "0x305f315f31",
+                        value: "1",
+                        value2: "0"
+                    },
+                    object! {
+                        id: "0x325f315f31",
+                        value: "0",
+                        value2: "0"
+                    }
+                ]
+            }
+        })
+    );
+
+    let query_res = ctx.query(
+    r#"{ testResult(id:"2_0" ){ id barDerived{id value value2} bBarDerived{id value value2} } }"#
+)
+.await
+.unwrap();
+    assert_json_eq!(
+        query_res,
+        Some(object! {
+            testResult: object! {
+                id: "2_0",
+                barDerived: vec![
+                    object! {
+                        id: "0_2_0",
+                        value: "2",
+                        value2: "0"
+                    }
+                ],
+                bBarDerived: vec![
+                    object! {
+                        id: "0x305f325f30",
+                        value: "2",
+                        value2: "0"
+                    }
+                ]
+            }
+        })
+    );
+}
+
+#[graph::test]
+async fn end_block() -> anyhow::Result<()> {
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("end_block", "end-block").await;
+    // This test is to test the end_block feature which enables datasources to stop indexing
+    // At a user specified block, this test tests whether the subgraph stops indexing at that
+    // block, rebuild the filters accurately when a revert occurs etc
+
+    // test if the TriggerFilter includes the given contract address
+    async fn test_filter(
+        ctx: &TestContext,
+        block_ptr: BlockPtr,
+        addr: &Address,
+        should_contain_addr: bool,
+    ) {
+        let runner = ctx.runner(block_ptr.clone()).await;
+        let runner = runner.run_for_test(false).await.unwrap();
+        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));
+        } else {
+            assert!(!addresses.contains(addr));
+        };
+    }
 
     let blocks = {
         let block_0 = genesis();
@@ -159,9 +476,144 @@ async fn file_data_sources() {
         let block_2 = empty_block(block_1.ptr(), test_ptr(2));
         let block_3 = empty_block(block_2.ptr(), test_ptr(3));
         let block_4 = empty_block(block_3.ptr(), test_ptr(4));
+        let block_5 = empty_block(block_4.ptr(), test_ptr(5));
+        let block_6 = empty_block(block_5.ptr(), test_ptr(6));
+        let block_7 = empty_block(block_6.ptr(), test_ptr(7));
+        let block_8 = empty_block(block_7.ptr(), test_ptr(8));
+        let block_9 = empty_block(block_8.ptr(), test_ptr(9));
+        let block_10 = empty_block(block_9.ptr(), test_ptr(10));
+        vec![
+            block_0, block_1, block_2, block_3, block_4, block_5, block_6, block_7, block_8,
+            block_9, block_10,
+        ]
+    };
+
+    let stop_block = blocks.last().unwrap().block.ptr();
+
+    let chain = chain(&test_info.test_name, blocks.clone(), &stores, None).await;
+    let ctx = fixture::setup(&test_info, &stores, &chain, None, None).await;
+
+    let addr = Address::from_str("0x0000000000000000000000000000000000000000").unwrap();
+
+    // Test if the filter includes the contract address before the stop block.
+    test_filter(&ctx, test_ptr(5), &addr, true).await;
+
+    // Test if the filter excludes the contract address after the stop block.
+    test_filter(&ctx, stop_block, &addr, false).await;
+
+    // Query the subgraph to ensure the last indexed block is number 8, indicating the end block feature works.
+    let query_res = ctx
+        .query(r#"{ blocks(first: 1, orderBy: number, orderDirection: desc) { number hash } }"#)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        query_res,
+        Some(
+            object! { blocks: vec![object!{ number: "8", hash:"0x0000000000000000000000000000000000000000000000000000000000000008"  }] }
+        )
+    );
+
+    // Simulate a chain reorg and ensure the filter rebuilds accurately post-reorg.
+    {
+        ctx.rewind(test_ptr(6)).await;
+
+        let mut blocks = blocks[0..8].to_vec().clone();
+
+        // Create new blocks to represent a fork from block 7 onwards, including a reorged block 8.
+        let block_8_1_ptr = test_ptr_reorged(8, 1);
+        let block_8_1 = empty_block(test_ptr(7), block_8_1_ptr.clone());
+        blocks.push(block_8_1);
+        blocks.push(empty_block(block_8_1_ptr, test_ptr(9)));
+
+        let stop_block = blocks.last().unwrap().block.ptr();
+
+        chain.set_block_stream(blocks.clone());
+
+        // Test the filter behavior in the presence of the reorganized chain.
+        test_filter(&ctx, test_ptr(7), &addr, true).await;
+        test_filter(&ctx, stop_block, &addr, false).await;
+
+        // 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
+                }
+            }"#,
+            )
+            .await
+            .unwrap();
+
+        assert_eq!(
+            query_res,
+            Some(object! {
+                blocks: vec![
+                    object!{
+                        number: "8",
+                        hash: "0x0000000100000000000000000000000000000000000000000000000000000008"
+                    }
+                ],
+            })
+        );
+    }
+
+    Ok(())
+}
+
+#[graph::test]
+async fn file_data_sources() {
+    let RunnerTestRecipe { stores, test_info } =
+        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 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, "createFile2");
-        vec![block_0, block_1, block_2, block_3, block_4, block_5]
+        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,
+        ]
     };
 
     // This test assumes the file data sources will be processed in the same block in which they are
@@ -173,140 +625,358 @@ async fn file_data_sources() {
         x: PhantomData,
         triggers_in_block_sleep: Duration::from_millis(150),
     };
-    let chain = chain(blocks.clone(), &stores, Some(Arc::new(adapter_selector))).await;
-    let ctx = fixture::setup(subgraph_name.clone(), &hash, &stores, &chain, None, None).await;
-    ctx.start_and_sync_to(test_ptr(1)).await;
+    let chain = chain(
+        &test_info.test_name,
+        blocks.clone(),
+        &stores,
+        Some(Arc::new(adapter_selector)),
+    )
+    .await;
+    let ctx = fixture::setup(&test_info, &stores, &chain, None, None).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();
+    {
+        ctx.start_and_sync_to(test_ptr(1)).await;
+
+        let content = "EXAMPLE_1";
+        let query_res = ctx
+            .query(&format!(
+                r#"{{ fileEntity(id: "{}") {{ id, content }} }}"#,
+                hash_1.clone()
+            ))
+            .await
+            .unwrap();
 
-    assert_json_eq!(
-        query_res,
-        Some(object! { ipfsFile: object!{ id: id, content: content.clone() } })
-    );
+        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);
 
-    // assert whether duplicate data sources are created.
-    ctx.start_and_sync_to(test_ptr(2)).await;
+        assert_json_eq!(
+            query_res,
+            Some(object! { fileEntity: object!{ id: hash_1.clone(), content: content } })
+        );
+    }
 
-    let store = ctx.store.cheap_clone();
-    let writable = store
-        .writable(ctx.logger.clone(), ctx.deployment.id)
-        .await
-        .unwrap();
-    let datasources = writable.load_dynamic_data_sources(vec![]).await.unwrap();
-    assert!(datasources.len() == 1);
+    // Should not create duplicate datasource
+    {
+        ctx.start_and_sync_to(test_ptr(2)).await;
 
-    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();
+    // 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;
 
-    assert_json_eq!(
-        query_res,
-        Some(object! { ipfsFile1: object!{ id: id , content: content } })
-    );
+        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" } })
+        );
 
-    ctx.start_and_sync_to(test_ptr(4)).await;
-    let writable = ctx
-        .store
-        .clone()
-        .writable(ctx.logger.clone(), ctx.deployment.id)
-        .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 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(5);
-    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`.\twasm backtrace:\t    0: 0x365d - <unknown>!src/mapping/handleFile1\t in handler `handleFile1` at block #5 ()".to_string();
-    let expected_err = SubgraphError {
-        subgraph_id: ctx.deployment.hash.clone(),
-        message,
-        block_ptr: Some(stop_block),
-        handler: None,
-        deterministic: false,
-    };
-    assert_eq!(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(4));
+        ctx.rewind(test_ptr(4)).await;
 
-        // Replace block number 5 with one that contains a different event
         let mut blocks = blocks.clone();
-        blocks.pop();
-        let block_5_1_ptr = test_ptr_reorged(5, 1);
-        let mut block_5_1 = empty_block(test_ptr(4), block_5_1_ptr.clone());
-        push_test_log(&mut block_5_1, "saveConflictingEntity");
-        blocks.push(block_5_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_5_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 5 with one that contains a different event
+        ctx.rewind(test_ptr(4)).await;
+
         let mut blocks = blocks.clone();
-        blocks.pop();
-        let block_5_2_ptr = test_ptr_reorged(5, 2);
-        let mut block_5_2 = empty_block(test_ptr(4), block_5_2_ptr.clone());
-        push_test_log(&mut block_5_2, "createFile1");
-        blocks.push(block_5_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_5_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(4)).await;
+
+        let mut blocks = blocks.clone();
+        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);
+
+        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;
+
+    let blocks = {
+        let block_0 = genesis();
+        let block_1_to_3 = generate_empty_blocks_for_range(block_0.ptr(), 1, 3, 0);
+        let block_4 = {
+            let mut block = empty_block(block_1_to_3.last().unwrap().ptr(), test_ptr(4));
+            push_test_polling_trigger(&mut block);
+            push_test_log(&mut block, "create_template");
+            block
+        };
+        let block_5 = {
+            let mut block = empty_block(block_4.ptr(), test_ptr(5));
+            push_test_polling_trigger(&mut block);
+            block
+        };
+        let block_6 = {
+            let mut block = empty_block(block_5.ptr(), test_ptr(6));
+            push_test_polling_trigger(&mut block);
+            block
+        };
+        let block_7 = {
+            let mut block = empty_block(block_6.ptr(), test_ptr(7));
+            push_test_polling_trigger(&mut block);
+            block
+        };
+        let block_8 = {
+            let mut block = empty_block(block_7.ptr(), test_ptr(8));
+            push_test_polling_trigger(&mut block);
+            block
+        };
+        let block_9 = {
+            let mut block = empty_block(block_8.ptr(), test_ptr(9));
+            push_test_polling_trigger(&mut block);
+            block
+        };
+        let block_10 = {
+            let mut block = empty_block(block_9.ptr(), test_ptr(10));
+            push_test_polling_trigger(&mut block);
+            block
+        };
+
+        // return the blocks
+        vec![block_0]
+            .into_iter()
+            .chain(block_1_to_3)
+            .chain(vec![
+                block_4, block_5, block_6, block_7, block_8, block_9, block_10,
+            ])
+            .collect()
+    };
+
+    let chain = chain(&test_info.test_name, blocks, &stores, None).await;
+
+    let mut env_vars = EnvVars::default();
+    env_vars.experimental_static_filters = true;
+
+    let ctx = fixture::setup(&test_info, &stores, &chain, None, Some(env_vars)).await;
+
+    ctx.start_and_sync_to(test_ptr(10)).await;
+
+    let query = format!(
+        r#"{{ blockFromPollingHandlers(first: {first}) {{ id, hash }} }}"#,
+        first = 3
+    );
+    let query_res = ctx.query(&query).await.unwrap();
+
+    assert_eq!(
+        query_res,
+        Some(object! {
+            blockFromPollingHandlers: vec![
+                object! {
+                    id: test_ptr(0).number.to_string(),
+                    hash:format!("0x{}",test_ptr(0).hash_hex()) ,
+                },
+                object! {
+                id: test_ptr(4).number.to_string(),
+                hash:format!("0x{}",test_ptr(4).hash_hex()) ,
+                },
+                object! {
+                    id: test_ptr(8).number.to_string(),
+                    hash:format!("0x{}",test_ptr(8).hash_hex()) ,
+                },
+            ]
+        })
+    );
+
+    let query = format!(
+        r#"{{ blockFromOtherPollingHandlers(first: {first}, orderBy: number) {{ id, hash }} }}"#,
+        first = 4
+    );
+    let query_res = ctx.query(&query).await.unwrap();
+
+    assert_eq!(
+        query_res,
+        Some(object! {
+            blockFromOtherPollingHandlers: vec![
+                // TODO: The block in which the handler was created is not included
+                // in the result. This is because for runner tests we mock the triggers_adapter
+                // A mock triggers adapter which can be used here is to be implemented
+                // object! {
+                //     id: test_ptr(4).number.to_string(),
+                //     hash:format!("0x{}",test_ptr(10).hash_hex()) ,
+                // },
+                object!{
+                    id: test_ptr(6).number.to_string(),
+                    hash:format!("0x{}",test_ptr(6).hash_hex()) ,
+                },
+                object!{
+                    id: test_ptr(8).number.to_string(),
+                    hash:format!("0x{}",test_ptr(8).hash_hex()) ,
+                },
+                object!{
+                    id: test_ptr(10).number.to_string(),
+                    hash:format!("0x{}",test_ptr(10).hash_hex()) ,
+                },
+            ]
+        })
+    );
+}
+
+#[graph::test]
 async fn template_static_filters_false_positives() {
-    let RunnerTestRecipe {
-        stores,
-        subgraph_name,
-        hash,
-    } = RunnerTestRecipe::new("dynamic-data-source").await;
+    let RunnerTestRecipe { stores, test_info } = RunnerTestRecipe::new(
+        "template_static_filters_false_positives",
+        "dynamic-data-source",
+    )
+    .await;
 
     let blocks = {
         let block_0 = genesis();
@@ -315,20 +985,12 @@ async fn template_static_filters_false_positives() {
         vec![block_0, block_1, block_2]
     };
     let stop_block = test_ptr(1);
-    let chain = chain(blocks, &stores, None).await;
+    let chain = chain(&test_info.test_name, blocks, &stores, None).await;
 
     let mut env_vars = EnvVars::default();
     env_vars.experimental_static_filters = true;
 
-    let ctx = fixture::setup(
-        subgraph_name.clone(),
-        &hash,
-        &stores,
-        &chain,
-        None,
-        Some(env_vars),
-    )
-    .await;
+    let ctx = fixture::setup(&test_info, &stores, &chain, None, Some(env_vars)).await;
     ctx.start_and_sync_to(stop_block).await;
 
     let poi = ctx
@@ -343,28 +1005,50 @@ async fn template_static_filters_false_positives() {
     // POI table. If this fails it's likely that either the bug was re-introduced or there is
     // a change in the POI infrastructure. Or the subgraph id changed.
     assert_eq!(
-        poi.unwrap(),
-        [
-            172, 174, 50, 50, 108, 187, 89, 216, 16, 123, 40, 207, 250, 97, 247, 138, 180, 67, 20,
-            5, 114, 187, 237, 104, 187, 122, 220, 9, 131, 67, 50, 237
-        ],
+        hex::encode(poi.unwrap()),
+        "8e5cfe3f014586cf0f02277c306ac66f11da52b632b937bd74229cce1374d9d5"
+    );
+}
+
+#[graph::test]
+async fn parse_data_source_context() {
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("parse_data_source_context", "data-sources").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));
+        vec![block_0, block_1, block_2]
+    };
+    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;
+
+    let query_res = ctx
+        .query(r#"{ data(id: "0") { id, foo, bar } }"#)
+        .await
+        .unwrap();
+
+    assert_eq!(
+        query_res,
+        Some(object! { data: object!{ id: "0", foo: "test", bar: 1 } })
     );
 }
 
-#[tokio::test]
+#[graph::test]
 async fn retry_create_ds() {
-    let RunnerTestRecipe {
-        stores,
-        subgraph_name,
-        hash,
-    } = RunnerTestRecipe::new("data-source-revert2").await;
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("retry_create_ds", "data-source-revert2").await;
 
     let blocks = {
         let block0 = genesis();
         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));
@@ -389,20 +1073,18 @@ async fn retry_create_ds() {
         triggers_in_block_sleep: Duration::ZERO,
         triggers_in_block,
     });
-    let chain = chain(blocks, &stores, Some(triggers_adapter)).await;
+    let chain = chain(
+        &test_info.test_name,
+        blocks,
+        &stores,
+        Some(triggers_adapter),
+    )
+    .await;
 
     let mut env_vars = EnvVars::default();
     env_vars.subgraph_error_retry_ceil = Duration::from_secs(1);
 
-    let ctx = fixture::setup(
-        subgraph_name.clone(),
-        &hash,
-        &stores,
-        &chain,
-        None,
-        Some(env_vars),
-    )
-    .await;
+    let ctx = fixture::setup(&test_info, &stores, &chain, None, Some(env_vars)).await;
 
     let runner = ctx
         .runner(stop_block)
@@ -410,16 +1092,13 @@ async fn retry_create_ds() {
         .run_for_test(true)
         .await
         .unwrap();
-    assert_eq!(runner.context().instance().hosts().len(), 2);
+    assert_eq!(runner.context().hosts_len(), 2);
 }
 
-#[tokio::test]
+#[graph::test]
 async fn fatal_error() -> anyhow::Result<()> {
-    let RunnerTestRecipe {
-        stores,
-        subgraph_name,
-        hash,
-    } = RunnerTestRecipe::new("fatal-error").await;
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("fatal_error", "fatal-error").await;
 
     let blocks = {
         let block_0 = genesis();
@@ -431,8 +1110,8 @@ async fn fatal_error() -> anyhow::Result<()> {
 
     let stop_block = blocks.last().unwrap().block.ptr();
 
-    let chain = chain(blocks, &stores, None).await;
-    let ctx = fixture::setup(subgraph_name.clone(), &hash, &stores, &chain, None, None).await;
+    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_error(stop_block).await;
 
@@ -444,8 +1123,36 @@ async fn fatal_error() -> anyhow::Result<()> {
     assert!(err.block.number == 3.into());
     assert!(err.deterministic);
 
+    let sg_store = stores.network_store.subgraph_store();
+
+    let poi2 = sg_store
+        .get_proof_of_indexing(&test_info.hash, &None, test_ptr(2))
+        .await
+        .unwrap();
+
+    // All POIs past this point should be the same
+    let poi3 = sg_store
+        .get_proof_of_indexing(&test_info.hash, &None, test_ptr(3))
+        .await
+        .unwrap();
+    assert!(poi2 != poi3);
+
+    let poi4 = sg_store
+        .get_proof_of_indexing(&test_info.hash, &None, test_ptr(4))
+        .await
+        .unwrap();
+    assert_eq!(poi3, poi4);
+    assert!(poi2 != poi4);
+
+    let poi100 = sg_store
+        .get_proof_of_indexing(&test_info.hash, &None, test_ptr(100))
+        .await
+        .unwrap();
+    assert_eq!(poi4, poi100);
+    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());
@@ -453,48 +1160,335 @@ async fn fatal_error() -> anyhow::Result<()> {
     Ok(())
 }
 
-async fn build_subgraph(dir: &str) -> DeploymentHash {
-    build_subgraph_with_yarn_cmd(dir, "deploy:test").await
+#[graph::test]
+async fn arweave_file_data_sources() {
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("arweave_file_data_sources", "arweave-file-data-sources").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));
+        vec![block_0, block_1, block_2]
+    };
+
+    // HASH used in the mappings.
+    let id = "8APeQ5lW0-csTcBaGdPBDLAL2ci2AT9pTn2tppGPU_8";
+
+    // 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,
+        &chain,
+        None,
+        None,
+        arweave_resolver,
+    )
+    .await;
+    ctx.start_and_sync_to(test_ptr(2)).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_eq!(datasources.len(), 1);
+    let ds = datasources.first().unwrap();
+    assert_ne!(ds.causality_region, CausalityRegion::ONCHAIN);
+    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).unwrap();
+    let query_res = ctx
+        .query(&format!(r#"{{ file(id: "{id}") {{ id, content }} }}"#,))
+        .await
+        .unwrap();
+
+    assert_json_eq!(
+        query_res,
+        Some(object! { file: object!{ id: id, content: content.clone() } })
+    );
 }
 
-async fn build_subgraph_with_yarn_cmd(dir: &str, yarn_cmd: &str) -> DeploymentHash {
-    // Test that IPFS is up.
-    IpfsClient::localhost()
-        .test()
+#[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,
+            ))],
+        }
+    }
+
+    // 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;
+
+    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" },
+            ]
+        })
+    );
 
-    // Make sure dependencies are present.
+    // 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();
 
-    run_cmd(
-        Command::new("yarn")
-            .arg("install")
-            .arg("--mutex")
-            .arg("file:.yarn-mutex")
-            .current_dir("./runner-tests/"),
+    assert_eq!(
+        query_res,
+        Some(object! {
+            stats_collection: vec![
+                object! { token: object! { id: "0xaa" }, sum: "40" },
+                object! { token: object! { id: "0xbb" }, sum: "60" },
+            ]
+        })
     );
 
-    // Run codegen.
-    run_cmd(Command::new("yarn").arg("codegen").current_dir(dir));
-
-    // 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")
-            .arg(yarn_cmd)
-            .env("IPFS_URI", "http://127.0.0.1:5001")
-            .env("GRAPH_NODE_ADMIN_URI", "http://localhost:0")
-            .current_dir(dir),
+    // 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();
+
+    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" },
+                    ]
+                },
+            ]
+        })
     );
+}
 
-    // Hack to extract deployment id from `graph deploy` output.
-    const ID_PREFIX: &str = "Build completed: ";
-    let mut line = deploy_output
-        .lines()
-        .find(|line| line.contains(ID_PREFIX))
-        .expect("found no matching line");
-    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()
+#[graph::test]
+async fn skip_duplicates() {
+    let RunnerTestRecipe { stores, test_info } =
+        RunnerTestRecipe::new("skip_duplicates", "skip-duplicates").await;
+
+    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 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;
+
+    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" }
+        })
+    );
+}
+
+/// 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]
+    };
+
+    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(())
 }