Add eth.blob_hashes table (#8 )

Adds `eth.blob_hashes`, indexed by blob transaction hash. Currently based on #7 Reviewed-on: #8
Update schema.sql
2024-08-01 00:21:06 +00:00 · 2024-07-24 07:13:22 +00:00 · 2024-07-24 07:13:22 +00:00 · 2024-07-24 07:13:22 +00:00 · 2024-07-24 07:13:22 +00:00 · 2024-07-24 07:05:47 +00:00
45 changed files with 1557 additions and 1726 deletions
--- a/.gitea/workflows/on-pr.yaml
+++ b/.gitea/workflows/on-pr.yaml
@ -0,0 +1,23 @@
 name: Basic test
 on: [pull_request]
 jobs:
  basic-test:
    name: Build and sanity check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Build Docker images
        run: docker compose build
      - name: Run Docker containers
        run: docker compose up -d
      - name: Check migration version
        timeout-minutes: 1
        run: |
          MIGRATION_VERSION=$(ls db/migrations/*.sql | wc -l)
          while
            version=$(docker compose run --rm migrations version 2>&1 | tail -1 | awk '{print $(NF)}')
            [[ $version != $MIGRATION_VERSION ]]; do
            echo "Incorrect version: $version"
            echo "Retrying..."
          done
--- a/.gitea/workflows/publish.yaml
+++ b/.gitea/workflows/publish.yaml
@ -0,0 +1,26 @@
 name: Publish Docker image
 on:
  release:
    types: [published, edited]
 jobs:
  build:
    name: Build and publish image
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - id: vars
        name: Output SHA and version tag
        run: |
          echo "sha=${GITHUB_SHA:0:7}" >> $GITHUB_OUTPUT
          echo "tag=${GITHUB_REF#refs/tags/}" >> $GITHUB_OUTPUT
      - name: Build and tag image
        run: |
          docker build . \
          -t cerc-io/ipld-eth-db \
          -t git.vdb.to/cerc-io/ipld-eth-db/ipld-eth-db:${{steps.vars.outputs.sha}} \
          -t git.vdb.to/cerc-io/ipld-eth-db/ipld-eth-db:${{steps.vars.outputs.tag}}
      - name: Push image tags
        run: |
          echo ${{ secrets.CICD_PUBLISH_TOKEN }} | docker login https://git.vdb.to -u cerccicd --password-stdin
          docker push git.vdb.to/cerc-io/ipld-eth-db/ipld-eth-db:${{steps.vars.outputs.sha}}
          docker push git.vdb.to/cerc-io/ipld-eth-db/ipld-eth-db:${{steps.vars.outputs.tag}}
--- a/.github/workflows/on-main.yaml
+++ b/.github/workflows/on-main.yaml
@ -1,25 +0,0 @@
 name: Docker Compose Build
 on:
  push:
    branches:
      - main
 jobs:
  build:
    name: Run docker build
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Get the version
        id: vars
        run: echo ::set-output name=sha::$(echo ${GITHUB_SHA:0:7})
      - name: Run docker build
        run: make docker-build
      - name: Tag docker image
        run: docker tag vulcanize/ipld-eth-db docker.pkg.github.com/vulcanize/ipld-eth-db/ipld-eth-db:${{steps.vars.outputs.sha}}
      - name: Docker Login
        run: echo ${{ secrets.GITHUB_TOKEN }} | docker login https://docker.pkg.github.com -u vulcanize --password-stdin
      - name: Docker Push
        run: docker push docker.pkg.github.com/vulcanize/ipld-eth-db/ipld-eth-db:${{steps.vars.outputs.sha}}
--- a/.github/workflows/on-pr.yaml
+++ b/.github/workflows/on-pr.yaml
@ -1,63 +0,0 @@
 name: Docker Build
 on: [pull_request]
 jobs:
  concise_migration_diff:
    name: Verify concise migration and generated schema
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run docker concise migration build
        run: make docker-concise-migration-build
      - name: Run database
        run: docker-compose -f docker-compose.test.yml up -d test-db
      - name: Test concise migration
        run: |
          sleep 10
          docker run --rm --network host -e DATABASE_USER=vdbm -e DATABASE_PASSWORD=password \
          -e DATABASE_HOSTNAME=127.0.0.1 -e DATABASE_PORT=8066 -e DATABASE_NAME=vulcanize_testing \
          vulcanize/concise-migration-build
      - name: Verify schema is latest
        run: |
          PGPASSWORD="password" pg_dump -h localhost -p 8066 -U vdbm vulcanize_testing --no-owner --schema-only > ./db/migration_schema.sql
          ./scripts/check_diff.sh ./db/migration_schema.sql db/schema.sql
  incremental_migration_diff:
    name: Compare conscise migration schema with incremental migration.
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Run database
        run: docker-compose -f docker-compose.test.yml up -d test-db statediff-migrations
      - name: Test incremental migration
        run: |
          sleep 10
          docker run --rm --network host -e DATABASE_USER=vdbm -e DATABASE_PASSWORD=password \
          -e DATABASE_HOSTNAME=127.0.0.1 -e DATABASE_PORT=8066 -e DATABASE_NAME=vulcanize_testing \
          vulcanize/statediff-migrations:v0.9.0
      - name: Verify schema is latest
        run: |
          PGPASSWORD="password" pg_dump -h localhost -p 8066 -U vdbm vulcanize_testing --no-owner --schema-only > ./db/migration_schema.sql
          ./scripts/check_diff.sh db/schema.sql ./db/migration_schema.sql
  migration:
    name: Compare up and down migration
    env:
      GOPATH: /tmp/go
    strategy:
      matrix:
        go-version: [ 1.16.x ]
        os: [ ubuntu-latest ]
    runs-on: ${{ matrix.os }}
    steps:
      - name: Create GOPATH
        run: mkdir -p /tmp/go
      - name: Install Go
        uses: actions/setup-go@v2
        with:
          go-version: ${{ matrix.go-version }}
      - uses: actions/checkout@v2
      - name: Test migration
        run: |
          timeout 5m make test-migrations
--- a/.github/workflows/publish.yaml
+++ b/.github/workflows/publish.yaml
@ -1,24 +0,0 @@
 name: Publish Docker image
 on:
  release:
    types: [published]
 jobs:
  push_to_registries:
    name: Push Docker image to Docker Hub
    runs-on: ubuntu-latest
    steps:
      - name: Get the version
        id: vars
        run: |
          echo ::set-output name=sha::$(echo ${GITHUB_SHA:0:7})
          echo ::set-output name=tag::$(echo ${GITHUB_REF#refs/tags/})
      - name: Docker Login to Github Registry
        run: echo ${{ secrets.GITHUB_TOKEN }} | docker login https://docker.pkg.github.com -u vulcanize --password-stdin
      - name: Docker Pull
        run: docker pull docker.pkg.github.com/vulcanize/ipld-eth-db/ipld-eth-db:${{steps.vars.outputs.sha}}
      - name: Docker Login to Docker Registry
        run: echo ${{ secrets.VULCANIZEJENKINS_PAT }} | docker login -u vulcanizejenkins --password-stdin
      - name: Tag docker image
        run: docker tag docker.pkg.github.com/vulcanize/ipld-eth-db/ipld-eth-db:${{steps.vars.outputs.sha}} vulcanize/ipld-eth-db:${{steps.vars.outputs.tag}}
      - name: Docker Push to Docker Hub
        run: docker push vulcanize/ipld-eth-db:${{steps.vars.outputs.tag}}
--- a/.gitignore
+++ b/.gitignore
@ -1 +1,2 @@
-.idea/
+.idea/
 .vscode
--- a/20
+++ b/20
@ -1,3 +1,19 @@
-FROM postgres:12-alpine
+FROM alpine as builder
-COPY ./schema.sql /docker-entrypoint-initdb.d/init.sql
+# Get migration tool
 WORKDIR /
 ARG GOOSE_VERSION="v3.6.1"
 RUN arch=$(arch | sed s/aarch64/arm64/) && \
  wget -O ./goose https://github.com/pressly/goose/releases/download/${GOOSE_VERSION}/goose_linux_${arch}
 RUN chmod +x ./goose
 # app container
 FROM alpine
 WORKDIR /app
 COPY --from=builder /goose goose
 ADD scripts/startup_script.sh .
 ADD db/migrations migrations
 ENTRYPOINT ["/app/startup_script.sh"]
--- a/94
+++ b/94
@ -1,94 +0,0 @@
 BIN = $(GOPATH)/bin
 # Tools
 ## Migration tool
 GOOSE = $(BIN)/goose
 $(BIN)/goose:
 	go get -u github.com/pressly/goose/cmd/goose
 .PHONY: installtools
 installtools: | $(GOOSE)
 	echo "Installing tools"
 #Database
 HOST_NAME = localhost
 PORT = 5432
 NAME =
 USER = postgres
 PASSWORD = password
 CONNECT_STRING=postgresql://$(USER):$(PASSWORD)@$(HOST_NAME):$(PORT)/$(NAME)?sslmode=disable
 # Parameter checks
 ## Check that DB variables are provided
 .PHONY: checkdbvars
 checkdbvars:
 	test -n "$(HOST_NAME)" # $$HOST_NAME
 	test -n "$(PORT)" # $$PORT
 	test -n "$(NAME)" # $$NAME
 	@echo $(CONNECT_STRING)
 ## Check that the migration variable (id/timestamp) is provided
 .PHONY: checkmigration
 checkmigration:
 	test -n "$(MIGRATION)" # $$MIGRATION
 # Check that the migration name is provided
 .PHONY: checkmigname
 checkmigname:
 	test -n "$(NAME)" # $$NAME
 # Migration operations
 ## Rollback the last migration
 .PHONY: rollback
 rollback: $(GOOSE) checkdbvars
 	$(GOOSE) -dir db/migrations postgres "$(CONNECT_STRING)" down
 	pg_dump -O -s $(CONNECT_STRING) > schema.sql
 ## Rollback to a select migration (id/timestamp)
 .PHONY: rollback_to
 rollback_to: $(GOOSE) checkmigration checkdbvars
 	$(GOOSE) -dir db/migrations postgres "$(CONNECT_STRING)" down-to "$(MIGRATION)"
 ## Apply all migrations not already run
 .PHONY: migrate
 migrate: $(GOOSE) checkdbvars
 	$(GOOSE) -dir db/migrations postgres "$(CONNECT_STRING)" up
 	pg_dump -O -s $(CONNECT_STRING) > schema.sql
 ## Create a new migration file
 .PHONY: new_migration
 new_migration: $(GOOSE) checkmigname
 	$(GOOSE) -dir db/migrations create $(NAME) sql
 ## Check which migrations are applied at the moment
 .PHONY: migration_status
 migration_status: $(GOOSE) checkdbvars
 	$(GOOSE) -dir db/migrations postgres "$(CONNECT_STRING)" status
 # Convert timestamped migrations to versioned (to be run in CI);
 # merge timestamped files to prevent conflict
 .PHONY: version_migrations
 version_migrations:
 	$(GOOSE) -dir db/migrations fix
 # Import a psql schema to the database
 .PHONY: import
 import:
 	test -n "$(NAME)" # $$NAME
 	psql $(NAME) < schema.sql
 ## Build docker image with schema
 .PHONY: docker-build
 docker-build:
 	docker-compose build
 ## Build docker image for migration
 .PHONY: docker-concise-migration-build
 docker-concise-migration-build:
 	docker build -t vulcanize/concise-migration-build -f ./db/Dockerfile .
 .PHONY: test-migrations
 test-migrations: $(GOOSE)
 	./scripts/test_migration.sh
--- a/README.md
+++ b/README.md
@ -2,4 +2,262 @@
 Schemas and utils for IPLD ETH Postgres database
 ## Database UML
-![](vulcanize_db.png)
+![](vulcanize_db.png)
 ## Run
 * Remove any existing containers / volumes:
  ```bash
  docker-compose down -v --remove-orphans
  ```
 * Spin up `ipld-eth-db` using an existing image:
  * Update image source used for running the migrations in [docker-compose.yml](./docker-compose.yml) (if required).
  * Run:
    ```
    docker-compose -f docker-compose.yml up
    ```
 * Spin up `ipld-eth-db` using a locally built image:
  * Update [Dockerfile](./Dockerfile) (if required).
  * Update build context used for running the migrations in [docker-compose.test.yml](./docker-compose.test.yml) (if required).
  * Run:
    ```
    docker-compose -f docker-compose.test.yml up --build
    ```
 ## Example queries
 Note that searching by block_number in addition to block_hash is optional in the below queries where both are provided,
 but since the tables are partitioned by block_number doing so will improve query performance by informing the query
 planner which partition it needs to search.
 ### Headers
 Retrieve header RLP (IPLD block) and CID for a given block hash
 ```sql
 SELECT header_cids.cid,
       blocks.data
 FROM ipld.blocks,
     eth.header_cids
 WHERE header_cids.block_hash = {block_hash}
    AND header_cids.block_number = {block_number}
 	AND header_cids.canonical
 	AND blocks.key = header_cids.cid
 	AND blocks.block_number = header_cids.block_number
 LIMIT 1
 ```
 ###  Uncles
 Retrieve the uncle list RLP (IPLD block) and CID for a given block hash
 ```sql
 SELECT uncle_cids.cid,
       blocks.data
 FROM eth.uncle_cids
 INNER JOIN eth.header_cids ON (
    uncle_cids.header_id = header_cids.block_hash
    AND uncle_cids.block_number = header_cids.block_number)
 INNER JOIN ipld.blocks ON (
    uncle_cids.cid = blocks.key
    AND uncle_cids.block_number = blocks.block_number)
 WHERE header_cids.block_hash = {block_hash}
    AND header_cids.block_number = {block_number}
 ORDER BY uncle_cids.parent_hash
 LIMIT 1
 ```
 ### Transactions
 Retrieve an ordered list of all the RLP encoded transactions (IPLD blocks) and their CIDs for a given block hash
 ```sql
 SELECT transaction_cids.cid,
       blocks.data
 FROM eth.transaction_cids,
     eth.header_cids,
     ipld.blocks
 WHERE header_cids.block_hash = {block_hash}
    AND header_cids.block_number = {block_number}
 	AND header_cids.canonical
 	AND transaction_cids.block_number = header_cids.block_number
 	AND transaction_cids.header_id = header_cids.block_hash
 	AND blocks.block_number = header_cids.block_number
 	AND blocks.key = transaction_cids.cid
 ORDER BY eth.transaction_cids.index ASC
 ```
 Retrieve an RLP encoded transaction (IPLD block), the block hash and block number for the block it belongs to, and its position in the transaction
 for that block for a provided transaction hash
 ```sql
 SELECT blocks.data,
       transaction_cids.header_id,
       transaction_cids.block_number,
       transaction_cids.index
 FROM eth.transaction_cids,
     ipld.blocks,
     eth.header_cids
 WHERE transaction_cids.tx_hash = {transaction_hash}
 	AND header_cids.block_hash = transaction_cids.header_id
 	AND header_cids.block_number = transaction_cids.block_number
 	AND header_cids.canonical
    AND blocks.key = transaction_cids.cid
 	AND blocks.block_number = transaction_cids.block_number
 ```
 ### Receipts
 Retrieve an ordered list of all the RLP encoded receipts (IPLD blocks), their CIDs, and their corresponding transaction
 hashes for a given block hash
 ```sql
 SELECT receipt_cids.cid,
       blocks.data,
       eth.transaction_cids.tx_hash
 FROM eth.receipt_cids,
     eth.transaction_cids,
     eth.header_cids,
     ipld.blocks
 WHERE header_cids.block_hash = {block_hash}
    AND header_cids.block_number = {block_number}
 	AND header_cids.canonical
 	AND receipt_cids.block_number = header_cids.block_number
 	AND receipt_cids.header_id = header_cids.block_hash
 	AND receipt_cids.TX_ID = transaction_cids.TX_HASH
 	AND transaction_cids.block_number = header_cids.block_number
 	AND transaction_cids.header_id = header_cids.block_hash
 	AND blocks.block_number = header_cids.block_number
 	AND blocks.key = receipt_cids.cid
 ORDER BY eth.transaction_cids.index ASC
 ```
 Retrieve the RLP encoded receipt (IPLD) and CID corresponding to a provided transaction hash
 ```sql
 SELECT receipt_cids.cid,
       blocks.data
 FROM eth.receipt_cids
 INNER JOIN eth.transaction_cids ON (
    receipt_cids.tx_id = transaction_cids.tx_hash
    AND receipt_cids.block_number = transaction_cids.block_number)
 INNER JOIN ipld.blocks ON (
    receipt_cids.cid = blocks.key
    AND receipt_cids.block_number = blocks.block_number)
 WHERE transaction_cids.tx_hash = {transaction_hash}
 ```
 ### Logs 
 Retrieve all the logs and their associated transaction hashes at a given block with that were emitted from
 any of the provided contract addresses and which match on any of the provided topics
 ```sql
 SELECT blocks.data,
       eth.transaction_cids.tx_hash
 FROM eth.log_cids
 INNER JOIN eth.transaction_cids ON (
    log_cids.rct_id = transaction_cids.tx_hash
    AND log_cids.header_id = transaction_cids.header_id
    AND log_cids.block_number = transaction_cids.block_number)
 INNER JOIN ipld.blocks ON (
    log_cids.cid = blocks.key
    AND log_cids.block_number = blocks.block_number)
 WHERE log_cids.header_id = {block_hash}
    AND log_cids.block_number = {block_number}
    AND eth.log_cids.address = ANY ({list,of,addresses})
    AND eth.log_cids.topic0 = ANY ({list,of,topic0s})
    AND eth.log_cids.topic1 = ANY ({list,of,topic1s})
    AND eth.log_cids.topic2 = ANY ({list,of,topic2s})
    AND eth.log_cids.topic3 = ANY ({list,of,topic3s})
 ORDER BY eth.transaction_cids.index, eth.log_cids.index
 ```
 Retrieve all the logs and their associated transaction hashes within a provided block range that were emitted from
 any of the provided contract addresses and which match on any of the provided topics
 ```sql
 SELECT blocks.data,
       eth.transaction_cids.tx_hash
 FROM eth.log_cids
 INNER JOIN eth.transaction_cids ON (
    log_cids.rct_id = transaction_cids.tx_hash
    AND log_cids.header_id = transaction_cids.header_id
    AND log_cids.block_number = transaction_cids.block_number)
 INNER JOIN eth.header_cids ON (
    transaction_cids.header_id = header_cids.block_hash
    AND transaction_cids.block_number = header_cids.block_number)
 INNER JOIN ipld.blocks ON (
    log_cids.cid = blocks.key
    AND log_cids.block_number = blocks.block_number)
 WHERE eth.header_cids.block_number >= {range_start} AND eth.header_cids.block_number <= {range_stop}
    AND eth.header_cids.canonical
    AND eth.log_cids.address = ANY ({list,of,addresses})
    AND eth.log_cids.topic0 = ANY ({list,of,topic0s})
    AND eth.log_cids.topic1 = ANY ({list,of,topic1s})
    AND eth.log_cids.topic2 = ANY ({list,of,topic2s})
    AND eth.log_cids.topic3 = ANY ({list,of,topic3s})
 ORDER BY eth.header_cids.block_number, eth.transaction_cids.index, eth.log_cids.index
 ```
 ### State and storage
 Retrieve the state account for a given address hash at a provided block hash. If `state_cids.removed == true` then
 the account is empty.
 ```sql
 SELECT state_cids.nonce,
       state_cids.balance,
       state_cids.storage_root,
       state_cids.code_hash,
       state_cids.removed
 FROM eth.state_cids,
     eth.header_cids
 WHERE state_cids.state_leaf_key = {address_hash}
 	AND state_cids.block_number <=
 		(SELECT block_number
 			FROM eth.header_cids
 			WHERE block_hash = {block_hash}
 			LIMIT 1)
 	AND header_cids.canonical
 	AND state_cids.header_id = header_cids.block_hash
 	AND state_cids.block_number = header_cids.block_number
 ORDER BY state_cids.block_number DESC
 LIMIT 1
 ```
 Retrieve a storage value, as well as the RLP encoded leaf node that stores it, for a given contract address hash and
 storage leaf key (storage slot hash) at a provided block hash. If `state_leaf_removed == true`
 or `storage_cids.removed == true` then the slot is empty
 ```sql
 SELECT storage_cids.cid,
       storage_cids.val,
       storage_cids.block_number,
       storage_cids.removed,
       was_state_leaf_removed_by_number(storage_cids.state_leaf_key, storage_cids.block_number) AS state_leaf_removed,
       blocks.data
 FROM eth.storage_cids,
     eth.header_cids,
     ipld.blocks
 WHERE header_cids.block_number <= (SELECT block_number from eth.header_cids where block_hash = $3 LIMIT 1)
    AND header_cids.canonical
    AND storage_cids.block_number = header_cids.block_number
    AND storage_cids.header_id = header_cids.block_hash
    AND storage_cids.storage_leaf_key = {storage_slot_hash}
    AND storage_cids.state_leaf_key = {contract_address_hash}
    AND blocks.key = storage_cids.cid
    AND blocks.block_number = storage_cids.block_number
 ORDER BY storage_cids.block_number DESC LIMIT 1
 ```
--- a/compose.yml
+++ b/compose.yml
@ -0,0 +1,34 @@
 services:
  migrations:
    restart: on-failure
    depends_on:
      ipld-eth-db:
        condition: service_healthy
    # Use local build
    build:
      context: .
      dockerfile: Dockerfile
    # Use an existing image
    image: cerc/ipld-eth-db:local
    environment:
      DATABASE_USER: "vdbm"
      DATABASE_NAME: "cerc_testing"
      DATABASE_PASSWORD: "password"
      DATABASE_HOSTNAME: "ipld-eth-db"
      DATABASE_PORT: 5432
  ipld-eth-db:
    image: timescale/timescaledb:latest-pg14
    restart: always
    command: ["postgres", "-c", "log_statement=all"]
    environment:
      POSTGRES_USER: "vdbm"
      POSTGRES_DB: "cerc_testing"
      POSTGRES_PASSWORD: "password"
    ports:
      - "127.0.0.1:8077:5432"
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "vdbm"]
      interval: 2s
      timeout: 1s
      retries: 3
--- a/db/Dockerfile
+++ b/db/Dockerfile
@ -1,23 +0,0 @@
 FROM golang:1.16-alpine as builder
 RUN apk --update --no-cache add make git g++ linux-headers
 ADD . /go/src/github.com/vulcanize/ipld-eth-db
 # Build migration tool
 WORKDIR /go/src/github.com/pressly
 RUN git clone https://github.com/pressly/goose.git
 WORKDIR /go/src/github.com/pressly/goose/cmd/goose
 RUN GCO_ENABLED=0 GOOS=linux go build -a -installsuffix cgo -ldflags '-extldflags "-static"' -tags='no_mysql no_sqlite' -o goose .
 # app container
 FROM alpine
 WORKDIR /app
 COPY --from=builder /go/src/github.com/vulcanize/ipld-eth-db/scripts/startup_script.sh .
 COPY --from=builder /go/src/github.com/pressly/goose/cmd/goose/goose goose
 COPY --from=builder /go/src/github.com/vulcanize/ipld-eth-db/db/migrations migrations/vulcanizedb
 ENTRYPOINT ["/app/startup_script.sh"]
--- a/db/migrations/00001_create_ipfs_blocks_table.sql
+++ b/db/migrations/00001_create_ipfs_blocks_table.sql
@ -1,8 +1,13 @@
 -- +goose Up
-CREATE TABLE IF NOT EXISTS public.blocks (
+CREATE SCHEMA ipld;
-  key TEXT UNIQUE NOT NULL,
+
-  data BYTEA NOT NULL
+CREATE TABLE IF NOT EXISTS ipld.blocks (
    block_number BIGINT NOT NULL,
    key TEXT NOT NULL,
    data BYTEA NOT NULL,
    PRIMARY KEY (key, block_number)
 );
 -- +goose Down
-DROP TABLE public.blocks;
+DROP TABLE ipld.blocks;
 DROP SCHEMA ipld;
--- a/db/migrations/00002_create_nodes_table.sql
+++ b/db/migrations/00002_create_nodes_table.sql
@ -1,12 +1,10 @@
 -- +goose Up
-CREATE TABLE nodes (
+CREATE TABLE IF NOT EXISTS nodes (
-  id            SERIAL PRIMARY KEY,
+    genesis_block VARCHAR(66),
-  client_name   VARCHAR,
+    network_id    VARCHAR,
-  genesis_block VARCHAR(66),
+    node_id       VARCHAR(128) PRIMARY KEY,
-  network_id    VARCHAR,
+    client_name   VARCHAR,
-  node_id       VARCHAR(128),
+    chain_id      INTEGER DEFAULT 1
  chain_id      INTEGER DEFAULT 1,
  CONSTRAINT node_uc UNIQUE (genesis_block, network_id, node_id, chain_id)
 );
 -- +goose Down
--- a/db/migrations/00004_create_eth_header_cids_table.sql
+++ b/db/migrations/00004_create_eth_header_cids_table.sql
@ -1,24 +1,23 @@
 -- +goose Up
-CREATE TABLE eth.header_cids (
+CREATE TABLE IF NOT EXISTS eth.header_cids (
-  id                    SERIAL PRIMARY KEY,
+    block_number          BIGINT NOT NULL,
-  block_number          BIGINT NOT NULL,
+    block_hash            VARCHAR(66) NOT NULL,
-  block_hash            VARCHAR(66) NOT NULL,
+    parent_hash           VARCHAR(66) NOT NULL,
-  parent_hash           VARCHAR(66) NOT NULL,
+    cid                   TEXT NOT NULL,
-  cid                   TEXT NOT NULL,
+    td                    NUMERIC NOT NULL,
-  mh_key                TEXT NOT NULL REFERENCES public.blocks (key) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    node_ids              VARCHAR(128)[] NOT NULL,
-  td                    NUMERIC NOT NULL,
+    reward                NUMERIC NOT NULL,
-  node_id               INTEGER NOT NULL REFERENCES nodes (id) ON DELETE CASCADE,
+    state_root            VARCHAR(66) NOT NULL,
-  reward                NUMERIC NOT NULL,
+    tx_root               VARCHAR(66) NOT NULL,
-  state_root            VARCHAR(66) NOT NULL,
+    receipt_root          VARCHAR(66) NOT NULL,
-  tx_root               VARCHAR(66) NOT NULL,
+    uncles_hash           VARCHAR(66) NOT NULL,
-  receipt_root          VARCHAR(66) NOT NULL,
+    bloom                 BYTEA NOT NULL,
-  uncle_root            VARCHAR(66) NOT NULL,
+    timestamp             BIGINT NOT NULL,
-  bloom                 BYTEA NOT NULL,
+    coinbase              VARCHAR(66) NOT NULL,
-  timestamp             NUMERIC NOT NULL,
+    canonical             BOOLEAN NOT NULL DEFAULT TRUE,
-  times_validated       INTEGER NOT NULL DEFAULT 1,
+    withdrawals_root      VARCHAR(66) NOT NULL,
-  base_fee              BIGINT,
+    PRIMARY KEY (block_hash, block_number)
  UNIQUE (block_number, block_hash)
 );
 -- +goose Down
-DROP TABLE eth.header_cids;
+DROP TABLE eth.header_cids;
--- a/db/migrations/00005_create_eth_uncle_cids_table.sql
+++ b/db/migrations/00005_create_eth_uncle_cids_table.sql
@ -1,14 +1,14 @@
 -- +goose Up
-CREATE TABLE eth.uncle_cids (
+CREATE TABLE IF NOT EXISTS eth.uncle_cids (
-  id                    SERIAL PRIMARY KEY,
+    block_number          BIGINT NOT NULL,
-  header_id             INTEGER NOT NULL REFERENCES eth.header_cids (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    block_hash            VARCHAR(66) NOT NULL,
-  block_hash            VARCHAR(66) NOT NULL,
+    header_id             VARCHAR(66) NOT NULL,
-  parent_hash           VARCHAR(66) NOT NULL,
+    parent_hash           VARCHAR(66) NOT NULL,
-  cid                   TEXT NOT NULL,
+    cid                   TEXT NOT NULL,
-  mh_key                TEXT NOT NULL REFERENCES public.blocks (key) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    reward                NUMERIC NOT NULL,
-  reward                NUMERIC NOT NULL,
+    index                 INT NOT NULL,
-  UNIQUE (header_id, block_hash)
+    PRIMARY KEY (block_hash, block_number)
 );
 -- +goose Down
-DROP TABLE eth.uncle_cids;
+DROP TABLE eth.uncle_cids;
--- a/db/migrations/00006_create_eth_transaction_cids_table.sql
+++ b/db/migrations/00006_create_eth_transaction_cids_table.sql
@ -1,16 +1,15 @@
 -- +goose Up
-CREATE TABLE eth.transaction_cids (
+CREATE TABLE IF NOT EXISTS eth.transaction_cids (
-  id                    SERIAL PRIMARY KEY,
+    block_number          BIGINT NOT NULL,
-  header_id             INTEGER NOT NULL REFERENCES eth.header_cids (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    header_id             VARCHAR(66) NOT NULL,
-  tx_hash               VARCHAR(66) NOT NULL,
+    tx_hash               VARCHAR(66) NOT NULL,
-  index                 INTEGER NOT NULL,
+    cid                   TEXT NOT NULL,
-  cid                   TEXT NOT NULL,
+    dst                   VARCHAR(66),
-  mh_key                TEXT NOT NULL REFERENCES public.blocks (key) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    src                   VARCHAR(66) NOT NULL,
-  dst                   VARCHAR(66) NOT NULL,
+    index                 INTEGER NOT NULL,
-  src                   VARCHAR(66) NOT NULL,
+    tx_type               INTEGER,
-  tx_data               BYTEA,
+    value                 NUMERIC,
-  tx_type               BYTEA,
+    PRIMARY KEY (tx_hash, header_id, block_number)
  UNIQUE (header_id, tx_hash)
 );
 -- +goose Down
--- a/db/migrations/00007_create_eth_receipt_cids_table.sql
+++ b/db/migrations/00007_create_eth_receipt_cids_table.sql
@ -1,16 +1,14 @@
 -- +goose Up
-CREATE TABLE eth.receipt_cids (
+CREATE TABLE IF NOT EXISTS eth.receipt_cids (
-  id                    SERIAL PRIMARY KEY,
+    block_number          BIGINT NOT NULL,
-  tx_id                 INTEGER NOT NULL REFERENCES eth.transaction_cids (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    header_id             VARCHAR(66) NOT NULL,
-  leaf_cid              TEXT NOT NULL,
+    tx_id                 VARCHAR(66) NOT NULL,
-  leaf_mh_key           TEXT NOT NULL REFERENCES public.blocks (key) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    cid                   TEXT NOT NULL,
-  contract              VARCHAR(66),
+    contract              VARCHAR(66),
-  contract_hash         VARCHAR(66),
+    post_state            VARCHAR(66),
-  post_state            VARCHAR(66),
+    post_status           SMALLINT,
-  post_status           INTEGER,
+    PRIMARY KEY (tx_id, header_id, block_number)
  log_root              VARCHAR(66),
  UNIQUE (tx_id)
 );
 -- +goose Down
-DROP TABLE eth.receipt_cids;
+DROP TABLE eth.receipt_cids;
--- a/db/migrations/00008_create_eth_state_cids_table.sql
+++ b/db/migrations/00008_create_eth_state_cids_table.sql
@ -1,15 +1,17 @@
 -- +goose Up
-CREATE TABLE eth.state_cids (
+CREATE TABLE IF NOT EXISTS eth.state_cids (
-  id                    BIGSERIAL PRIMARY KEY,
+    block_number          BIGINT NOT NULL,
-  header_id             INTEGER NOT NULL REFERENCES eth.header_cids (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    header_id             VARCHAR(66) NOT NULL,
-  state_leaf_key        VARCHAR(66),
+    state_leaf_key        VARCHAR(66) NOT NULL,
-  cid                   TEXT NOT NULL,
+    cid                   TEXT NOT NULL,
-  mh_key                TEXT NOT NULL REFERENCES public.blocks (key) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    diff                  BOOLEAN NOT NULL DEFAULT FALSE,
-  state_path            BYTEA,
+    balance               NUMERIC,      -- NULL if "removed"
-  node_type             INTEGER NOT NULL,
+    nonce                 BIGINT,       -- NULL if "removed"
-  diff                  BOOLEAN NOT NULL DEFAULT FALSE,
+    code_hash             VARCHAR(66),  -- NULL if "removed"
-  UNIQUE (header_id, state_path)
+    storage_root          VARCHAR(66),  -- NULL if "removed"
    removed               BOOLEAN NOT NULL,
    PRIMARY KEY (state_leaf_key, header_id, block_number)
 );
 -- +goose Down
-DROP TABLE eth.state_cids;
+DROP TABLE eth.state_cids;
--- a/db/migrations/00009_create_eth_storage_cids_table.sql
+++ b/db/migrations/00009_create_eth_storage_cids_table.sql
@ -1,15 +1,15 @@
 -- +goose Up
-CREATE TABLE eth.storage_cids (
+CREATE TABLE IF NOT EXISTS eth.storage_cids (
-  id                    BIGSERIAL PRIMARY KEY,
+    block_number          BIGINT NOT NULL,
-  state_id              BIGINT NOT NULL REFERENCES eth.state_cids (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    header_id             VARCHAR(66) NOT NULL,
-  storage_leaf_key      VARCHAR(66),
+    state_leaf_key        VARCHAR(66) NOT NULL,
-  cid                   TEXT NOT NULL,
+    storage_leaf_key      VARCHAR(66) NOT NULL,
-  mh_key                TEXT NOT NULL REFERENCES public.blocks (key) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
+    cid                   TEXT NOT NULL,
-  storage_path          BYTEA,
+    diff                  BOOLEAN NOT NULL DEFAULT FALSE,
-  node_type             INTEGER NOT NULL,
+    val                   BYTEA,  -- NULL if "removed"
-  diff                  BOOLEAN NOT NULL DEFAULT FALSE,
+    removed               BOOLEAN NOT NULL,
-  UNIQUE (state_id, storage_path)
+    PRIMARY KEY (storage_leaf_key, state_leaf_key, header_id, block_number)
 );
 -- +goose Down
-DROP TABLE eth.storage_cids;
+DROP TABLE eth.storage_cids;
--- a/db/migrations/00010_create_eth_log_cids_table.sql
+++ b/db/migrations/00010_create_eth_log_cids_table.sql
@ -0,0 +1,18 @@
 -- +goose Up
 CREATE TABLE IF NOT EXISTS eth.log_cids (
    block_number        BIGINT NOT NULL,
    header_id           VARCHAR(66) NOT NULL,
    cid                 TEXT NOT NULL,
    rct_id              VARCHAR(66) NOT NULL,
    address             VARCHAR(66) NOT NULL,
    index               INTEGER NOT NULL,
    topic0              VARCHAR(66),
    topic1              VARCHAR(66),
    topic2              VARCHAR(66),
    topic3              VARCHAR(66),
    PRIMARY KEY (rct_id, index, header_id, block_number)
 );
 -- +goose Down
 -- log indexes
 DROP TABLE eth.log_cids;
--- a/db/migrations/00010_create_eth_state_accouts_table.sql
+++ b/db/migrations/00010_create_eth_state_accouts_table.sql
@ -1,13 +0,0 @@
 -- +goose Up
 CREATE TABLE eth.state_accounts (
  id                    SERIAL PRIMARY KEY,
  state_id              BIGINT NOT NULL REFERENCES eth.state_cids (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
  balance               NUMERIC NOT NULL,
  nonce                 INTEGER NOT NULL,
  code_hash             BYTEA NOT NULL,
  storage_root          VARCHAR(66) NOT NULL,
  UNIQUE (state_id)
 );
 -- +goose Down
 DROP TABLE eth.state_accounts;
--- a/db/migrations/00011_create_postgraphile_comments.sql
+++ b/db/migrations/00011_create_postgraphile_comments.sql
@ -3,7 +3,7 @@ COMMENT ON TABLE public.nodes IS E'@name NodeInfo';
 COMMENT ON TABLE eth.transaction_cids IS E'@name EthTransactionCids';
 COMMENT ON TABLE eth.header_cids IS E'@name EthHeaderCids';
 COMMENT ON COLUMN public.nodes.node_id IS E'@name ChainNodeID';
-COMMENT ON COLUMN eth.header_cids.node_id IS E'@name EthNodeID';
+COMMENT ON COLUMN eth.header_cids.node_ids IS E'@name EthNodeIDs';
 -- +goose Down
@ -11,4 +11,4 @@ COMMENT ON TABLE public.nodes IS NULL;
 COMMENT ON TABLE eth.transaction_cids IS NULL;
 COMMENT ON TABLE eth.header_cids IS NULL;
 COMMENT ON COLUMN public.nodes.node_id IS NULL;
-COMMENT ON COLUMN eth.header_cids.node_id IS NULL;
+COMMENT ON COLUMN eth.header_cids.node_ids IS NULL;
--- a/db/migrations/00012_create_cid_indexes.sql
+++ b/db/migrations/00012_create_cid_indexes.sql
@ -0,0 +1,101 @@
 -- +goose Up
 -- header indexes
 CREATE INDEX header_block_number_index ON eth.header_cids USING btree (block_number);
 CREATE UNIQUE INDEX header_cid_block_number_index ON eth.header_cids USING btree (cid, block_number);
 CREATE INDEX state_root_index ON eth.header_cids USING btree (state_root);
 CREATE INDEX timestamp_index ON eth.header_cids USING btree (timestamp);
 -- uncle indexes
 CREATE INDEX uncle_block_number_index ON eth.uncle_cids USING btree (block_number);
 CREATE UNIQUE INDEX uncle_cid_block_number_index ON eth.uncle_cids USING btree (cid, block_number, index);
 CREATE INDEX uncle_header_id_index ON eth.uncle_cids USING btree (header_id);
 -- transaction indexes
 CREATE INDEX tx_block_number_index ON eth.transaction_cids USING btree (block_number);
 CREATE INDEX tx_header_id_index ON eth.transaction_cids USING btree (header_id);
 CREATE INDEX tx_cid_block_number_index ON eth.transaction_cids USING btree (cid, block_number);
 CREATE INDEX tx_dst_index ON eth.transaction_cids USING btree (dst);
 CREATE INDEX tx_src_index ON eth.transaction_cids USING btree (src);
 -- receipt indexes
 CREATE INDEX rct_block_number_index ON eth.receipt_cids USING btree (block_number);
 CREATE INDEX rct_header_id_index ON eth.receipt_cids USING btree (header_id);
 CREATE INDEX rct_cid_block_number_index ON eth.receipt_cids USING btree (cid, block_number);
 CREATE INDEX rct_contract_index ON eth.receipt_cids USING btree (contract);
 -- state node indexes
 CREATE INDEX state_block_number_index ON eth.state_cids USING btree (block_number);
 CREATE INDEX state_cid_block_number_index ON eth.state_cids USING btree (cid, block_number);
 CREATE INDEX state_header_id_index ON eth.state_cids USING btree (header_id);
 CREATE INDEX state_removed_index ON eth.state_cids USING btree (removed);
 CREATE INDEX state_code_hash_index ON eth.state_cids USING btree (code_hash); -- could be useful for e.g. selecting all the state accounts with the same contract bytecode deployed
 CREATE INDEX state_leaf_key_block_number_index ON eth.state_cids(state_leaf_key, block_number DESC);
 -- storage node indexes
 CREATE INDEX storage_block_number_index ON eth.storage_cids USING btree (block_number);
 CREATE INDEX storage_state_leaf_key_index ON eth.storage_cids USING btree (state_leaf_key);
 CREATE INDEX storage_cid_block_number_index ON eth.storage_cids USING btree (cid, block_number);
 CREATE INDEX storage_header_id_index ON eth.storage_cids USING btree (header_id);
 CREATE INDEX storage_removed_index ON eth.storage_cids USING btree (removed);
 CREATE INDEX storage_leaf_key_block_number_index ON eth.storage_cids(storage_leaf_key, block_number DESC);
 -- log indexes
 CREATE INDEX log_block_number_index ON eth.log_cids USING btree (block_number);
 CREATE INDEX log_header_id_index ON eth.log_cids USING btree (header_id);
 CREATE INDEX log_cid_block_number_index ON eth.log_cids USING btree (cid, block_number);
 CREATE INDEX log_address_index ON eth.log_cids USING btree (address);
 CREATE INDEX log_topic0_index ON eth.log_cids USING btree (topic0);
 CREATE INDEX log_topic1_index ON eth.log_cids USING btree (topic1);
 CREATE INDEX log_topic2_index ON eth.log_cids USING btree (topic2);
 CREATE INDEX log_topic3_index ON eth.log_cids USING btree (topic3);
 -- +goose Down
 -- log indexes
 DROP INDEX eth.log_topic3_index;
 DROP INDEX eth.log_topic2_index;
 DROP INDEX eth.log_topic1_index;
 DROP INDEX eth.log_topic0_index;
 DROP INDEX eth.log_address_index;
 DROP INDEX eth.log_cid_block_number_index;
 DROP INDEX eth.log_header_id_index;
 DROP INDEX eth.log_block_number_index;
 -- storage node indexes
 DROP INDEX eth.storage_removed_index;
 DROP INDEX eth.storage_header_id_index;
 DROP INDEX eth.storage_cid_block_number_index;
 DROP INDEX eth.storage_state_leaf_key_index;
 DROP INDEX eth.storage_block_number_index;
 DROP INDEX eth.storage_leaf_key_block_number_index;
 -- state node indexes
 DROP INDEX eth.state_code_hash_index;
 DROP INDEX eth.state_removed_index;
 DROP INDEX eth.state_header_id_index;
 DROP INDEX eth.state_cid_block_number_index;
 DROP INDEX eth.state_block_number_index;
 DROP INDEX eth.state_leaf_key_block_number_index;
 -- receipt indexes
 DROP INDEX eth.rct_contract_index;
 DROP INDEX eth.rct_cid_block_number_index;
 DROP INDEX eth.rct_header_id_index;
 DROP INDEX eth.rct_block_number_index;
 -- transaction indexes
 DROP INDEX eth.tx_src_index;
 DROP INDEX eth.tx_dst_index;
 DROP INDEX eth.tx_cid_block_number_index;
 DROP INDEX eth.tx_header_id_index;
 DROP INDEX eth.tx_block_number_index;
 -- uncle indexes
 DROP INDEX eth.uncle_block_number_index;
 DROP INDEX eth.uncle_cid_block_number_index;
 DROP INDEX eth.uncle_header_id_index;
 -- header indexes
 DROP INDEX eth.timestamp_index;
 DROP INDEX eth.state_root_index;
 DROP INDEX eth.header_cid_block_number_index;
 DROP INDEX eth.header_block_number_index;
--- a/db/migrations/00012_potgraphile_triggers.sql
+++ b/db/migrations/00012_potgraphile_triggers.sql
@ -1,69 +0,0 @@
 -- +goose Up
 -- +goose StatementBegin
 CREATE FUNCTION eth.graphql_subscription() returns TRIGGER as $$
 declare
    table_name text = TG_ARGV[0];
    attribute text = TG_ARGV[1];
    id text;
 begin
    execute 'select $1.' || quote_ident(attribute)
        using new
        into id;
    perform pg_notify('postgraphile:' || table_name,
                      json_build_object(
                              '__node__', json_build_array(
                              table_name,
                              id
                          )
                          )::text
        );
    return new;
 end;
 $$ language plpgsql;
 -- +goose StatementEnd
 CREATE TRIGGER header_cids_ai
    after INSERT ON eth.header_cids
    for each row
    execute procedure eth.graphql_subscription('header_cids', 'id');
 CREATE TRIGGER receipt_cids_ai
    after INSERT ON eth.receipt_cids
    for each row
    execute procedure eth.graphql_subscription('receipt_cids', 'id');
 CREATE TRIGGER state_accounts_ai
    after INSERT ON eth.state_accounts
    for each row
    execute procedure eth.graphql_subscription('state_accounts', 'id');
 CREATE TRIGGER state_cids_ai
    after INSERT ON eth.state_cids
    for each row
    execute procedure eth.graphql_subscription('state_cids', 'id');
 CREATE TRIGGER storage_cids_ai
    after INSERT ON eth.storage_cids
    for each row
    execute procedure eth.graphql_subscription('storage_cids', 'id');
 CREATE TRIGGER transaction_cids_ai
    after INSERT ON eth.transaction_cids
    for each row
    execute procedure eth.graphql_subscription('transaction_cids', 'id');
 CREATE TRIGGER uncle_cids_ai
    after INSERT ON eth.uncle_cids
    for each row
    execute procedure eth.graphql_subscription('uncle_cids', 'id');
 -- +goose Down
 DROP TRIGGER uncle_cids_ai ON eth.uncle_cids;
 DROP TRIGGER transaction_cids_ai ON eth.transaction_cids;
 DROP TRIGGER storage_cids_ai ON eth.storage_cids;
 DROP TRIGGER state_cids_ai ON eth.state_cids;
 DROP TRIGGER state_accounts_ai ON eth.state_accounts;
 DROP TRIGGER receipt_cids_ai ON eth.receipt_cids;
 DROP TRIGGER header_cids_ai ON eth.header_cids;
 DROP FUNCTION eth.graphql_subscription();
--- a/db/migrations/00013_create_cid_indexes.sql
+++ b/db/migrations/00013_create_cid_indexes.sql
@ -1,112 +0,0 @@
 -- +goose Up
 -- header indexes
 CREATE INDEX block_number_index ON eth.header_cids USING brin (block_number);
 CREATE INDEX block_hash_index ON eth.header_cids USING btree (block_hash);
 CREATE INDEX header_cid_index ON eth.header_cids USING btree (cid);
 CREATE INDEX header_mh_index ON eth.header_cids USING btree (mh_key);
 CREATE INDEX state_root_index ON eth.header_cids USING btree (state_root);
 CREATE INDEX timestamp_index ON eth.header_cids USING brin (timestamp);
 -- transaction indexes
 CREATE INDEX tx_header_id_index ON eth.transaction_cids USING btree (header_id);
 CREATE INDEX tx_hash_index ON eth.transaction_cids USING btree (tx_hash);
 CREATE INDEX tx_cid_index ON eth.transaction_cids USING btree (cid);
 CREATE INDEX tx_mh_index ON eth.transaction_cids USING btree (mh_key);
 CREATE INDEX tx_dst_index ON eth.transaction_cids USING btree (dst);
 CREATE INDEX tx_src_index ON eth.transaction_cids USING btree (src);
 -- receipt indexes
 CREATE INDEX rct_tx_id_index ON eth.receipt_cids USING btree (tx_id);
 CREATE INDEX rct_leaf_cid_index ON eth.receipt_cids USING btree (leaf_cid);
 CREATE INDEX rct_leaf_mh_index ON eth.receipt_cids USING btree (leaf_mh_key);
 CREATE INDEX rct_contract_index ON eth.receipt_cids USING btree (contract);
 CREATE INDEX rct_contract_hash_index ON eth.receipt_cids USING btree (contract_hash);
 -- state node indexes
 CREATE INDEX state_header_id_index ON eth.state_cids USING btree (header_id);
 CREATE INDEX state_leaf_key_index ON eth.state_cids USING btree (state_leaf_key);
 CREATE INDEX state_cid_index ON eth.state_cids USING btree (cid);
 CREATE INDEX state_mh_index ON eth.state_cids USING btree (mh_key);
 CREATE INDEX state_path_index ON eth.state_cids USING btree (state_path);
 CREATE INDEX state_node_type_index ON eth.state_cids USING btree (node_type);
 -- storage node indexes
 CREATE INDEX storage_state_id_index ON eth.storage_cids USING btree (state_id);
 CREATE INDEX storage_leaf_key_index ON eth.storage_cids USING btree (storage_leaf_key);
 CREATE INDEX storage_cid_index ON eth.storage_cids USING btree (cid);
 CREATE INDEX storage_mh_index ON eth.storage_cids USING btree (mh_key);
 CREATE INDEX storage_path_index ON eth.storage_cids USING btree (storage_path);
 CREATE INDEX storage_node_type_index ON eth.storage_cids USING btree (node_type);
 -- state accounts indexes
 CREATE INDEX account_state_id_index ON eth.state_accounts USING btree (state_id);
 CREATE INDEX storage_root_index ON eth.state_accounts USING btree (storage_root);
 -- +goose Down
 -- state account indexes
 DROP INDEX eth.storage_root_index;
 DROP INDEX eth.account_state_id_index;
 -- storage node indexes
 DROP INDEX eth.storage_node_type_index;
 DROP INDEX eth.storage_path_index;
 DROP INDEX eth.storage_mh_index;
 DROP INDEX eth.storage_cid_index;
 DROP INDEX eth.storage_leaf_key_index;
 DROP INDEX eth.storage_state_id_index;
 -- state node indexes
 DROP INDEX eth.state_node_type_index;
 DROP INDEX eth.state_path_index;
 DROP INDEX eth.state_mh_index;
 DROP INDEX eth.state_cid_index;
 DROP INDEX eth.state_leaf_key_index;
 DROP INDEX eth.state_header_id_index;
 -- receipt indexes
 DROP INDEX eth.rct_contract_hash_index;
 DROP INDEX eth.rct_contract_index;
 DROP INDEX eth.rct_leaf_mh_index;
 DROP INDEX eth.rct_leaf_cid_index;
 DROP INDEX eth.rct_tx_id_index;
 -- transaction indexes
 DROP INDEX eth.tx_src_index;
 DROP INDEX eth.tx_dst_index;
 DROP INDEX eth.tx_mh_index;
 DROP INDEX eth.tx_cid_index;
 DROP INDEX eth.tx_hash_index;
 DROP INDEX eth.tx_header_id_index;
 -- header indexes
 DROP INDEX eth.timestamp_index;
 DROP INDEX eth.state_root_index;
 DROP INDEX eth.header_mh_index;
 DROP INDEX eth.header_cid_index;
 DROP INDEX eth.block_hash_index;
 DROP INDEX eth.block_number_index;
--- a/db/migrations/00013_create_db_version_table.sql
+++ b/db/migrations/00013_create_db_version_table.sql
@ -0,0 +1,12 @@
 -- +goose Up
 CREATE TABLE IF NOT EXISTS public.db_version (
    singleton BOOLEAN NOT NULL DEFAULT TRUE UNIQUE CHECK (singleton),
    version TEXT NOT NULL,
    tstamp TIMESTAMP WITHOUT TIME ZONE DEFAULT NOW()
 );
 INSERT INTO public.db_version (singleton, version) VALUES (true, 'v5.0.0')
    ON CONFLICT (singleton) DO UPDATE SET (version, tstamp) = ('v5.0.0', NOW());
 -- +goose Down
 DROP TABLE public.db_version;
--- a/db/migrations/00014_create_eth_meta_schema.sql
+++ b/db/migrations/00014_create_eth_meta_schema.sql
@ -0,0 +1,5 @@
 -- +goose Up
 CREATE SCHEMA eth_meta;
 -- +goose Down
 DROP SCHEMA eth_meta;
--- a/db/migrations/00014_create_stored_functions.sql
+++ b/db/migrations/00014_create_stored_functions.sql
@ -1,138 +0,0 @@
 -- +goose Up
 -- +goose StatementBegin
 -- returns if a state leaf node was removed within the provided block number
 CREATE OR REPLACE FUNCTION was_state_leaf_removed(key character varying, hash character varying)
    RETURNS boolean AS $$
    SELECT state_cids.node_type = 3
    FROM eth.state_cids
             INNER JOIN eth.header_cids ON (state_cids.header_id = header_cids.id)
    WHERE state_leaf_key = key
      AND block_number <= (SELECT block_number
                           FROM eth.header_cids
                           WHERE block_hash = hash)
    ORDER BY block_number DESC LIMIT 1;
 $$
 language sql;
 -- +goose StatementEnd
 -- +goose StatementBegin
 CREATE TYPE child_result AS (
    has_child BOOLEAN,
    children eth.header_cids[]
 );
 CREATE OR REPLACE FUNCTION has_child(hash VARCHAR(66), height BIGINT) RETURNS child_result AS
 $BODY$
 DECLARE
  child_height INT;
  temp_child eth.header_cids;
  new_child_result child_result;
 BEGIN
  child_height = height + 1;
  -- short circuit if there are no children
  SELECT exists(SELECT 1
              FROM eth.header_cids
              WHERE parent_hash = hash
                AND block_number = child_height
              LIMIT 1)
  INTO new_child_result.has_child;
  -- collect all the children for this header
  IF new_child_result.has_child THEN
    FOR temp_child IN
    SELECT * FROM eth.header_cids WHERE parent_hash = hash AND block_number = child_height
    LOOP
      new_child_result.children = array_append(new_child_result.children, temp_child);
    END LOOP;
  END IF;
  RETURN new_child_result;
 END
 $BODY$
 LANGUAGE 'plpgsql';
 -- +goose StatementEnd
 -- +goose StatementBegin
 CREATE OR REPLACE FUNCTION canonical_header_from_array(headers eth.header_cids[]) RETURNS eth.header_cids AS
 $BODY$
 DECLARE
  canonical_header eth.header_cids;
  canonical_child eth.header_cids;
  header eth.header_cids;
  current_child_result child_result;
  child_headers eth.header_cids[];
  current_header_with_child eth.header_cids;
  has_children_count INT DEFAULT 0;
 BEGIN
  -- for each header in the provided set
  FOREACH header IN ARRAY headers
  LOOP
    -- check if it has any children
    current_child_result = has_child(header.block_hash, header.block_number);
    IF current_child_result.has_child THEN
      -- if it does, take note
      has_children_count = has_children_count + 1;
      current_header_with_child = header;
      -- and add the children to the growing set of child headers
      child_headers = array_cat(child_headers, current_child_result.children);
    END IF;
  END LOOP;
  -- if none of the headers had children, none is more canonical than the other
  IF has_children_count = 0 THEN
    -- return the first one selected
    SELECT * INTO canonical_header FROM unnest(headers) LIMIT 1;
  -- if only one header had children, it can be considered the heaviest/canonical header of the set
  ELSIF has_children_count = 1 THEN
    -- return the only header with a child
    canonical_header = current_header_with_child;
  -- if there are multiple headers with children
  ELSE
    -- find the canonical header from the child set
    canonical_child = canonical_header_from_array(child_headers);
    -- the header that is parent to this header, is the canonical header at this level
    SELECT * INTO canonical_header FROM unnest(headers)
    WHERE block_hash = canonical_child.parent_hash;
  END IF;
  RETURN canonical_header;
 END
 $BODY$
 LANGUAGE 'plpgsql';
 -- +goose StatementEnd
 -- +goose StatementBegin
 CREATE OR REPLACE FUNCTION canonical_header_id(height BIGINT) RETURNS INTEGER AS
 $BODY$
 DECLARE
  canonical_header eth.header_cids;
  headers eth.header_cids[];
  header_count INT;
  temp_header eth.header_cids;
 BEGIN
  -- collect all headers at this height
  FOR temp_header IN
  SELECT * FROM eth.header_cids WHERE block_number = height
  LOOP
    headers = array_append(headers, temp_header);
  END LOOP;
  -- count the number of headers collected
  header_count = array_length(headers, 1);
  -- if we have less than 1 header, return NULL
  IF header_count IS NULL OR header_count < 1 THEN
    RETURN NULL;
  -- if we have one header, return its id
  ELSIF header_count = 1 THEN
    RETURN headers[1].id;
  -- if we have multiple headers we need to determine which one is canonical
  ELSE
    canonical_header = canonical_header_from_array(headers);
    RETURN canonical_header.id;
  END IF;
 END;
 $BODY$
 LANGUAGE 'plpgsql';
 -- +goose StatementEnd
 -- +goose Down
 DROP FUNCTION was_state_leaf_removed;
 DROP FUNCTION canonical_header_id;
 DROP FUNCTION canonical_header_from_array;
 DROP FUNCTION has_child;
 DROP TYPE child_result;
--- a/db/migrations/00015_create_access_list_table.sql
+++ b/db/migrations/00015_create_access_list_table.sql
@ -1,15 +0,0 @@
 -- +goose Up
 CREATE TABLE eth.access_list_element (
    id                    SERIAL PRIMARY KEY,
    tx_id                 INTEGER NOT NULL REFERENCES eth.transaction_cids (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
    index                 INTEGER NOT NULL,
    address               VARCHAR(66),
    storage_keys          VARCHAR(66)[],
    UNIQUE (tx_id, index)
 );
 CREATE INDEX accesss_list_element_address_index ON eth.access_list_element USING btree (address);
 -- +goose Down
 DROP INDEX eth.accesss_list_element_address_index;
 DROP TABLE eth.access_list_element;
--- a/db/migrations/00015_create_watched_addresses_table.sql
+++ b/db/migrations/00015_create_watched_addresses_table.sql
@ -0,0 +1,10 @@
 -- +goose Up
 CREATE TABLE eth_meta.watched_addresses (
    address                 VARCHAR(66) PRIMARY KEY,
    created_at              BIGINT NOT NULL,
    watched_at              BIGINT NOT NULL,
    last_filled_at          BIGINT NOT NULL DEFAULT 0
 );
 -- +goose Down
 DROP TABLE eth_meta.watched_addresses;
--- a/db/migrations/00016_create_eth_log_cids_table.sql
+++ b/db/migrations/00016_create_eth_log_cids_table.sql
@ -1,61 +0,0 @@
 -- +goose Up
 CREATE TABLE eth.log_cids (
    id                  SERIAL PRIMARY KEY,
    leaf_cid            TEXT NOT NULL,
    leaf_mh_key         TEXT NOT NULL REFERENCES public.blocks (key) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
    receipt_id          INTEGER NOT NULL REFERENCES eth.receipt_cids (id) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
    address             VARCHAR(66) NOT NULL,
    log_data            BYTEA,
    index               INTEGER NOT NULL,
    topic0              VARCHAR(66),
    topic1              VARCHAR(66),
    topic2              VARCHAR(66),
    topic3              VARCHAR(66),
    UNIQUE (receipt_id, index)
 );
 CREATE INDEX log_mh_index ON eth.log_cids USING btree (leaf_mh_key);
 CREATE INDEX log_cid_index ON  eth.log_cids USING btree (leaf_cid);
 CREATE INDEX log_rct_id_index ON eth.log_cids USING btree (receipt_id);
 --
 -- Name: log_topic0_index; Type: INDEX; Schema: eth; Owner: -
 --
 CREATE INDEX log_topic0_index ON eth.log_cids USING btree (topic0);
 --
 -- Name: log_topic1_index; Type: INDEX; Schema: eth; Owner: -
 --
 CREATE INDEX log_topic1_index ON eth.log_cids USING btree (topic1);
 --
 -- Name: log_topic2_index; Type: INDEX; Schema: eth; Owner: -
 --
 CREATE INDEX log_topic2_index ON eth.log_cids USING btree (topic2);
 --
 -- Name: log_topic3_index; Type: INDEX; Schema: eth; Owner: -
 --
 CREATE INDEX log_topic3_index ON eth.log_cids USING btree (topic3);
 -- +goose Down
 -- log indexes
 DROP INDEX eth.log_mh_index;
 DROP INDEX eth.log_cid_index;
 DROP INDEX eth.log_rct_id_index;
 DROP INDEX eth.log_topic0_index;
 DROP INDEX eth.log_topic1_index;
 DROP INDEX eth.log_topic2_index;
 DROP INDEX eth.log_topic3_index;
 DROP TABLE eth.log_cids;
--- a/db/migrations/00016_create_stored_procedures.sql
+++ b/db/migrations/00016_create_stored_procedures.sql
@ -0,0 +1,43 @@
 -- +goose Up
 -- +goose StatementBegin
 -- returns whether the state leaf key is vacated (previously existed but now is empty) at the provided block hash
 CREATE OR REPLACE FUNCTION was_state_leaf_removed(v_key VARCHAR(66), v_hash VARCHAR)
    RETURNS boolean AS $$
    SELECT state_cids.removed = true
    FROM eth.state_cids
             INNER JOIN eth.header_cids ON (state_cids.header_id = header_cids.block_hash)
    WHERE state_leaf_key = v_key
      AND state_cids.block_number <= (SELECT block_number
                           FROM eth.header_cids
                           WHERE block_hash = v_hash)
    ORDER BY state_cids.block_number DESC LIMIT 1;
 $$
 language sql;
 -- +goose StatementEnd
 -- +goose StatementBegin
 -- returns whether the state leaf key is vacated (previously existed but now is empty) at the provided block height
 CREATE OR REPLACE FUNCTION public.was_state_leaf_removed_by_number(v_key VARCHAR(66), v_block_no BIGINT)
    RETURNS BOOLEAN AS $$
    SELECT state_cids.removed = true
    FROM eth.state_cids
             INNER JOIN eth.header_cids ON (state_cids.header_id = header_cids.block_hash)
    WHERE state_leaf_key = v_key
      AND state_cids.block_number <= v_block_no
    ORDER BY state_cids.block_number DESC LIMIT 1;
 $$
 language sql;
 -- +goose StatementEnd
 -- +goose StatementBegin
 CREATE OR REPLACE FUNCTION canonical_header_hash(height BIGINT) RETURNS character varying AS
 $BODY$
    SELECT block_hash from eth.header_cids WHERE block_number = height AND canonical = true LIMIT 1;
 $BODY$
 LANGUAGE sql;
 -- +goose StatementEnd
 -- +goose Down
 DROP FUNCTION was_state_leaf_removed;
 DROP FUNCTION was_state_leaf_removed_by_number;
 DROP FUNCTION canonical_header_hash;
--- a/db/migrations/00017_create_get_storage_at_functions.sql
+++ b/db/migrations/00017_create_get_storage_at_functions.sql
@ -0,0 +1,110 @@
 -- +goose Up
 -- +goose StatementBegin
 CREATE OR REPLACE FUNCTION public.get_storage_at_by_number(v_state_leaf_key text, v_storage_leaf_key text, v_block_no bigint)
    RETURNS TABLE
            (
                cid                TEXT,
                val                BYTEA,
                block_number       BIGINT,
                removed            BOOL,
                state_leaf_removed BOOL
            )
 AS
 $BODY$
 DECLARE
    v_state_path       BYTEA;
    v_header           TEXT;
    v_canonical_header TEXT;
 BEGIN
    CREATE TEMP TABLE tmp_tt_stg2
    (
        header_id          TEXT,
        cid                TEXT,
        val                BYTEA,
        block_number       BIGINT,
        removed            BOOL,
        state_leaf_removed BOOL
    ) ON COMMIT DROP;
    -- in best case scenario, the latest record we find for the provided keys is for a canonical block
    INSERT INTO tmp_tt_stg2
    SELECT storage_cids.header_id,
           storage_cids.cid,
           storage_cids.val,
           storage_cids.block_number,
           storage_cids.removed,
           was_state_leaf_removed_by_number(v_state_leaf_key, v_block_no) AS state_leaf_removed
    FROM eth.storage_cids
    WHERE storage_leaf_key = v_storage_leaf_key
      AND storage_cids.state_leaf_key = v_state_leaf_key -- can lookup directly on the leaf key in v5
      AND storage_cids.block_number <= v_block_no
    ORDER BY storage_cids.block_number DESC LIMIT 1;
    -- check if result is from canonical state
    SELECT header_id, canonical_header_hash(tmp_tt_stg2.block_number)
    INTO v_header, v_canonical_header
    FROM tmp_tt_stg2 LIMIT 1;
    IF v_header IS NULL OR v_header != v_canonical_header THEN
        RAISE NOTICE 'get_storage_at_by_number: chosen header NULL OR % != canonical header % for block number %, trying again.', v_header, v_canonical_header, v_block_no;
        TRUNCATE tmp_tt_stg2;
        -- If we hit on a non-canonical block, we need to go back and do a comprehensive check.
        -- We try to avoid this to avoid joining between storage_cids and header_cids
        INSERT INTO tmp_tt_stg2
        SELECT storage_cids.header_id,
               storage_cids.cid,
               storage_cids.val,
               storage_cids.block_number,
               storage_cids.removed,
               was_state_leaf_removed_by_number(
                       v_state_leaf_key,
                       v_block_no
                   ) AS state_leaf_removed
        FROM eth.storage_cids
                 INNER JOIN eth.header_cids ON (
                    storage_cids.header_id = header_cids.block_hash
                AND storage_cids.block_number = header_cids.block_number
            )
        WHERE state_leaf_key = v_state_leaf_key
          AND storage_leaf_key = v_storage_leaf_key
          AND storage_cids.block_number <= v_block_no
          AND header_cids.block_number <= v_block_no
          AND header_cids.block_hash = (SELECT canonical_header_hash(header_cids.block_number))
        ORDER BY header_cids.block_number DESC LIMIT 1;
    END IF;
    RETURN QUERY SELECT t.cid, t.val, t.block_number, t.removed, t.state_leaf_removed
                    FROM tmp_tt_stg2 AS t LIMIT 1;
 END
 $BODY$
 language 'plpgsql';
 -- +goose StatementEnd
 -- +goose StatementBegin
 CREATE OR REPLACE FUNCTION public.get_storage_at_by_hash(v_state_leaf_key TEXT, v_storage_leaf_key text, v_block_hash text)
    RETURNS TABLE
            (
                cid                TEXT,
                val                BYTEA,
                block_number       BIGINT,
                removed            BOOL,
                state_leaf_removed BOOL
            )
 AS
 $BODY$
 DECLARE
    v_block_no BIGINT;
 BEGIN
    SELECT h.block_number INTO v_block_no FROM eth.header_cids AS h WHERE block_hash = v_block_hash LIMIT 1;
    IF v_block_no IS NULL THEN
        RETURN;
    END IF;
    RETURN QUERY SELECT * FROM get_storage_at_by_number(v_state_leaf_key, v_storage_leaf_key, v_block_no);
 END
 $BODY$
 LANGUAGE 'plpgsql';
 -- +goose StatementEnd
 -- +goose Down
 DROP FUNCTION get_storage_at_by_hash;
 DROP FUNCTION get_storage_at_by_number;
--- a/db/migrations/00018_create_foreign_keys.sql
+++ b/db/migrations/00018_create_foreign_keys.sql
@ -0,0 +1,105 @@
 -- +goose Up
 ALTER TABLE eth.header_cids
 ADD CONSTRAINT header_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.uncle_cids
 ADD CONSTRAINT uncle_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.uncle_cids
 ADD CONSTRAINT uncle_cids_header_cids_fkey
 FOREIGN KEY (header_id, block_number)
 REFERENCES eth.header_cids (block_hash, block_number);
 ALTER TABLE eth.transaction_cids
 ADD CONSTRAINT transaction_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.transaction_cids
 ADD CONSTRAINT transaction_cids_header_cids_fkey
 FOREIGN KEY (header_id, block_number)
 REFERENCES eth.header_cids (block_hash, block_number);
 ALTER TABLE eth.receipt_cids
 ADD CONSTRAINT receipt_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.receipt_cids
 ADD CONSTRAINT receipt_cids_transaction_cids_fkey
 FOREIGN KEY (tx_id, header_id, block_number)
 REFERENCES eth.transaction_cids (tx_hash, header_id, block_number);
 ALTER TABLE eth.state_cids
 ADD CONSTRAINT state_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.state_cids
 ADD CONSTRAINT state_cids_header_cids_fkey
 FOREIGN KEY (header_id, block_number)
 REFERENCES eth.header_cids (block_hash, block_number);
 ALTER TABLE eth.storage_cids
 ADD CONSTRAINT storage_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.storage_cids
 ADD CONSTRAINT storage_cids_state_cids_fkey
 FOREIGN KEY (state_leaf_key, header_id, block_number)
 REFERENCES eth.state_cids (state_leaf_key, header_id, block_number);
 ALTER TABLE eth.log_cids
 ADD CONSTRAINT log_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.log_cids
 ADD CONSTRAINT log_cids_receipt_cids_fkey
 FOREIGN KEY (rct_id, header_id, block_number)
 REFERENCES eth.receipt_cids (tx_id, header_id, block_number);
 -- +goose Down
 ALTER TABLE eth.log_cids
 DROP CONSTRAINT log_cids_receipt_cids_fkey;
 ALTER TABLE eth.log_cids
 DROP CONSTRAINT log_cids_ipld_blocks_fkey;
 ALTER TABLE eth.storage_cids
 DROP CONSTRAINT storage_cids_state_cids_fkey;
 ALTER TABLE eth.storage_cids
 DROP CONSTRAINT storage_cids_ipld_blocks_fkey;
 ALTER TABLE eth.state_cids
 DROP CONSTRAINT state_cids_header_cids_fkey;
 ALTER TABLE eth.state_cids
 DROP CONSTRAINT state_cids_ipld_blocks_fkey;
 ALTER TABLE eth.receipt_cids
 DROP CONSTRAINT receipt_cids_transaction_cids_fkey;
 ALTER TABLE eth.receipt_cids
 DROP CONSTRAINT receipt_cids_ipld_blocks_fkey;
 ALTER TABLE eth.transaction_cids
 DROP CONSTRAINT transaction_cids_header_cids_fkey;
 ALTER TABLE eth.transaction_cids
 DROP CONSTRAINT transaction_cids_ipld_blocks_fkey;
 ALTER TABLE eth.uncle_cids
 DROP CONSTRAINT uncle_cids_header_cids_fkey;
 ALTER TABLE eth.uncle_cids
 DROP CONSTRAINT uncle_cids_ipld_blocks_fkey;
 ALTER TABLE eth.header_cids
 DROP CONSTRAINT header_cids_ipld_blocks_fkey;
--- a/db/migrations/00019_drop_foreign_keys.sql
+++ b/db/migrations/00019_drop_foreign_keys.sql
@ -0,0 +1,105 @@
 -- +goose Up
 ALTER TABLE eth.log_cids
 DROP CONSTRAINT log_cids_receipt_cids_fkey;
 ALTER TABLE eth.log_cids
 DROP CONSTRAINT log_cids_ipld_blocks_fkey;
 ALTER TABLE eth.storage_cids
 DROP CONSTRAINT storage_cids_state_cids_fkey;
 ALTER TABLE eth.storage_cids
 DROP CONSTRAINT storage_cids_ipld_blocks_fkey;
 ALTER TABLE eth.state_cids
 DROP CONSTRAINT state_cids_header_cids_fkey;
 ALTER TABLE eth.state_cids
 DROP CONSTRAINT state_cids_ipld_blocks_fkey;
 ALTER TABLE eth.receipt_cids
 DROP CONSTRAINT receipt_cids_transaction_cids_fkey;
 ALTER TABLE eth.receipt_cids
 DROP CONSTRAINT receipt_cids_ipld_blocks_fkey;
 ALTER TABLE eth.transaction_cids
 DROP CONSTRAINT transaction_cids_header_cids_fkey;
 ALTER TABLE eth.transaction_cids
 DROP CONSTRAINT transaction_cids_ipld_blocks_fkey;
 ALTER TABLE eth.uncle_cids
 DROP CONSTRAINT uncle_cids_header_cids_fkey;
 ALTER TABLE eth.uncle_cids
 DROP CONSTRAINT uncle_cids_ipld_blocks_fkey;
 ALTER TABLE eth.header_cids
 DROP CONSTRAINT header_cids_ipld_blocks_fkey;
 -- +goose Down
 ALTER TABLE eth.header_cids
 ADD CONSTRAINT header_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.uncle_cids
 ADD CONSTRAINT uncle_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.uncle_cids
 ADD CONSTRAINT uncle_cids_header_cids_fkey
 FOREIGN KEY (header_id, block_number)
 REFERENCES eth.header_cids (block_hash, block_number);
 ALTER TABLE eth.transaction_cids
 ADD CONSTRAINT transaction_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.transaction_cids
 ADD CONSTRAINT transaction_cids_header_cids_fkey
 FOREIGN KEY (header_id, block_number)
 REFERENCES eth.header_cids (block_hash, block_number);
 ALTER TABLE eth.receipt_cids
 ADD CONSTRAINT receipt_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.receipt_cids
 ADD CONSTRAINT receipt_cids_transaction_cids_fkey
 FOREIGN KEY (tx_id, header_id, block_number)
 REFERENCES eth.transaction_cids (tx_hash, header_id, block_number);
 ALTER TABLE eth.state_cids
 ADD CONSTRAINT state_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.state_cids
 ADD CONSTRAINT state_cids_header_cids_fkey
 FOREIGN KEY (header_id, block_number)
 REFERENCES eth.header_cids (block_hash, block_number);
 ALTER TABLE eth.storage_cids
 ADD CONSTRAINT storage_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.storage_cids
 ADD CONSTRAINT storage_cids_state_cids_fkey
 FOREIGN KEY (state_leaf_key, header_id, block_number)
 REFERENCES eth.state_cids (state_leaf_key, header_id, block_number);
 ALTER TABLE eth.log_cids
 ADD CONSTRAINT log_cids_ipld_blocks_fkey
 FOREIGN KEY (cid, block_number)
 REFERENCES ipld.blocks (key, block_number);
 ALTER TABLE eth.log_cids
 ADD CONSTRAINT log_cids_receipt_cids_fkey
 FOREIGN KEY (rct_id, header_id, block_number)
 REFERENCES eth.receipt_cids (tx_id, header_id, block_number);
--- a/db/migrations/00020_convert_to_hypertables.sql
+++ b/db/migrations/00020_convert_to_hypertables.sql
@ -0,0 +1,98 @@
 -- +goose Up
 SELECT create_hypertable('ipld.blocks', 'block_number', migrate_data => true, chunk_time_interval => 32768);
 SELECT create_hypertable('eth.uncle_cids', 'block_number', migrate_data => true, chunk_time_interval => 32768);
 SELECT create_hypertable('eth.transaction_cids', 'block_number', migrate_data => true, chunk_time_interval => 32768);
 SELECT create_hypertable('eth.receipt_cids', 'block_number', migrate_data => true, chunk_time_interval => 32768);
 SELECT create_hypertable('eth.state_cids', 'block_number', migrate_data => true, chunk_time_interval => 32768);
 SELECT create_hypertable('eth.storage_cids', 'block_number', migrate_data => true, chunk_time_interval => 32768);
 SELECT create_hypertable('eth.log_cids', 'block_number', migrate_data => true, chunk_time_interval => 32768);
 -- update version
 INSERT INTO public.db_version (singleton, version) VALUES (true, 'v5.0.0-h')
    ON CONFLICT (singleton) DO UPDATE SET (version, tstamp) = ('v5.0.0-h', NOW());
 -- +goose Down
 INSERT INTO public.db_version (singleton, version) VALUES (true, 'v5.0.0')
    ON CONFLICT (singleton) DO UPDATE SET (version, tstamp) = ('v5.0.0', NOW());
 -- reversing conversion to hypertable requires migrating all data from every chunk back to a single table
 -- create new regular tables
 CREATE TABLE eth.log_cids_i (LIKE eth.log_cids INCLUDING ALL);
 CREATE TABLE eth.storage_cids_i (LIKE eth.storage_cids INCLUDING ALL);
 CREATE TABLE eth.state_cids_i (LIKE eth.state_cids INCLUDING ALL);
 CREATE TABLE eth.receipt_cids_i (LIKE eth.receipt_cids INCLUDING ALL);
 CREATE TABLE eth.transaction_cids_i (LIKE eth.transaction_cids INCLUDING ALL);
 CREATE TABLE eth.uncle_cids_i (LIKE eth.uncle_cids INCLUDING ALL);
 CREATE TABLE ipld.blocks_i (LIKE ipld.blocks INCLUDING ALL);
 -- migrate data
 INSERT INTO eth.log_cids_i (SELECT * FROM eth.log_cids);
 INSERT INTO eth.storage_cids_i (SELECT * FROM eth.storage_cids);
 INSERT INTO eth.state_cids_i (SELECT * FROM eth.state_cids);
 INSERT INTO eth.receipt_cids_i (SELECT * FROM eth.receipt_cids);
 INSERT INTO eth.transaction_cids_i (SELECT * FROM eth.transaction_cids);
 INSERT INTO eth.uncle_cids_i (SELECT * FROM eth.uncle_cids);
 INSERT INTO ipld.blocks_i (SELECT * FROM ipld.blocks);
 -- drop hypertables
 DROP TABLE eth.log_cids;
 DROP TABLE eth.storage_cids;
 DROP TABLE eth.state_cids;
 DROP TABLE eth.receipt_cids;
 DROP TABLE eth.transaction_cids;
 DROP TABLE eth.uncle_cids;
 DROP TABLE ipld.blocks;
 -- rename new tables
 ALTER TABLE eth.log_cids_i RENAME TO log_cids;
 ALTER TABLE eth.storage_cids_i RENAME TO storage_cids;
 ALTER TABLE eth.state_cids_i RENAME TO state_cids;
 ALTER TABLE eth.receipt_cids_i RENAME TO receipt_cids;
 ALTER TABLE eth.transaction_cids_i RENAME TO transaction_cids;
 ALTER TABLE eth.uncle_cids_i RENAME TO uncle_cids;
 ALTER TABLE ipld.blocks_i RENAME TO blocks;
 -- rename indexes:
 -- log indexes
 ALTER INDEX eth.log_cids_i_topic3_idx RENAME TO log_topic3_index;
 ALTER INDEX eth.log_cids_i_topic2_idx RENAME TO log_topic2_index;
 ALTER INDEX eth.log_cids_i_topic1_idx RENAME TO log_topic1_index;
 ALTER INDEX eth.log_cids_i_topic0_idx RENAME TO log_topic0_index;
 ALTER INDEX eth.log_cids_i_address_idx RENAME TO log_address_index;
 ALTER INDEX eth.log_cids_i_cid_block_number_idx RENAME TO log_cid_block_number_index;
 ALTER INDEX eth.log_cids_i_header_id_idx RENAME TO log_header_id_index;
 ALTER INDEX eth.log_cids_i_block_number_idx RENAME TO log_block_number_index;
 -- storage node indexes                                            -- storage node indexes
 ALTER INDEX eth.storage_cids_i_removed_idx RENAME TO storage_removed_index;
 ALTER INDEX eth.storage_cids_i_header_id_idx RENAME TO storage_header_id_index;
 ALTER INDEX eth.storage_cids_i_cid_block_number_idx RENAME TO storage_cid_block_number_index;
 ALTER INDEX eth.storage_cids_i_state_leaf_key_idx RENAME TO storage_state_leaf_key_index;
 ALTER INDEX eth.storage_cids_i_block_number_idx RENAME TO storage_block_number_index;
 ALTER INDEX eth.storage_cids_i_storage_leaf_key_block_number_idx RENAME TO storage_leaf_key_block_number_index;
 -- state node indexes                                                 -- state node indexes
 ALTER INDEX eth.state_cids_i_code_hash_idx RENAME TO state_code_hash_index;
 ALTER INDEX eth.state_cids_i_removed_idx RENAME TO state_removed_index;
 ALTER INDEX eth.state_cids_i_header_id_idx RENAME TO state_header_id_index;
 ALTER INDEX eth.state_cids_i_cid_block_number_idx RENAME TO state_cid_block_number_index;
 ALTER INDEX eth.state_cids_i_block_number_idx RENAME TO state_block_number_index;
 ALTER INDEX eth.state_cids_i_state_leaf_key_block_number_idx RENAME TO state_leaf_key_block_number_index;
 -- receipt indexes                                                    -- receipt indexes
 ALTER INDEX eth.receipt_cids_i_contract_idx RENAME TO rct_contract_index;
 ALTER INDEX eth.receipt_cids_i_cid_block_number_idx RENAME TO rct_cid_block_number_index;
 ALTER INDEX eth.receipt_cids_i_header_id_idx RENAME TO rct_header_id_index;
 ALTER INDEX eth.receipt_cids_i_block_number_idx RENAME TO rct_block_number_index;
 -- transaction indexes                                                -- transaction indexes
 ALTER INDEX eth.transaction_cids_i_src_idx RENAME TO tx_src_index;
 ALTER INDEX eth.transaction_cids_i_dst_idx RENAME TO tx_dst_index;
 ALTER INDEX eth.transaction_cids_i_cid_block_number_idx RENAME TO tx_cid_block_number_index;
 ALTER INDEX eth.transaction_cids_i_header_id_idx RENAME TO tx_header_id_index;
 ALTER INDEX eth.transaction_cids_i_block_number_idx RENAME TO tx_block_number_index;
 -- uncle indexes                                                      -- uncle indexes
 ALTER INDEX eth.uncle_cids_i_block_number_idx RENAME TO uncle_block_number_index;
 ALTER INDEX eth.uncle_cids_i_cid_block_number_index_idx RENAME TO uncle_cid_block_number_index;
 ALTER INDEX eth.uncle_cids_i_header_id_idx RENAME TO uncle_header_id_index;
--- a/db/migrations/00021_create_eth_withdrawal_cids_table.sql
+++ b/db/migrations/00021_create_eth_withdrawal_cids_table.sql
@ -0,0 +1,16 @@
 -- +goose Up
 CREATE TABLE IF NOT EXISTS eth.withdrawal_cids (
    block_number    BIGINT NOT NULL,
    header_id       VARCHAR(66) NOT NULL,
    cid             TEXT NOT NULL,
    index           INTEGER NOT NULL,
    validator       INTEGER NOT NULL,
    address         VARCHAR(66) NOT NULL,
    amount          NUMERIC NOT NULL,
    PRIMARY KEY (index, header_id, block_number)
 );
 SELECT create_hypertable('eth.withdrawal_cids', 'block_number', migrate_data => true, chunk_time_interval => 32768);
 -- +goose Down
 DROP TABLE eth.withdrawal_cids;
--- a/db/migrations/00022_create_eth_blob_hash_cids_table.sql
+++ b/db/migrations/00022_create_eth_blob_hash_cids_table.sql
@ -0,0 +1,12 @@
 -- +goose Up
 CREATE TABLE eth.blob_hashes (
  tx_hash   VARCHAR(66) NOT NULL,
  index     INTEGER NOT NULL,
  blob_hash BYTEA NOT NULL
 );
 CREATE UNIQUE INDEX blob_hashes_tx_hash_index ON eth.blob_hashes(tx_hash, index);
 -- +goose Down
 DROP INDEX eth.blob_hashes_tx_hash_index;
 DROP TABLE eth.blob_hashes;
--- a/docker-compose.test.yml
+++ b/docker-compose.test.yml
@ -1,19 +0,0 @@
 version: '3.2'
 services:
  statediff-migrations:
    restart: on-failure
    depends_on:
      - test-db
    image: vulcanize/statediff-migrations:v0.9.0
  test-db:
    restart: always
    image: postgres:10.12-alpine
    command: ["postgres", "-c", "log_statement=all"]
    environment:
      POSTGRES_USER: "vdbm"
      POSTGRES_DB: "vulcanize_testing"
      POSTGRES_PASSWORD: "password"
    ports:
      - "127.0.0.1:8066:5432"
--- a/docker-compose.yml
+++ b/docker-compose.yml
@ -1,14 +0,0 @@
 version: '3.2'
 services:
  ipld-eth-db:
    restart: always
    image: vulcanize/ipld-eth-db
    build: .
    environment:
      POSTGRES_USER: "vdbm"
      POSTGRES_DB: "vulcanize_testing"
      POSTGRES_PASSWORD: "password"
      hostname: db
    ports:
      - "127.0.0.1:8077:5432"
--- a/schema.sql
+++ b/schema.sql
--- a/scripts/startup_script.sh
+++ b/scripts/startup_script.sh
@ -1,19 +1,14 @@
 #!/bin/sh
-# Runs the db migrations
+set -e
-set +x
+
 # Default command is "goose up"
 if [[ $# -eq 0 ]]; then
  set -- "up"
 fi
 # Construct the connection string for postgres
 VDB_PG_CONNECT=postgresql://$DATABASE_USER:$DATABASE_PASSWORD@$DATABASE_HOSTNAME:$DATABASE_PORT/$DATABASE_NAME?sslmode=disable
 # Run the DB migrations
-echo "Connecting with: $VDB_PG_CONNECT"
+set -x
-echo "Running database migrations"
+exec ./goose -dir migrations postgres "$VDB_PG_CONNECT" "$@"
 ./goose -dir migrations/vulcanizedb postgres "$VDB_PG_CONNECT" up
 # If the db migrations ran without err
 if [[ $? -eq 0 ]]; then
    echo "Migration process ran successfully"
 else
    echo "Could not run migrations. Are the database details correct?"
    exit 1
 fi
--- a/scripts/test_migration.sh
+++ b/scripts/test_migration.sh
@ -10,7 +10,7 @@ sleep 5s
 export HOST_NAME=localhost
 export PORT=8066
 export USER=vdbm
-export TEST_DB=vulcanize_testing
+export TEST_DB=cerc_testing
 export TEST_CONNECT_STRING=postgresql://$USER@$HOST_NAME:$PORT/$TEST_DB?sslmode=disable
 export PGPASSWORD=password
@ -54,4 +54,4 @@ do
    then
        exit 0
    fi
-done
+done
--- a/vulcanize_db.png
+++ b/vulcanize_db.png
--- a/vulcanize_db.uml
+++ b/vulcanize_db.uml
@ -1,150 +1,113 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <Diagram>
  <ID>DATABASE</ID>
-  <OriginalElement>763cb2dc-728a-4fbd-a163-94dd564429aa</OriginalElement>
+  <OriginalElement>86a0461b-ec84-4911-9aa2-e562b5d7b24c</OriginalElement>
  <nodes>
-    <node x="508.5625" y="998.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.receipt_cids</node>
+    <node x="561.75" y="152.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.header_cids</node>
-    <node x="227.705078125" y="1282.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.log_cids</node>
+    <node x="0.0" y="1439.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.public.goose_db_version</node>
-    <node x="256.5" y="1031.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.state_accounts</node>
+    <node x="1133.0" y="0.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.public.nodes</node>
-    <node x="156.705078125" y="712.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.state_cids</node>
+    <node x="203.25" y="1140.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.log_cids</node>
-    <node x="193.330078125" y="44.5">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.blocks</node>
+    <node x="729.5" y="603.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.uncle_cids</node>
-    <node x="10.5" y="1009.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.storage_cids</node>
+    <node x="467.25" y="0.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.ipld.blocks</node>
-    <node x="547.375" y="723.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.uncle_cids</node>
+    <node x="500.5" y="570.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.state_cids</node>
-    <node x="1146.375" y="0.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.goose_db_version</node>
+    <node x="1384.0" y="0.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth_meta.watched_addresses</node>
-    <node x="499.455078125" y="0.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.nodes</node>
+    <node x="660.6941964285713" y="878.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.storage_cids</node>
-    <node x="824.375" y="1042.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.access_list_element</node>
+    <node x="303.5" y="581.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.transaction_cids</node>
-    <node x="614.5" y="228.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.header_cids</node>
+    <node x="233.0" y="1439.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.public.db_version</node>
-    <node x="761.375" y="690.0">763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.transaction_cids</node>
+    <node x="251.5" y="889.0">86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.receipt_cids</node>
  </nodes>
  <notes />
  <edges>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.nodes" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.nodes" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.state_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.ipld.blocks" relationship="REFERENCES">
-      <point x="-76.5" y="83.0" />
+      <point x="-52.25" y="-127.0" />
-      <point x="575.955078125" y="151.63819095477388" />
+      <point x="552.75" y="538.0" />
-      <point x="532.3193997330402" y="151.63819095477388" />
+      <point x="551.25" y="538.0" />
-      <point x="532.3193997330402" y="83.0" />
+      <point x="0.0" y="50.0" />
      <point x="-153.0" y="0.0" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.uncle_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.header_cids" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.receipt_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.ipld.blocks" relationship="REFERENCES">
-      <point x="48.5" y="-94.0" />
+      <point x="-45.5" y="-94.0" />
-      <point x="692.875" y="668.0" />
+      <point x="297.0" y="851.0" />
-      <point x="756.0" y="668.0" />
+      <point x="293.0" y="851.0" />
-      <point x="0.0" y="204.0" />
+      <point x="293.0" y="126.0" />
      <point x="551.25" y="126.0" />
      <point x="0.0" y="50.0" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.storage_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.blocks" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.transaction_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.header_cids" relationship="REFERENCES">
-      <point x="-56.5" y="-105.0" />
+      <point x="44.25" y="-116.0" />
-      <point x="67.0" y="971.0" />
+      <point x="436.25" y="548.0" />
-      <point x="111.205078125" y="971.0" />
+      <point x="658.75" y="548.0" />
-      <point x="111.205078125" y="207.0" />
+      <point x="0.0" y="182.0" />
      <point x="502.875" y="207.0" />
      <point x="502.875" y="197.0" />
      <point x="269.080078125" y="197.0" />
      <point x="25.25" y="38.5" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.state_accounts" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.state_cids" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.log_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.receipt_cids" relationship="REFERENCES">
-      <point x="0.0" y="-83.0" />
+      <point x="44.25" y="-127.0" />
-      <point x="355.0" y="971.0" />
+      <point x="336.0" y="1114.0" />
-      <point x="261.205078125" y="971.0" />
+      <point x="342.5" y="1114.0" />
-      <point x="0.0" y="105.0" />
+      <point x="0.0" y="94.0" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.uncle_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.blocks" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.uncle_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.header_cids" relationship="REFERENCES">
      <point x="-48.5" y="-94.0" />
-      <point x="595.875" y="658.0" />
+      <point x="778.0" y="548.0" />
-      <point x="589.25" y="658.0" />
+      <point x="658.75" y="548.0" />
-      <point x="589.25" y="207.0" />
+      <point x="0.0" y="182.0" />
      <point x="502.875" y="207.0" />
      <point x="502.875" y="197.0" />
      <point x="269.080078125" y="197.0" />
      <point x="25.25" y="38.5" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.storage_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.state_cids" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.log_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.ipld.blocks" relationship="REFERENCES">
-      <point x="56.5" y="-105.0" />
+      <point x="-44.25" y="-127.0" />
-      <point x="180.0" y="971.0" />
+      <point x="247.5" y="1114.0" />
-      <point x="261.205078125" y="971.0" />
+      <point x="241.0" y="1114.0" />
-      <point x="0.0" y="105.0" />
+      <point x="241.0" y="126.0" />
      <point x="551.25" y="126.0" />
      <point x="0.0" y="50.0" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.log_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.receipt_cids" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.receipt_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.transaction_cids" relationship="REFERENCES">
-      <point x="41.0" y="-138.0" />
+      <point x="45.5" y="-94.0" />
-      <point x="350.705078125" y="1256.0" />
+      <point x="388.0" y="851.0" />
-      <point x="612.0625" y="1256.0" />
+      <point x="392.0" y="851.0" />
      <point x="0.0" y="116.0" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.header_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.blocks" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.state_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.header_cids" relationship="REFERENCES">
-      <point x="-70.75" y="-204.0" />
+      <point x="52.25" y="-127.0" />
-      <point x="685.25" y="207.0" />
+      <point x="657.25" y="548.0" />
-      <point x="502.875" y="207.0" />
+      <point x="658.75" y="548.0" />
-      <point x="502.875" y="197.0" />
+      <point x="0.0" y="182.0" />
      <point x="269.080078125" y="197.0" />
      <point x="25.25" y="38.5" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.state_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.header_cids" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.storage_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.state_cids" relationship="REFERENCES">
-      <point x="52.25" y="-105.0" />
+      <point x="-56.5" y="-105.0" />
-      <point x="313.455078125" y="668.0" />
+      <point x="717.1941964285713" y="851.0" />
-      <point x="756.0" y="668.0" />
+      <point x="605.0" y="851.0" />
      <point x="0.0" y="204.0" />
    </edge>
    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.receipt_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.transaction_cids" relationship="REFERENCES">
      <point x="51.75" y="-116.0" />
      <point x="663.8125" y="971.0" />
      <point x="931.375" y="971.0" />
      <point x="0.0" y="127.0" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.transaction_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.blocks" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.transaction_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.ipld.blocks" relationship="REFERENCES">
-      <point x="85.0" y="-127.0" />
+      <point x="-44.25" y="-116.0" />
-      <point x="1016.375" y="668.0" />
+      <point x="347.75" y="548.0" />
-      <point x="923.3125" y="668.0" />
+      <point x="391.1941964285714" y="548.0" />
-      <point x="923.3125" y="207.0" />
+      <point x="391.1941964285714" y="126.0" />
-      <point x="502.875" y="207.0" />
+      <point x="551.25" y="126.0" />
-      <point x="502.875" y="197.0" />
+      <point x="0.0" y="50.0" />
      <point x="269.080078125" y="197.0" />
      <point x="25.25" y="38.5" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.receipt_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.blocks" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.storage_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.ipld.blocks" relationship="REFERENCES">
-      <point x="-51.75" y="-116.0" />
+      <point x="56.5" y="-105.0" />
-      <point x="560.3125" y="971.0" />
+      <point x="830.1941964285713" y="851.0" />
-      <point x="497.625" y="971.0" />
+      <point x="934.0" y="851.0" />
-      <point x="497.625" y="207.0" />
+      <point x="934.0" y="126.0" />
-      <point x="502.875" y="207.0" />
+      <point x="551.25" y="126.0" />
-      <point x="502.875" y="197.0" />
+      <point x="0.0" y="50.0" />
      <point x="269.080078125" y="197.0" />
      <point x="25.25" y="38.5" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.log_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.blocks" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.uncle_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.ipld.blocks" relationship="REFERENCES">
-      <point x="-41.0" y="-138.0" />
+      <point x="48.5" y="-94.0" />
-      <point x="268.705078125" y="1256.0" />
+      <point x="875.0" y="548.0" />
-      <point x="0.0" y="1256.0" />
+      <point x="835.6941964285714" y="548.0" />
-      <point x="0.0" y="197.0" />
+      <point x="835.6941964285714" y="126.0" />
-      <point x="218.580078125" y="197.0" />
+      <point x="551.25" y="126.0" />
-      <point x="-25.25" y="38.5" />
+      <point x="0.0" y="50.0" />
    </edge>
-    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.transaction_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.header_cids" relationship="REFERENCES">
+    <edge source="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.eth.header_cids" target="86a0461b-ec84-4911-9aa2-e562b5d7b24c.TABLE:uml_diagram.ipld.blocks" relationship="REFERENCES">
-      <point x="-85.0" y="-127.0" />
+      <point x="0.0" y="-182.0" />
-      <point x="846.375" y="668.0" />
+      <point x="658.75" y="126.0" />
-      <point x="756.0" y="668.0" />
+      <point x="551.25" y="126.0" />
-      <point x="0.0" y="204.0" />
+      <point x="0.0" y="50.0" />
    </edge>
    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.state_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.blocks" relationship="REFERENCES">
      <point x="-52.25" y="-105.0" />
      <point x="208.955078125" y="668.0" />
      <point x="256.205078125" y="668.0" />
      <point x="256.205078125" y="207.0" />
      <point x="502.875" y="207.0" />
      <point x="502.875" y="197.0" />
      <point x="269.080078125" y="197.0" />
      <point x="25.25" y="38.5" />
    </edge>
    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.access_list_element" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.transaction_cids" relationship="REFERENCES">
      <point x="0.0" y="-72.0" />
      <point x="0.0" y="127.0" />
    </edge>
    <edge source="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.eth.header_cids" target="763cb2dc-728a-4fbd-a163-94dd564429aa.TABLE:vulcanize_testing.public.nodes" relationship="REFERENCES">
      <point x="70.75" y="-204.0" />
      <point x="826.75" y="197.0" />
      <point x="728.955078125" y="197.0" />
      <point x="76.5" y="83.0" />
    </edge>
  </edges>
-  <settings layout="Hierarchic" zoom="0.37832699619771865" showDependencies="false" x="667.5" y="779.0" />
+  <settings layout="Hierarchic" zoom="0.40290955091714103" showDependencies="false" x="793.0" y="780.5" />
  <SelectedNodes />
  <Categories>
    <Category>Columns</Category>