diff --git a/.dockerignore b/.dockerignore
index d6492c09d..3968d7088 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,5 +1,11 @@
+.git
+.vscode
+**/.env.local
+**/dfuse-transactions*.json
+**/dist
+**/node_modules
+**/state
 build
 build-dbg
 build-docker
-.vscode
-**/.env.local
+!build/eden-micro-chain.wasm
diff --git a/.github/ccache.conf b/.github/ccache.conf
new file mode 100644
index 000000000..64828568b
--- /dev/null
+++ b/.github/ccache.conf
@@ -0,0 +1,2 @@
+max_size = 600M
+log_file = /__w/Eden/Eden/ccache.log
diff --git a/.github/workflows/box.yml b/.github/workflows/box.yml
deleted file mode 100644
index 369b0e17d..000000000
--- a/.github/workflows/box.yml
+++ /dev/null
@@ -1,82 +0,0 @@
-name: box
-
-on:
-    push:
-        branches:
-            - main
-            - "test/*"
-    pull_request:
-        types: [assigned, opened, synchronize, reopened, labeled]
-        paths:
-            - "docker/eden-box.Dockerfile"
-            - ".eslintignore"
-            - ".eslintrc.js"
-            - ".prettierrc.json"
-            - "lerna.json"
-            - "packages/box/**"
-            - "package.json"
-            - "tsconfig.build.json"
-            - "tsconfig.json"
-            - "yarn.lock"
-
-jobs:
-    box-e2e:
-        name: Eden Box E2E Tests
-        runs-on: ubuntu-latest
-
-        steps:
-            - name: ✅ Checkout code
-              uses: actions/checkout@v2
-
-            - name: 🛠 Build and Start Box
-              run: |
-                  yarn
-                  yarn build --stream
-                  cd packages/box
-                  yarn start &
-
-            - name: 🧪 Run E2E
-              # TODO: add real E2E tests... for now it's just a shameless curl ping
-              run: |
-                  curl localhost:3032
-
-    box-build:
-        needs: box-e2e
-        name: Build Eden Box
-        runs-on: ubuntu-latest
-
-        steps:
-            - name: ✅ Checkout code
-              uses: actions/checkout@v2
-
-            - name: Image Preparation
-              id: prep
-              run: |
-                  REGISTRY="ghcr.io"
-                  IMAGE="${REGISTRY}/${{ github.repository_owner }}/eden-box"
-                  TAGS="${IMAGE}:${{ github.sha }}"
-                  if [[ $GITHUB_REF == ref/head/master ]]; then
-                    TAGS="${TAGS},${IMAGE}:latest"
-                  fi
-                  echo ::set-output name=tags::${TAGS,,}
-
-            - name: Showtag
-              id: showtag
-              run: echo ${{ steps.prep.outputs.tags }}
-
-            - name: Docker Buildx setup
-              uses: docker/setup-buildx-action@v1
-
-            - name: Login in to registry
-              uses: docker/login-action@v1
-              with:
-                  registry: ghcr.io
-                  username: ${{ github.repository_owner }}
-                  password: ${{ secrets.GITHUB_TOKEN }}
-
-            - name: 🛠 Build & Publish Image
-              uses: docker/build-push-action@v2
-              with:
-                  # push: true # TODO: follow up on this... https://github.community/t/403-error-on-container-registry-push-from-github-action/173071/5
-                  file: docker/eden-box.Dockerfile
-                  tags: ${{ steps.prep.outputs.tags }}
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 7d9c3cd88..4b731e131 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -1,4 +1,4 @@
-name: build eosio contracts
+name: Build
 
 on:
     push:
@@ -8,6 +8,9 @@ on:
     pull_request:
         types: [assigned, opened, synchronize, reopened, labeled]
         paths:
+            - ".github/workflows/build.yml"
+
+            # C++
             - "CMakeLists.txt"
             - "contracts/**"
             - "external/CMakeLists.txt"
@@ -15,19 +18,53 @@ on:
             - "native/**"
             - "programs/**"
             - "wasm/**"
-            - ".github/workflows/build.yml"
 
+            # box, webapp
+            - ".eslintignore"
+            - ".eslintrc.js"
+            - ".prettierrc.json"
+            - "lerna.json"
+            - "package.json"
+            - "packages/common/**"
+            - "tsconfig.build.json"
+            - "tsconfig.json"
+            - "yarn.lock"
+
+            # box
+            - "docker/eden-box.Dockerfile"
+            - "packages/box/**"
+
+            # webapp
+            - "docker/eden-webapp.Dockerfile"
+            - "packages/webapp/**"
 jobs:
-    build:
-        name: Build Eden Community Contracts and WASMs
+    build-cpp:
+        name: Build C++
         runs-on: ubuntu-latest
-        container: ghcr.io/eoscommunity/eden-builder:latest
+        container: ghcr.io/eoscommunity/eden-builder:sub-chain
 
         steps:
+            - uses: dorny/paths-filter@v2
+              id: filter
+              with:
+                  filters: |
+                      src:
+                        - ".github/workflows/build.yml"
+
+                        - "CMakeLists.txt"
+                        - "contracts/**"
+                        - "external/CMakeLists.txt"
+                        - "libraries/**"
+                        - "native/**"
+                        - "programs/**"
+                        - "wasm/**"
+
             - name: ✅ Checkout code
+              if: steps.filter.outputs.src == 'true'
               uses: actions/checkout@v2
 
             - name: Prepare ccache timestamp
+              if: steps.filter.outputs.src == 'true'
               id: ccache_cache_timestamp
               shell: cmake -P {0}
               run: |
@@ -35,21 +72,28 @@ jobs:
                   message("::set-output name=timestamp::${current_date}")
 
             - name: show_cache
+              if: steps.filter.outputs.src == 'true'
               id: show_cache
-              run: echo "${{ runner.os }}-ccache-${{ steps.ccache_cache_timestamp.outputs.timestamp }}"
+              run: echo "${{ runner.os }}-ccache_whole-${{ steps.ccache_cache_timestamp.outputs.timestamp }}"
 
             - name: ccache cache files
+              if: steps.filter.outputs.src == 'true'
               uses: actions/cache@v1.1.0
               with:
                   path: .ccache
-                  key: ${{ runner.os }}-ccache-${{ steps.ccache_cache_timestamp.outputs.timestamp }}
+                  key: ${{ runner.os }}-ccache_whole-${{ steps.ccache_cache_timestamp.outputs.timestamp }}
                   restore-keys: |
-                      ${{ runner.os }}-ccache-
+                      ${{ runner.os }}-ccache_whole-
 
             - name: 🛠 Build
+              if: steps.filter.outputs.src == 'true'
               run: |
                   set -e
                   export CCACHE_DIR=${GITHUB_WORKSPACE}/.ccache
+                  export CCACHE_CONFIGPATH=${GITHUB_WORKSPACE}/.github/ccache.conf
+                  echo =====
+                  pwd
+                  echo ${GITHUB_WORKSPACE}
                   echo =====
                   ccache -s
                   echo =====
@@ -62,14 +106,26 @@ jobs:
 
                   tar czf clsdk-ubuntu-20-04.tar.gz clsdk
 
+                  echo =====
+                  ls -la ${GITHUB_WORKSPACE}
                   echo =====
                   ccache -s
                   echo =====
 
             - name: 🧪 Run tests with CTest
+              if: steps.filter.outputs.src == 'true'
               run: cd build && ctest -j$(nproc) -V
 
+            - name: 📃 Upload ccache.log
+              if: steps.filter.outputs.src == 'true'
+              uses: actions/upload-artifact@v2
+              with:
+                  name: ccache_log
+                  path: |
+                      ccache.log
+
             - name: 📃 Upload clsdk
+              if: steps.filter.outputs.src == 'true'
               uses: actions/upload-artifact@v2
               with:
                   name: clsdk
@@ -77,9 +133,335 @@ jobs:
                       build/clsdk-ubuntu-20-04.tar.gz
 
             - name: 📃 Upload Eden Smart Contract
+              if: steps.filter.outputs.src == 'true'
               uses: actions/upload-artifact@v2
               with:
                   name: Eden Smart Contract
                   path: |
                       build/eden.abi
                       build/eden.wasm
+                      build/eden-micro-chain.wasm
+
+    build-micro-chain:
+        name: Build Micro Chain
+        runs-on: ubuntu-latest
+        container: ghcr.io/eoscommunity/eden-builder:sub-chain
+
+        steps:
+            - name: ✅ Checkout code
+              uses: actions/checkout@v2
+
+            - name: Prepare ccache timestamp
+              id: ccache_cache_timestamp
+              shell: cmake -P {0}
+              run: |
+                  string(TIMESTAMP current_date "%Y-%m-%d-%H-%M-%S" UTC)
+                  message("::set-output name=timestamp::${current_date}")
+
+            - name: show_cache
+              id: show_cache
+              run: echo "${{ runner.os }}-ccache_microchain-${{ steps.ccache_cache_timestamp.outputs.timestamp }}"
+
+            - name: ccache cache files
+              uses: actions/cache@v1.1.0
+              with:
+                  path: .ccache
+                  key: ${{ runner.os }}-ccache_microchain-${{ steps.ccache_cache_timestamp.outputs.timestamp }}
+                  restore-keys: |
+                      ${{ runner.os }}-ccache_microchain-
+
+            - name: 🛠 Build
+              run: |
+                  set -e
+                  export CCACHE_DIR=${GITHUB_WORKSPACE}/.ccache
+                  export CCACHE_CONFIGPATH=${GITHUB_WORKSPACE}/.github/ccache.conf
+                  echo =====
+                  pwd
+                  echo ${GITHUB_WORKSPACE}
+                  echo =====
+                  ccache -s
+                  echo =====
+
+                  git submodule update --init external/atomicassets-contract
+                  git submodule update --init external/Catch2
+                  git submodule update --init external/fmt
+                  git submodule update --init external/rapidjson
+                  mkdir build
+                  cd build
+                  cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_COMPILER_LAUNCHER=ccache -DCMAKE_C_COMPILER_LAUNCHER=ccache -DSKIP_TS=Yes -DEDEN_ATOMIC_ASSETS_ACCOUNT=atomicassets -DEDEN_ATOMIC_MARKET_ACCOUNT=atomicmarket -DEDEN_SCHEMA_NAME=members -DBUILD_NATIVE=OFF ..
+                  make -j$(nproc) wasm-configure
+                  bash -c "cd wasm && make -j$(nproc) eden-micro-chain"
+
+                  echo =====
+                  ls -la ${GITHUB_WORKSPACE}
+                  echo =====
+                  ccache -s
+                  echo =====
+
+            - name: 📃 Upload ccache.log
+              uses: actions/upload-artifact@v2
+              with:
+                  name: microchain_ccache_log
+                  path: |
+                      ccache.log
+
+            - name: 📃 Upload Eden Microchain
+              uses: actions/upload-artifact@v2
+              with:
+                  name: Eden Microchain
+                  path: |
+                      build/eden-micro-chain.wasm
+
+    box-e2e:
+        needs: build-micro-chain
+        name: Eden Box E2E Tests
+        runs-on: ubuntu-latest
+
+        steps:
+            - uses: dorny/paths-filter@v2
+              id: filter
+              with:
+                  filters: |
+                      src:
+                        - ".github/workflows/build.yml"
+
+                        - ".eslintignore"
+                        - ".eslintrc.js"
+                        - ".prettierrc.json"
+                        - "lerna.json"
+                        - "package.json"
+                        - "packages/common/**"
+                        - "tsconfig.build.json"
+                        - "tsconfig.json"
+                        - "yarn.lock"
+
+                        - "docker/eden-box.Dockerfile"
+                        - "packages/box/**"
+
+            - name: ✅ Checkout code
+              if: steps.filter.outputs.src == 'true'
+              uses: actions/checkout@v2
+
+            - name: Download Eden Microchain
+              if: steps.filter.outputs.src == 'true'
+              uses: actions/download-artifact@v2
+              with:
+                  name: Eden Microchain
+                  path: build
+
+            - name: 🛠 Build and Start Box
+              if: steps.filter.outputs.src == 'true'
+              run: |
+                  export SUBCHAIN_DFUSE_PREVENT_CONNECT=1
+                  yarn
+                  yarn build --stream
+                  cd packages/box
+                  yarn start &
+
+            - name: 🧪 Run E2E
+              if: steps.filter.outputs.src == 'true'
+              # TODO: add real E2E tests... for now it's just a shameless curl ping
+              run: |
+                  curl localhost:3032
+
+    box-build:
+        needs: build-micro-chain
+        name: Build Eden Box
+        runs-on: ubuntu-latest
+
+        steps:
+            - uses: dorny/paths-filter@v2
+              id: filter
+              with:
+                  filters: |
+                      src:
+                        - ".github/workflows/build.yml"
+
+                        - ".eslintignore"
+                        - ".eslintrc.js"
+                        - ".prettierrc.json"
+                        - "lerna.json"
+                        - "package.json"
+                        - "packages/common/**"
+                        - "tsconfig.build.json"
+                        - "tsconfig.json"
+                        - "yarn.lock"
+
+                        - "docker/eden-box.Dockerfile"
+                        - "packages/box/**"
+
+            - name: ✅ Checkout code
+              if: steps.filter.outputs.src == 'true'
+              uses: actions/checkout@v2
+
+            - name: Download Eden Microchain
+              if: steps.filter.outputs.src == 'true'
+              uses: actions/download-artifact@v2
+              with:
+                  name: Eden Microchain
+                  path: build
+
+            - name: Image Preparation
+              if: steps.filter.outputs.src == 'true'
+              id: prep
+              run: |
+                  REGISTRY="ghcr.io"
+                  IMAGE="${REGISTRY}/${{ github.repository_owner }}/eden-box"
+                  TAGS="${IMAGE}:${{ github.sha }}"
+                  if [[ $GITHUB_REF == ref/head/master ]]; then
+                    TAGS="${TAGS},${IMAGE}:latest"
+                  fi
+                  echo ::set-output name=tags::${TAGS,,}
+
+            - name: Showtag
+              if: steps.filter.outputs.src == 'true'
+              id: showtag
+              run: echo ${{ steps.prep.outputs.tags }}
+
+            - name: Docker Buildx setup
+              if: steps.filter.outputs.src == 'true'
+              uses: docker/setup-buildx-action@v1
+
+            - name: Login in to registry
+              if: steps.filter.outputs.src == 'true'
+              uses: docker/login-action@v1
+              with:
+                  registry: ghcr.io
+                  username: ${{ github.repository_owner }}
+                  password: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: 🛠 Build & Publish Image
+              if: steps.filter.outputs.src == 'true'
+              uses: docker/build-push-action@v2
+              with:
+                  push: true
+                  file: docker/eden-box.Dockerfile
+                  tags: ${{ steps.prep.outputs.tags }}
+                  context: .
+
+    webapp-e2e:
+        needs: build-micro-chain
+        name: WebApp E2E Tests
+        runs-on: ubuntu-latest
+
+        steps:
+            - uses: dorny/paths-filter@v2
+              id: filter
+              with:
+                  filters: |
+                      src:
+                        - ".github/workflows/build.yml"
+
+                        - ".eslintignore"
+                        - ".eslintrc.js"
+                        - ".prettierrc.json"
+                        - "lerna.json"
+                        - "package.json"
+                        - "packages/common/**"
+                        - "tsconfig.build.json"
+                        - "tsconfig.json"
+                        - "yarn.lock"
+
+                        - "docker/eden-webapp.Dockerfile"
+                        - "packages/webapp/**"
+
+            - name: ✅ Checkout code
+              if: steps.filter.outputs.src == 'true'
+              uses: actions/checkout@v2
+
+            - name: Download Eden Microchain
+              if: steps.filter.outputs.src == 'true'
+              uses: actions/download-artifact@v2
+              with:
+                  name: Eden Microchain
+                  path: build
+
+            - name: 🛠 Build and Start WebApp
+              if: steps.filter.outputs.src == 'true'
+              run: |
+                  export SUBCHAIN_DFUSE_PREVENT_CONNECT=1
+                  yarn
+                  yarn build --stream --ignore @edenos/example-history-app
+                  yarn start --stream --ignore @edenos/example-history-app &
+
+            - name: 🧪 Run E2E
+              if: steps.filter.outputs.src == 'true'
+              run: |
+                  yarn test --stream
+
+            - name: 🎥 Upload Cypress Results
+              if: always() && steps.filter.outputs.src == 'true'
+              uses: actions/upload-artifact@v2
+              with:
+                  name: Cypress E2E Videos and Screenshots
+                  path: |
+                      packages/webapp/cypress/screenshots
+                      packages/webapp/cypress/videos
+
+    webapp-build:
+        needs: build-micro-chain
+        name: Build Eden Community WebApp
+        runs-on: ubuntu-latest
+
+        steps:
+            - uses: dorny/paths-filter@v2
+              id: filter
+              with:
+                  filters: |
+                      src:
+                        - ".github/workflows/build.yml"
+
+                        - ".eslintignore"
+                        - ".eslintrc.js"
+                        - ".prettierrc.json"
+                        - "lerna.json"
+                        - "package.json"
+                        - "packages/common/**"
+                        - "tsconfig.build.json"
+                        - "tsconfig.json"
+                        - "yarn.lock"
+
+                        - "docker/eden-webapp.Dockerfile"
+                        - "packages/webapp/**"
+
+            - name: ✅ Checkout code
+              if: steps.filter.outputs.src == 'true'
+              uses: actions/checkout@v2
+
+            - name: Image Preparation
+              if: steps.filter.outputs.src == 'true'
+              id: prep
+              run: |
+                  REGISTRY="ghcr.io"
+                  IMAGE="${REGISTRY}/${{ github.repository_owner }}/eden-webapp"
+                  TAGS="${IMAGE}:${{ github.sha }}"
+                  if [[ $GITHUB_REF == ref/head/master ]]; then
+                    TAGS="${TAGS},${IMAGE}:latest"
+                  fi
+                  echo ::set-output name=tags::${TAGS,,}
+
+            - name: Showtag
+              if: steps.filter.outputs.src == 'true'
+              id: showtag
+              run: echo ${{ steps.prep.outputs.tags }}
+
+            - name: Docker Buildx setup
+              if: steps.filter.outputs.src == 'true'
+              uses: docker/setup-buildx-action@v1
+
+            - name: Login in to registry
+              if: steps.filter.outputs.src == 'true'
+              uses: docker/login-action@v1
+              with:
+                  registry: ghcr.io
+                  username: ${{ github.repository_owner }}
+                  password: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: 🛠 Build & Publish Image
+              if: steps.filter.outputs.src == 'true'
+              uses: docker/build-push-action@v2
+              with:
+                  push: true
+                  file: docker/eden-webapp.Dockerfile
+                  tags: ${{ steps.prep.outputs.tags }}
+                  context: .
diff --git a/.github/workflows/eden-builder.yml b/.github/workflows/eden-builder.yml
index a345fd78f..e767847e8 100644
--- a/.github/workflows/eden-builder.yml
+++ b/.github/workflows/eden-builder.yml
@@ -36,22 +36,21 @@ jobs:
               id: showtag
               run: echo ${{ steps.prep.outputs.tags }}
 
-            # TODO: follow up on this... https://github.community/t/403-error-on-container-registry-push-from-github-action/173071/5
-            # - name: Docker Buildx setup
-            #   uses: docker/setup-buildx-action@v1
-            #   with:
-            #       buildkitd-flags: --debug
-
-            # - name: Login in to registry
-            #   uses: docker/login-action@v1
-            #   with:
-            #       registry: ghcr.io
-            #       username: ${{ github.repository_owner }}
-            #       password: ${{ secrets.GITHUB_TOKEN }}
-
-            # - name: 🛠 Build & Publish Image
-            #   uses: docker/build-push-action@v2
-            #   with:
-            #       push: true
-            #       file: docker/eden-builder.Dockerfile
-            #       tags: ${{ steps.prep.outputs.tags }}
+            - name: Docker Buildx setup
+              uses: docker/setup-buildx-action@v1
+              with:
+                  buildkitd-flags: --debug
+
+            - name: Login in to registry
+              uses: docker/login-action@v1
+              with:
+                  registry: ghcr.io
+                  username: ${{ github.repository_owner }}
+                  password: ${{ secrets.GITHUB_TOKEN }}
+
+            - name: 🛠 Build & Publish Image
+              uses: docker/build-push-action@v2
+              with:
+                  push: true
+                  file: docker/eden-builder.Dockerfile
+                  tags: ${{ steps.prep.outputs.tags }}
diff --git a/.github/workflows/webapp.yml b/.github/workflows/webapp.yml
deleted file mode 100644
index bf0f9ecf5..000000000
--- a/.github/workflows/webapp.yml
+++ /dev/null
@@ -1,89 +0,0 @@
-name: webapp
-
-on:
-    push:
-        branches:
-            - main
-            - "test/*"
-    pull_request:
-        types: [assigned, opened, synchronize, reopened, labeled]
-        paths:
-            - "docker/eden-webapp.Dockerfile"
-            - ".eslintignore"
-            - ".eslintrc.js"
-            - ".prettierrc.json"
-            - "lerna.json"
-            - "packages/webapp/**"
-            - "package.json"
-            - "tsconfig.build.json"
-            - "tsconfig.json"
-            - "yarn.lock"
-
-jobs:
-    webapp-e2e:
-        name: WebApp E2E Tests
-        runs-on: ubuntu-latest
-
-        steps:
-            - name: ✅ Checkout code
-              uses: actions/checkout@v2
-
-            - name: 🛠 Build and Start WebApp
-              run: |
-                  yarn
-                  yarn build --stream
-                  yarn start --stream &
-
-            - name: 🧪 Run E2E
-              run: |
-                  yarn test --stream
-
-            - name: 🎥 Upload Cypress Results
-              uses: actions/upload-artifact@v2
-              if: always()
-              with:
-                  name: Cypress E2E Videos and Screenshots
-                  path: |
-                      packages/webapp/cypress/screenshots
-                      packages/webapp/cypress/videos
-
-    webapp-build:
-        needs: webapp-e2e
-        name: Build Eden Community WebApp
-        runs-on: ubuntu-latest
-
-        steps:
-            - name: ✅ Checkout code
-              uses: actions/checkout@v2
-
-            - name: Image Preparation
-              id: prep
-              run: |
-                  REGISTRY="ghcr.io"
-                  IMAGE="${REGISTRY}/${{ github.repository_owner }}/eden-webapp"
-                  TAGS="${IMAGE}:${{ github.sha }}"
-                  if [[ $GITHUB_REF == ref/head/master ]]; then
-                    TAGS="${TAGS},${IMAGE}:latest"
-                  fi
-                  echo ::set-output name=tags::${TAGS,,}
-
-            - name: Showtag
-              id: showtag
-              run: echo ${{ steps.prep.outputs.tags }}
-
-            - name: Docker Buildx setup
-              uses: docker/setup-buildx-action@v1
-
-            - name: Login in to registry
-              uses: docker/login-action@v1
-              with:
-                  registry: ghcr.io
-                  username: ${{ github.repository_owner }}
-                  password: ${{ secrets.GITHUB_TOKEN }}
-
-            - name: 🛠 Build & Publish Image
-              uses: docker/build-push-action@v2
-              with:
-                  # push: true # TODO: follow up on this... https://github.community/t/403-error-on-container-registry-push-from-github-action/173071/5
-                  file: docker/eden-webapp.Dockerfile
-                  tags: ${{ steps.prep.outputs.tags }}
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 69d5b7399..9ba09da1e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -12,10 +12,13 @@ endif()
 
 file(WRITE ${CMAKE_BINARY_DIR}/CTestTestfile.cmake)
 
+set(DEPEND_TESTER "")
+
 option(BUILD_NATIVE "Build native code" ON)
 if(BUILD_NATIVE)
     add_subdirectory(native)
     file(APPEND ${CMAKE_BINARY_DIR}/CTestTestfile.cmake "subdirs(\"native\")\n")
+    set(DEPEND_TESTER cltester)
 endif()
 
 if(DEFINED WASI_SDK_PREFIX)
@@ -26,13 +29,15 @@ if(DEFINED WASI_SDK_PREFIX)
 
     ExternalProject_Add(wasm
         SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/wasm
-        DEPENDS cltester # for abi generation
+        DEPENDS ${DEPEND_TESTER} # for abi generation
         BINARY_DIR wasm
         INSTALL_COMMAND ""
         BUILD_ALWAYS 1
         TEST_EXCLUDE_FROM_MAIN 1
+        STEP_TARGETS configure
         CMAKE_ARGS
             -DCMAKE_BUILD_TYPE=
+            -DCMAKE_TARGET_MESSAGES=${CMAKE_TARGET_MESSAGES}
             -DCMAKE_TOOLCHAIN_FILE=${CMAKE_CURRENT_SOURCE_DIR}/wasm/toolchain.cmake
             -DWASI_SDK_PREFIX=${WASI_SDK_PREFIX}
             -DWASM_CLANG_PREFIX=${WASM_CLANG_PREFIX}
@@ -45,6 +50,8 @@ if(DEFINED WASI_SDK_PREFIX)
             -DFORCE_COLORED_OUTPUT=${FORCE_COLORED_OUTPUT}
             -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
             -DCMAKE_CXX_COMPILER_LAUNCHER=${CMAKE_CXX_COMPILER_LAUNCHER}
+            -DCMAKE_FIND_ROOT_PATH=${CMAKE_CURRENT_BINARY_DIR}/wasm/deps
+            -DCMAKE_PREFIX_PATH=/
     )
     file(APPEND ${CMAKE_BINARY_DIR}/CTestTestfile.cmake "subdirs(\"wasm\")\n")
     ExternalProject_Add_StepTargets(wasm test)
diff --git a/README.md b/README.md
index a5f6e540e..4a20985d4 100644
--- a/README.md
+++ b/README.md
@@ -42,7 +42,9 @@ sudo apt-get install -yq    \
     git                     \
     libboost-all-dev        \
     libcurl4-openssl-dev    \
+    libgbm-dev              \
     libgmp-dev              \
+    libnss3-dev             \
     libssl-dev              \
     libusb-1.0-0-dev        \
     pkg-config              \
diff --git a/contracts/eden/CMakeLists.txt b/contracts/eden/CMakeLists.txt
index f74d38dcd..07fcf341c 100644
--- a/contracts/eden/CMakeLists.txt
+++ b/contracts/eden/CMakeLists.txt
@@ -52,3 +52,29 @@ endfunction()
 add_test_eden("")
 add_test_eden("-debug")
 eden_tester_test(test-eden)
+
+function(add_eden_microchain suffix)
+    add_executable(eden-micro-chain${suffix}
+        src/eden-micro-chain.cpp
+    )
+    target_link_libraries(eden-micro-chain${suffix} clchain${suffix} eosio-contracts-wasi-polyfill${suffix})
+    target_include_directories(eden-micro-chain${suffix} PRIVATE
+        include
+        ../../libraries/eosiolib/contracts/include
+        ../../libraries/eosiolib/core/include
+    )
+    set_target_properties(eden-micro-chain${suffix} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${ROOT_BINARY_DIR})
+    target_link_options(eden-micro-chain${suffix} PRIVATE
+        -Wl,--stack-first
+        -Wl,--no-entry
+        -Wl,-z,stack-size=8192
+        -nostdlib
+        -lc++
+        -lc++abi
+        -lc
+        ${WASI_SDK_PREFIX}/lib/clang/11.0.0/lib/wasi/libclang_rt.builtins-wasm32.a
+    )
+    add_dependencies(eden-micro-chain${suffix} eden)
+endfunction()
+add_eden_microchain("")
+# add_eden_microchain("-debug")
diff --git a/contracts/eden/src/eden-micro-chain.cpp b/contracts/eden/src/eden-micro-chain.cpp
new file mode 100644
index 000000000..cf563dcb6
--- /dev/null
+++ b/contracts/eden/src/eden-micro-chain.cpp
@@ -0,0 +1,598 @@
+#include <boost/multi_index/key.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index_container.hpp>
+#include <chainbase/chainbase.hpp>
+#include <clchain/crypto.hpp>
+#include <clchain/graphql_connection.hpp>
+#include <clchain/subchain.hpp>
+#include <eden.hpp>
+#include <eosio/from_bin.hpp>
+#include <eosio/to_bin.hpp>
+
+using namespace eosio::literals;
+
+eosio::name eden_account;
+eosio::name token_account;
+eosio::name atomic_account;
+eosio::name atomicmarket_account;
+
+// TODO: switch to uint64_t (js BigInt) after we upgrade to nodejs >= 15
+extern "C" void __wasm_call_ctors();
+[[clang::export_name("initialize")]] void initialize(uint32_t eden_account_low,
+                                                     uint32_t eden_account_high,
+                                                     uint32_t token_account_low,
+                                                     uint32_t token_account_high,
+                                                     uint32_t atomic_account_low,
+                                                     uint32_t atomic_account_high,
+                                                     uint32_t atomicmarket_account_low,
+                                                     uint32_t atomicmarket_account_high)
+{
+   __wasm_call_ctors();
+   eden_account.value = (uint64_t(eden_account_high) << 32) | eden_account_low;
+   token_account.value = (uint64_t(token_account_high) << 32) | token_account_low;
+   atomic_account.value = (uint64_t(atomic_account_high) << 32) | atomic_account_low;
+   atomicmarket_account.value =
+       (uint64_t(atomicmarket_account_high) << 32) | atomicmarket_account_low;
+}
+
+[[clang::export_name("allocateMemory")]] void* allocateMemory(uint32_t size)
+{
+   return malloc(size);
+}
+[[clang::export_name("freeMemory")]] void freeMemory(void* p)
+{
+   free(p);
+}
+
+std::variant<std::string, std::vector<char>> result;
+[[clang::export_name("getResultSize")]] uint32_t getResultSize()
+{
+   return std::visit([](auto& data) { return data.size(); }, result);
+}
+[[clang::export_name("getResult")]] const char* getResult()
+{
+   return std::visit([](auto& data) { return data.data(); }, result);
+}
+
+template <typename T>
+void dump(const T& ind)
+{
+   printf("%s\n", eosio::format_json(ind).c_str());
+}
+
+namespace boost
+{
+   BOOST_NORETURN void throw_exception(std::exception const& e)
+   {
+      eosio::detail::assert_or_throw(e.what());
+   }
+   BOOST_NORETURN void throw_exception(std::exception const& e, boost::source_location const& loc)
+   {
+      eosio::detail::assert_or_throw(e.what());
+   }
+}  // namespace boost
+
+struct by_id;
+struct by_pk;
+struct by_invitee;
+
+template <typename T, typename... Indexes>
+using mic = boost::
+    multi_index_container<T, boost::multi_index::indexed_by<Indexes...>, chainbase::allocator<T>>;
+
+template <typename T>
+using ordered_by_id = boost::multi_index::ordered_unique<  //
+    boost::multi_index::tag<by_id>,
+    boost::multi_index::key<&T::id>>;
+
+template <typename T>
+using ordered_by_pk = boost::multi_index::ordered_unique<  //
+    boost::multi_index::tag<by_pk>,
+    boost::multi_index::key<&T::pk>>;
+
+template <typename T>
+using ordered_by_invitee = boost::multi_index::ordered_unique<  //
+    boost::multi_index::tag<by_invitee>,
+    boost::multi_index::key<&T::invitee>>;
+
+uint64_t available_pk(const auto& table, const auto& first)
+{
+   auto& idx = table.template get<by_pk>();
+   if (idx.empty())
+      return first;
+   return (--idx.end())->pk() + 1;
+}
+
+enum tables
+{
+   status_table,
+   induction_table,
+   member_table,
+};
+
+struct status
+{
+   bool active = false;
+   std::string community;
+   eosio::symbol communitySymbol;
+   eosio::asset minimumDonation;
+   std::vector<eosio::name> initialMembers;
+   std::string genesisVideo;
+   eden::atomicassets::attribute_map collectionAttributes;
+   eosio::asset auctionStartingBid;
+   uint32_t auctionDuration;
+   std::string memo;
+};
+EOSIO_REFLECT(status,
+              active,
+              community,
+              communitySymbol,
+              minimumDonation,
+              initialMembers,
+              genesisVideo,
+              collectionAttributes,
+              auctionStartingBid,
+              auctionDuration,
+              memo)
+
+struct status_object : public chainbase::object<status_table, status_object>
+{
+   CHAINBASE_DEFAULT_CONSTRUCTOR(status_object)
+
+   id_type id;
+   status status;
+};
+using status_index = mic<status_object, ordered_by_id<status_object>>;
+
+struct induction
+{
+   uint64_t id = 0;
+   eosio::name inviter;
+   eosio::name invitee;
+   std::vector<eosio::name> witnesses;
+   eden::new_member_profile profile;
+   std::string video;
+};
+EOSIO_REFLECT(induction, id, inviter, invitee, witnesses, profile, video)
+
+struct induction_object : public chainbase::object<induction_table, induction_object>
+{
+   CHAINBASE_DEFAULT_CONSTRUCTOR(induction_object)
+
+   id_type id;
+   induction induction;
+
+   uint64_t pk() const { return induction.id; }
+   std::pair<eosio::name, uint64_t> invitee() const { return {induction.invitee, induction.id}; }
+};
+using induction_index = mic<induction_object,
+                            ordered_by_id<induction_object>,
+                            ordered_by_pk<induction_object>,
+                            ordered_by_invitee<induction_object>>;
+
+struct member
+{
+   eosio::name account;
+   eosio::name inviter;
+   std::vector<eosio::name> inductionWitnesses;
+   eden::new_member_profile profile;
+   std::string inductionVideo;
+};
+EOSIO_REFLECT(member, account, inviter, inductionWitnesses, profile, inductionVideo)
+
+struct member_object : public chainbase::object<member_table, member_object>
+{
+   CHAINBASE_DEFAULT_CONSTRUCTOR(member_object)
+
+   id_type id;
+   member member;
+
+   eosio::name pk() const { return member.account; }
+};
+using member_index = mic<member_object, ordered_by_id<member_object>, ordered_by_pk<member_object>>;
+
+struct database
+{
+   chainbase::database db;
+   chainbase::generic_index<status_index> status;
+   chainbase::generic_index<induction_index> inductions;
+   chainbase::generic_index<member_index> members;
+
+   database()
+   {
+      db.add_index(status);
+      db.add_index(inductions);
+      db.add_index(members);
+   }
+};
+database db;
+
+template <typename Tag, typename Table, typename Key, typename F>
+void add_or_modify(Table& table, const Key& key, F&& f)
+{
+   auto& idx = table.template get<Tag>();
+   auto it = idx.find(key);
+   if (it != idx.end())
+      table.modify(*it, [&](auto& obj) { return f(false, obj); });
+   else
+      table.emplace([&](auto& obj) { return f(true, obj); });
+}
+
+template <typename Tag, typename Table, typename Key, typename F>
+void add_or_replace(Table& table, const Key& key, F&& f)
+{
+   auto& idx = table.template get<Tag>();
+   auto it = idx.find(key);
+   if (it != idx.end())
+      table.remove(*it);
+   table.emplace(f);
+}
+
+template <typename Tag, typename Table, typename Key, typename F>
+void modify(Table& table, const Key& key, F&& f)
+{
+   auto& idx = table.template get<Tag>();
+   auto it = idx.find(key);
+   eosio::check(it != idx.end(), "missing record");
+   table.modify(*it, [&](auto& obj) { return f(obj); });
+}
+
+template <typename Tag, typename Table, typename Key>
+void remove_if_exists(Table& table, const Key& key)
+{
+   auto& idx = table.template get<Tag>();
+   auto it = idx.find(key);
+   if (it != idx.end())
+      table.remove(*it);
+}
+
+template <typename Tag, typename Table, typename Key>
+const auto& get(Table& table, const Key& key)
+{
+   auto& idx = table.template get<Tag>();
+   auto it = idx.find(key);
+   eosio::check(it != idx.end(), "missing record");
+   return *it;
+}
+
+const auto& get_status()
+{
+   auto& idx = db.status.get<by_id>();
+   eosio::check(idx.size() == 1, "missing genesis action");
+   return *idx.begin();
+}
+
+void add_genesis_member(const status& status, eosio::name member)
+{
+   db.inductions.emplace([&](auto& obj) {
+      obj.induction.id = available_pk(db.inductions, 1);
+      obj.induction.inviter = eden_account;
+      obj.induction.invitee = member;
+      for (auto witness : status.initialMembers)
+         if (witness != member)
+            obj.induction.witnesses.push_back(witness);
+   });
+}
+
+void clearall(auto& table)
+{
+   for (auto it = table.begin(); it != table.end();)
+   {
+      auto next = it;
+      ++next;
+      table.remove(*it);
+      it = next;
+   }
+}
+
+void clearall()
+{
+   clearall(db.status);
+   clearall(db.inductions);
+   clearall(db.members);
+}
+
+void genesis(std::string community,
+             eosio::symbol community_symbol,
+             eosio::asset minimum_donation,
+             std::vector<eosio::name> initial_members,
+             std::string genesis_video,
+             eden::atomicassets::attribute_map collection_attributes,
+             eosio::asset auction_starting_bid,
+             uint32_t auction_duration,
+             std::string memo)
+{
+   auto& idx = db.status.get<by_id>();
+   eosio::check(idx.empty(), "duplicate genesis action");
+   db.status.emplace([&](auto& obj) {
+      obj.status.community = std::move(community);
+      obj.status.communitySymbol = std::move(community_symbol);
+      obj.status.minimumDonation = std::move(minimum_donation);
+      obj.status.initialMembers = std::move(initial_members);
+      obj.status.genesisVideo = std::move(genesis_video);
+      obj.status.collectionAttributes = std::move(collection_attributes);
+      obj.status.auctionStartingBid = std::move(auction_starting_bid);
+      obj.status.auctionDuration = std::move(auction_duration);
+      obj.status.memo = std::move(memo);
+      for (auto& member : obj.status.initialMembers)
+         add_genesis_member(obj.status, member);
+   });
+}
+
+void addtogenesis(eosio::name new_genesis_member)
+{
+   auto& status = get_status();
+   db.status.modify(get_status(),
+                    [&](auto& obj) { obj.status.initialMembers.push_back(new_genesis_member); });
+   for (auto& obj : db.inductions)
+      db.inductions.modify(
+          obj, [&](auto& obj) { obj.induction.witnesses.push_back(new_genesis_member); });
+   add_genesis_member(status.status, new_genesis_member);
+}
+
+void inductinit(uint64_t id,
+                eosio::name inviter,
+                eosio::name invitee,
+                std::vector<eosio::name> witnesses)
+{
+   // TODO: expire records
+
+   // contract doesn't allow inductinit() until it transitioned to active
+   const auto& status = get_status();
+   if (!status.status.active)
+      db.status.modify(status, [&](auto& obj) { obj.status.active = true; });
+
+   add_or_replace<by_pk>(db.inductions, id, [&](auto& obj) {
+      obj.induction.id = id;
+      obj.induction.inviter = inviter;
+      obj.induction.invitee = invitee;
+      obj.induction.witnesses = witnesses;
+   });
+}
+
+void inductprofil(uint64_t id, eden::new_member_profile profile)
+{
+   modify<by_pk>(db.inductions, id, [&](auto& obj) { obj.induction.profile = profile; });
+}
+
+void inductvideo(eosio::name account, uint64_t id, std::string video)
+{
+   modify<by_pk>(db.inductions, id, [&](auto& obj) { obj.induction.video = video; });
+}
+
+void inductcancel(eosio::name account, uint64_t id)
+{
+   remove_if_exists<by_pk>(db.inductions, id);
+}
+
+void inductdonate(eosio::name payer, uint64_t id, eosio::asset quantity)
+{
+   auto& induction = get<by_pk>(db.inductions, id);
+   auto& member = db.members.emplace([&](auto& obj) {
+      obj.member.account = induction.induction.invitee;
+      obj.member.inviter = induction.induction.inviter;
+      obj.member.inductionWitnesses = induction.induction.witnesses;
+      obj.member.profile = induction.induction.profile;
+      obj.member.inductionVideo = induction.induction.video;
+   });
+
+   auto& index = db.inductions.get<by_invitee>();
+   for (auto it = index.lower_bound(std::pair<eosio::name, uint64_t>{member.member.account, 0});
+        it != index.end() && it->induction.invitee == member.member.account;)
+   {
+      auto next = it;
+      ++next;
+      db.inductions.remove(*it);
+      it = next;
+   }
+}
+
+template <typename... Args>
+void call(void (*f)(Args...), const std::vector<char>& data)
+{
+   std::tuple<eosio::remove_cvref_t<Args>...> t;
+   eosio::input_stream s(data);
+   // TODO: prevent abort, indicate what failed
+   eosio::from_bin(t, s);
+   std::apply([f](auto&&... args) { f(std::move(args)...); }, t);
+}
+
+void filter_block(const subchain::eosio_block& block)
+{
+   for (auto& trx : block.transactions)
+   {
+      for (auto& action : trx.actions)
+      {
+         if (action.firstReceiver == eden_account)
+         {
+            if (action.name == "clearall"_n)
+               call(clearall, action.hexData.data);
+            else if (action.name == "genesis"_n)
+               call(genesis, action.hexData.data);
+            else if (action.name == "addtogenesis"_n)
+               call(addtogenesis, action.hexData.data);
+            else if (action.name == "inductinit"_n)
+               call(inductinit, action.hexData.data);
+            else if (action.name == "inductprofil"_n)
+               call(inductprofil, action.hexData.data);
+            else if (action.name == "inductvideo"_n)
+               call(inductvideo, action.hexData.data);
+            else if (action.name == "inductcancel"_n)
+               call(inductcancel, action.hexData.data);
+            else if (action.name == "inductdonate"_n)
+               call(inductdonate, action.hexData.data);
+         }
+      }
+   }
+}
+
+subchain::block_log block_log;
+
+void forked_n_blocks(size_t n)
+{
+   if (n)
+      printf("forked %d blocks, %d now in log\n", (int)n, (int)block_log.blocks.size());
+   while (n--)
+      db.db.undo();
+}
+
+bool add_block(subchain::block_with_id&& bi, uint32_t eosio_irreversible)
+{
+   auto [status, num_forked] = block_log.add_block(bi);
+   if (status)
+      return false;
+   forked_n_blocks(num_forked);
+   if (auto* b = block_log.block_before_eosio_num(eosio_irreversible + 1))
+      block_log.irreversible = std::max(block_log.irreversible, b->num);
+   db.db.commit(block_log.irreversible);
+   bool need_undo = bi.num > block_log.irreversible;
+   auto session = db.db.start_undo_session(bi.num > block_log.irreversible);
+   filter_block(bi.eosioBlock);
+   session.push();
+   if (!need_undo)
+      db.db.set_revision(bi.num);
+   // printf("%s block: %d %d log: %d irreversible: %d db: %d-%d %s\n", block_log.status_str[status],
+   //        (int)bi.eosioBlock.num, (int)bi.num, (int)block_log.blocks.size(),
+   //        block_log.irreversible,  //
+   //        (int)db.db.undo_stack_revision_range().first,
+   //        (int)db.db.undo_stack_revision_range().second,  //
+   //        to_string(bi.eosioBlock.id).c_str());
+   return true;
+}
+
+bool add_block(subchain::block&& eden_block, uint32_t eosio_irreversible)
+{
+   auto bin = eosio::convert_to_bin(eden_block);
+   subchain::block_with_id bi;
+   static_cast<subchain::block&>(bi) = std::move(eden_block);
+   bi.id = clchain::sha256(bin.data(), bin.size());
+   auto bin_with_id = eosio::convert_to_bin(bi.id);
+   bin_with_id.insert(bin_with_id.end(), bin.begin(), bin.end());
+   result = std::move(bin_with_id);
+   return add_block(std::move(bi), eosio_irreversible);
+}
+
+// TODO: prevent from_json from aborting
+[[clang::export_name("addEosioBlockJson")]] bool addEosioBlockJson(const char* json,
+                                                                   uint32_t size,
+                                                                   uint32_t eosio_irreversible)
+{
+   std::string str(json, size);
+   eosio::json_token_stream s(str.data());
+   subchain::eosio_block eosio_block;
+   eosio::from_json(eosio_block, s);
+
+   subchain::block eden_block;
+   eden_block.eosioBlock = std::move(eosio_block);
+   auto* prev = block_log.block_before_eosio_num(eden_block.eosioBlock.num);
+   if (prev)
+   {
+      eden_block.num = prev->num + 1;
+      eden_block.previous = prev->id;
+   }
+   else
+      eden_block.num = 1;
+   return add_block(std::move(eden_block), eosio_irreversible);
+
+   // printf("%d blocks processed, %d blocks now in log\n", (int)eosio_blocks.size(),
+   //        (int)block_log.blocks.size());
+   // for (auto& b : block_log.blocks)
+   //    printf("%d\n", (int)b->num);
+}
+
+// TODO: prevent from_bin from aborting
+[[clang::export_name("addBlock")]] bool addBlock(const char* data,
+                                                 uint32_t size,
+                                                 uint32_t eosio_irreversible)
+{
+   // TODO: verify id integrity
+   eosio::input_stream bin{data, size};
+   subchain::block_with_id block;
+   eosio::from_bin(block, bin);
+   return add_block(std::move(block), eosio_irreversible);
+}
+
+[[clang::export_name("setIrreversible")]] uint32_t setIrreversible(uint32_t irreversible)
+{
+   if (auto* b = block_log.block_before_num(irreversible + 1))
+      block_log.irreversible = std::max(block_log.irreversible, b->num);
+   db.db.commit(block_log.irreversible);
+   return block_log.irreversible;
+}
+
+[[clang::export_name("trimBlocks")]] void trimBlocks()
+{
+   block_log.trim();
+}
+
+[[clang::export_name("undoBlockNum")]] void undoBlockNum(uint32_t blockNum)
+{
+   forked_n_blocks(block_log.undo(blockNum));
+}
+
+[[clang::export_name("undoEosioNum")]] void undoEosioNum(uint32_t eosioNum)
+{
+   if (auto* b = block_log.block_by_eosio_num(eosioNum))
+      forked_n_blocks(block_log.undo(b->num));
+}
+
+[[clang::export_name("getBlock")]] bool getBlock(uint32_t num)
+{
+   auto block = block_log.block_by_num(num);
+   if (!block)
+      return false;
+   result = eosio::convert_to_bin(*block);
+   return true;
+}
+
+constexpr const char MemberConnection_name[] = "MemberConnection";
+constexpr const char MemberEdge_name[] = "MemberEdge";
+using MemberConnection =
+    clchain::Connection<clchain::ConnectionConfig<std::reference_wrapper<const member>,
+                                                  MemberConnection_name,
+                                                  MemberEdge_name>>;
+
+struct Query
+{
+   subchain::BlockLog blockLog;
+
+   MemberConnection members(std::optional<eosio::name> gt,
+                            std::optional<eosio::name> ge,
+                            std::optional<eosio::name> lt,
+                            std::optional<eosio::name> le,
+                            std::optional<uint32_t> first,
+                            std::optional<uint32_t> last,
+                            std::optional<std::string> before,
+                            std::optional<std::string> after) const
+   {
+      return clchain::make_connection<MemberConnection, eosio::name>(
+          gt, ge, lt, le, first, last, before, after,       //
+          db.members.get<by_pk>(),                          //
+          [](auto& obj) { return obj.member.account; },     //
+          [](auto& obj) { return std::cref(obj.member); },  //
+          [](auto& members, auto key) { return members.lower_bound(key); },
+          [](auto& members, auto key) { return members.upper_bound(key); });
+   }
+};
+EOSIO_REFLECT2(Query,
+               blockLog,
+               method(members, "gt", "ge", "lt", "le", "first", "last", "before", "after"))
+
+auto schema = clchain::get_gql_schema<Query>();
+[[clang::export_name("getSchemaSize")]] uint32_t getSchemaSize()
+{
+   return schema.size();
+}
+[[clang::export_name("getSchema")]] const char* getSchema()
+{
+   return schema.c_str();
+}
+
+[[clang::export_name("query")]] void query(const char* query,
+                                           uint32_t size,
+                                           const char* variables,
+                                           uint32_t variables_size)
+{
+   Query root{block_log};
+   result = clchain::gql_query(root, {query, size}, {variables, variables_size});
+}
diff --git a/docker/eden-box.Dockerfile b/docker/eden-box.Dockerfile
index d5974b27c..098260f11 100644
--- a/docker/eden-box.Dockerfile
+++ b/docker/eden-box.Dockerfile
@@ -23,6 +23,7 @@ COPY .eslintignore .eslintrc.js .prettierrc.json lerna.json package.json tsconfi
 COPY --from=deps /app/node_modules ./node_modules
 COPY --from=deps /app/packages/common/node_modules ./packages/common/node_modules
 COPY --from=deps /app/packages/box/node_modules ./packages/box/node_modules
+COPY ./build/eden-micro-chain.wasm /app/build/
 
 RUN yarn build --stream
 
diff --git a/docker/eden-builder.Dockerfile b/docker/eden-builder.Dockerfile
index 71e618495..9e58f00ae 100644
--- a/docker/eden-builder.Dockerfile
+++ b/docker/eden-builder.Dockerfile
@@ -5,7 +5,6 @@ RUN export DEBIAN_FRONTEND=noninteractive \
     && apt-get install -yq      \
         binaryen                \
         build-essential         \
-        ccache                  \
         cmake                   \
         curl                    \
         git                     \
@@ -14,15 +13,27 @@ RUN export DEBIAN_FRONTEND=noninteractive \
         libgmp-dev              \
         libssl-dev              \
         libusb-1.0-0-dev        \
+        libzstd-dev             \
         pkg-config              \
     && apt-get clean -yq \
     && rm -rf /var/lib/apt/lists/*
 
+RUN cd /root \
+    && curl -LO https://github.com/ccache/ccache/releases/download/v4.3/ccache-4.3.tar.gz \
+    && tar xf ccache-4.3.tar.gz \
+    && cd /root/ccache-4.3 \
+    && cmake . \
+    && make -j \
+    && make -j install \
+    && cd /root \
+    && rm -rf ccache*
+
 RUN cd /opt \
     && curl -LO https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-12/wasi-sdk-12.0-linux.tar.gz \
     && tar xf wasi-sdk-12.0-linux.tar.gz \
     && curl -LO https://nodejs.org/dist/v14.16.0/node-v14.16.0-linux-x64.tar.xz \
     && tar xf node-v14.16.0-linux-x64.tar.xz \
+    && rm *.tar.* \
     && export PATH="/opt/node-v14.16.0-linux-x64/bin:$PATH" \
     && npm i -g yarn
 
diff --git a/external/CMakeLists.txt b/external/CMakeLists.txt
index 61313c949..0c964e8c6 100644
--- a/external/CMakeLists.txt
+++ b/external/CMakeLists.txt
@@ -40,6 +40,7 @@ if(IS_NATIVE)
         CMAKE_ARGS
             -DENABLE_OC=OFF
             -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+            -DCMAKE_TARGET_MESSAGES=${CMAKE_TARGET_MESSAGES}
             -DCMAKE_INSTALL_PREFIX=${ROOT_BINARY_DIR}/eos
             -DCMAKE_INSTALL_LIBDIR=lib
             -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
@@ -124,8 +125,12 @@ if(IS_NATIVE)
         BINARY_DIR rocksdb-ext
         TEST_EXCLUDE_FROM_MAIN 1
         EXCLUDE_FROM_ALL 1
+        BUILD_COMMAND sed -i s/@@//g ${CMAKE_CURRENT_SOURCE_DIR}/rocksdb/util/build_version.cc.in
+        COMMAND sed -i "s/__DATE__/\"\"/g" ${CMAKE_CURRENT_SOURCE_DIR}/rocksdb/util/build_version.cc.in
+        COMMAND cmake --build . -j ${NUM_PROCS}
         CMAKE_ARGS
             -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+            -DCMAKE_TARGET_MESSAGES=${CMAKE_TARGET_MESSAGES}
             -DCMAKE_INSTALL_PREFIX=${ROOT_BINARY_DIR}/rocksdb
             -DPORTABLE=ON # don't use sse4.2
             -DWITH_GFLAGS=OFF
@@ -152,6 +157,7 @@ ExternalProject_Add(fmt-ext
     EXCLUDE_FROM_ALL 1
     CMAKE_ARGS
         -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        -DCMAKE_TARGET_MESSAGES=${CMAKE_TARGET_MESSAGES}
         -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/fmt
         -DCMAKE_INSTALL_LIBDIR=lib
         -DCMAKE_C_COMPILER_LAUNCHER=${CMAKE_C_COMPILER_LAUNCHER}
@@ -186,6 +192,7 @@ ExternalProject_Add(catch2-ext
     ${CATCH2_INSTALL_COMMAND}
     CMAKE_ARGS
         -DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}
+        -DCMAKE_TARGET_MESSAGES=${CMAKE_TARGET_MESSAGES}
         -DCMAKE_INSTALL_PREFIX=${CMAKE_BINARY_DIR}/catch2
         -DCATCH_INSTALL_DOCS=FALSE
         -DCATCH_INSTALL_EXTRAS=FALSE
diff --git a/libraries/CMakeLists.txt b/libraries/CMakeLists.txt
index 9977656cf..d672beaae 100644
--- a/libraries/CMakeLists.txt
+++ b/libraries/CMakeLists.txt
@@ -11,4 +11,5 @@ if(DEFINED IS_NATIVE)
     add_subdirectory(state_history)
 endif()
 
+add_subdirectory(clchain)
 add_subdirectory(rodeos)
diff --git a/libraries/abieos/include/eosio/fixed_bytes.hpp b/libraries/abieos/include/eosio/fixed_bytes.hpp
index a35be1252..91dd3a013 100644
--- a/libraries/abieos/include/eosio/fixed_bytes.hpp
+++ b/libraries/abieos/include/eosio/fixed_bytes.hpp
@@ -5,6 +5,7 @@
 #include <cstring>
 #include <type_traits>
 #include "from_json.hpp"
+#include "hex.hpp"
 #include "operators.hpp"
 #include "reflection.hpp"
 #include "to_json.hpp"
@@ -288,4 +289,10 @@ namespace eosio
       eosio::to_json_hex((const char*)bytes.data(), bytes.size(), stream);
    }
 
+   template <typename T, std::size_t Size>
+   std::string to_string(const fixed_bytes<Size, T>& obj)
+   {
+      auto bytes = obj.extract_as_byte_array();
+      return hex(bytes.begin(), bytes.end());
+   }
 }  // namespace eosio
diff --git a/libraries/abieos/include/eosio/for_each_field.hpp b/libraries/abieos/include/eosio/for_each_field.hpp
index 0390ccc09..f0c0821ed 100644
--- a/libraries/abieos/include/eosio/for_each_field.hpp
+++ b/libraries/abieos/include/eosio/for_each_field.hpp
@@ -24,7 +24,7 @@ namespace eosio
    constexpr auto for_each_field(T&& t, F&& f)
        -> std::enable_if_t<reflection::has_for_each_field_v<std::decay_t<T>>>
    {
-      eosio_for_each_field((std::decay_t<T>*)nullptr, [&](const char*, auto member) {
+      eosio_for_each_field((std::decay_t<T>*)nullptr, [&](const char*, auto member, auto...) {
          if constexpr (std::is_member_object_pointer_v<decltype(member(&t))>)
          {
             f(t.*member(&t));
@@ -35,7 +35,7 @@ namespace eosio
    template <typename T, typename F>
    constexpr void for_each_field(F&& f)
    {
-      eosio_for_each_field((T*)nullptr, [&f](const char* name, auto member) {
+      eosio_for_each_field((T*)nullptr, [&f](const char* name, auto member, auto...) {
          if constexpr (std::is_member_object_pointer_v<decltype(member((T*)nullptr))>)
          {
             f(name, [member](auto p) -> decltype((p->*member(p))) { return p->*member(p); });
@@ -47,10 +47,10 @@ namespace eosio
    template <typename T, typename F>
    constexpr void for_each_method(F&& f)
    {
-      eosio_for_each_field((T*)nullptr, [&f](const char* name, auto member) {
+      eosio_for_each_field((T*)nullptr, [&f](const char* name, auto member, auto... arg_names) {
          if constexpr (std::is_member_function_pointer_v<decltype(member((T*)nullptr))>)
          {
-            f(name, member((T*)nullptr));
+            f(name, member((T*)nullptr), arg_names...);
          }
       });
    }
diff --git a/libraries/abieos/include/eosio/hex.hpp b/libraries/abieos/include/eosio/hex.hpp
new file mode 100644
index 000000000..832012831
--- /dev/null
+++ b/libraries/abieos/include/eosio/hex.hpp
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <string>
+
+namespace eosio
+{
+   template <typename SrcIt, typename DestIt>
+   void hex(SrcIt begin, SrcIt end, DestIt dest)
+   {
+      auto nibble = [&dest](uint8_t i) {
+         if (i <= 9)
+            *dest++ = '0' + i;
+         else
+            *dest++ = 'A' + i - 10;
+      };
+      while (begin != end)
+      {
+         nibble(((uint8_t)*begin) >> 4);
+         nibble(((uint8_t)*begin) & 0xf);
+         ++begin;
+      }
+   }
+
+   template <typename SrcIt>
+   std::string hex(SrcIt begin, SrcIt end)
+   {
+      std::string s;
+      s.reserve((end - begin) * 2);
+      hex(begin, end, std::back_inserter(s));
+      return s;
+   }
+}  // namespace eosio
diff --git a/libraries/abieos/include/eosio/reflection2.hpp b/libraries/abieos/include/eosio/reflection2.hpp
new file mode 100644
index 000000000..bba15f8be
--- /dev/null
+++ b/libraries/abieos/include/eosio/reflection2.hpp
@@ -0,0 +1,68 @@
+#include <eosio/reflection.hpp>
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/facilities/check_empty.hpp>
+#include <boost/preprocessor/logical/bitand.hpp>
+#include <boost/preprocessor/logical/compl.hpp>
+#include <boost/preprocessor/seq/for_each.hpp>
+#include <boost/preprocessor/stringize.hpp>
+#include <boost/preprocessor/tuple/push_front.hpp>
+#include <boost/preprocessor/variadic/to_seq.hpp>
+
+#define EOSIO_REFLECT2_MATCH_CHECK_N(x, n, r, ...) \
+   BOOST_PP_BITAND(n, BOOST_PP_COMPL(BOOST_PP_CHECK_EMPTY(r)))
+#define EOSIO_REFLECT2_MATCH_CHECK(...) EOSIO_REFLECT2_MATCH_CHECK_N(__VA_ARGS__, 0, )
+#define EOSIO_REFLECT2_MATCH(base, x) EOSIO_REFLECT2_MATCH_CHECK(BOOST_PP_CAT(base, x))
+
+#define EOSIO_REFLECT2_FIRST(a, ...) a
+#define EOSIO_REFLECT2_APPLY_FIRST(a) EOSIO_REFLECT2_FIRST(a)
+#define EOSIO_REFLECT2_SKIP_SECOND(a, b, ...) (a, __VA_ARGS__)
+
+#define EOSIO_REFLECT2_KNOWN_ITEM(STRUCT, item)                                                   \
+   EOSIO_REFLECT2_FIRST EOSIO_REFLECT2_APPLY_FIRST(BOOST_PP_CAT(EOSIO_REFLECT2_MATCH_ITEM, item)) \
+       EOSIO_REFLECT2_SKIP_SECOND BOOST_PP_TUPLE_PUSH_FRONT(                                      \
+           EOSIO_REFLECT2_APPLY_FIRST(BOOST_PP_CAT(EOSIO_REFLECT2_MATCH_ITEM, item)), STRUCT)
+#define EOSIO_REFLECT2_MATCH_ITEM(r, STRUCT, item)                                  \
+   BOOST_PP_IIF(BOOST_PP_CHECK_EMPTY(item), ,                                       \
+                BOOST_PP_IIF(EOSIO_REFLECT2_MATCH(EOSIO_REFLECT2_MATCH_ITEM, item), \
+                             EOSIO_REFLECT2_KNOWN_ITEM, EOSIO_REFLECT2_MEMBER)(STRUCT, item))
+
+#define EOSIO_REFLECT2_MEMBER(STRUCT, member)                               \
+   f(#member, [](auto p) -> decltype(&std::decay_t<decltype(*p)>::member) { \
+      return &std::decay_t<decltype(*p)>::member;                           \
+   });
+
+#define EOSIO_REFLECT2_MATCH_ITEMbase(...) (EOSIO_REFLECT2_base, __VA_ARGS__), 1
+#define EOSIO_REFLECT2_base(STRUCT, base)                                                         \
+   static_assert(std::is_base_of_v<base, STRUCT>,                                                 \
+                 BOOST_PP_STRINGIZE(base) " is not a base class of " BOOST_PP_STRINGIZE(STRUCT)); \
+   eosio_for_each_field((base*)nullptr, f);
+
+#define EOSIO_REFLECT2_MATCH_ITEMmethod(...) (EOSIO_REFLECT2_method, __VA_ARGS__), 1
+#define EOSIO_REFLECT2_method(STRUCT, member, ...)                   \
+   f(                                                                \
+       BOOST_PP_STRINGIZE(member),                                   \
+       [](auto p) -> decltype(&std::decay_t<decltype(*p)>::member) { \
+          return &std::decay_t<decltype(*p)>::member;                \
+       },                                                            \
+       __VA_ARGS__);
+
+/**
+ * EOSIO_REFLECT2(<struct>, <member or base spec>...)
+ * Each parameter may be one of the following:
+ *    * ident:                         non-static data member or method
+ *    * base(ident):                   base class
+ *    * method(ident, "arg1", ...):    method
+ */
+#define EOSIO_REFLECT2(STRUCT, ...)                                               \
+   [[maybe_unused]] inline const char* get_type_name(STRUCT*) { return #STRUCT; } \
+   template <typename F>                                                          \
+   constexpr void eosio_for_each_field(STRUCT*, F f)                              \
+   {                                                                              \
+      BOOST_PP_SEQ_FOR_EACH(EOSIO_REFLECT2_MATCH_ITEM, STRUCT,                    \
+                            BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))                \
+   }
+
+#define EOSIO_REFLECT2_FOR_EACH_FIELD(STRUCT, ...) \
+   BOOST_PP_SEQ_FOR_EACH(EOSIO_REFLECT2_MATCH_ITEM, STRUCT, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))
diff --git a/libraries/abieos/include/eosio/stream.hpp b/libraries/abieos/include/eosio/stream.hpp
index aef07aef9..ec7171f83 100644
--- a/libraries/abieos/include/eosio/stream.hpp
+++ b/libraries/abieos/include/eosio/stream.hpp
@@ -99,6 +99,24 @@ namespace eosio
       }
    };
 
+   struct string_stream
+   {
+      std::string& data;
+      string_stream(std::string& data) : data(data) {}
+
+      void write(char c) { data.push_back(c); }
+      void write(const void* src, std::size_t sz)
+      {
+         auto s = reinterpret_cast<const char*>(src);
+         data.insert(data.end(), s, s + sz);
+      }
+      template <typename T>
+      void write_raw(const T& v)
+      {
+         write(&v, sizeof(v));
+      }
+   };
+
    struct fixed_buf_stream
    {
       char* pos;
@@ -119,12 +137,6 @@ namespace eosio
          pos += sz;
       }
 
-      template <int Size>
-      void write(const char (&src)[Size])
-      {
-         write(src, Size);
-      }
-
       template <typename T>
       void write_raw(const T& v)
       {
@@ -140,12 +152,6 @@ namespace eosio
 
       void write(const void* src, std::size_t sz) { size += sz; }
 
-      template <int Size>
-      void write(const char (&src)[Size])
-      {
-         size += Size;
-      }
-
       template <typename T>
       void write_raw(const T& v)
       {
@@ -153,6 +159,12 @@ namespace eosio
       }
    };
 
+   template <typename S>
+   void write_str(std::string_view str, S& stream)
+   {
+      stream.write(str.data(), str.size());
+   }
+
    template <typename S>
    void increase_indent(S&)
    {
diff --git a/libraries/abieos/include/eosio/time.hpp b/libraries/abieos/include/eosio/time.hpp
index 2e0c3019c..96b3ccc19 100644
--- a/libraries/abieos/include/eosio/time.hpp
+++ b/libraries/abieos/include/eosio/time.hpp
@@ -103,18 +103,42 @@ namespace eosio
    void from_json(time_point& obj, S& stream)
    {
       auto s = stream.get_string();
+      auto pos = s.data();
+      auto end = pos + s.size();
       uint64_t utc_microseconds;
-      if (!eosio::string_to_utc_microseconds(utc_microseconds, s.data(), s.data() + s.size()))
+      if (!eosio::string_to_utc_microseconds(utc_microseconds, pos, end, false) ||
+          !(pos == end || pos + 1 == end && *pos == 'Z'))
       {
          check(false, convert_json_error(eosio::from_json_error::expected_time_point));
       }
       obj = time_point(microseconds(utc_microseconds));
    }
 
+   template <typename Base>
+   struct time_point_include_z_stream : Base
+   {
+      using Base::Base;
+   };
+
+   template <typename S>
+   constexpr bool time_point_include_z(const S*)
+   {
+      return false;
+   }
+
+   template <typename Base>
+   constexpr bool time_point_include_z(const time_point_include_z_stream<Base>*)
+   {
+      return true;
+   }
+
    template <typename S>
    void to_json(const time_point& obj, S& stream)
    {
-      return to_json(eosio::microseconds_to_str(obj.elapsed._count), stream);
+      if constexpr (time_point_include_z((S*)nullptr))
+         return to_json(eosio::microseconds_to_str(obj.elapsed._count) + "Z", stream);
+      else
+         return to_json(eosio::microseconds_to_str(obj.elapsed._count), stream);
    }
 
    /**
diff --git a/libraries/abieos/include/eosio/to_json.hpp b/libraries/abieos/include/eosio/to_json.hpp
index b4258399c..7ae85bb65 100644
--- a/libraries/abieos/include/eosio/to_json.hpp
+++ b/libraries/abieos/include/eosio/to_json.hpp
@@ -331,16 +331,22 @@ template <typename S> void to_json(__int128 value, S& stream) { return int_to_js
       return result;
    }
 
-   template <typename T>
-   std::string format_json(const T& t)
+   template <template <typename S> typename Wrapper, typename T>
+   std::string convert_to_json_wrapped(const T& t)
    {
-      pretty_stream<size_stream> ss;
+      Wrapper<size_stream> ss;
       to_json(t, ss);
       std::string result(ss.size, 0);
-      pretty_stream<fixed_buf_stream> fbs(result.data(), result.size());
+      Wrapper<fixed_buf_stream> fbs(result.data(), result.size());
       to_json(t, fbs);
       check(fbs.pos == fbs.end, convert_stream_error(stream_error::underrun));
       return result;
    }
 
+   template <typename T>
+   std::string format_json(const T& t)
+   {
+      return convert_to_json_wrapped<pretty_stream>(t);
+   }
+
 }  // namespace eosio
diff --git a/libraries/abieos/include/eosio/types.hpp b/libraries/abieos/include/eosio/types.hpp
index 9cbe550d3..602c3bb79 100644
--- a/libraries/abieos/include/eosio/types.hpp
+++ b/libraries/abieos/include/eosio/types.hpp
@@ -5,6 +5,7 @@
 #include <deque>
 #include <list>
 #include <map>
+#include <memory>
 #include <optional>
 #include <set>
 #include <string>
@@ -13,11 +14,63 @@
 
 namespace eosio
 {
+   template <class T>
+   using remove_cvref_t = std::remove_cv_t<std::remove_reference_t<T>>;
+
    template <typename... Ts>
    struct type_list
    {
+      static constexpr int size = sizeof...(Ts);
+   };
+
+   template <typename... Ts>
+   std::tuple<Ts...> tuple_from_type_list_impl(type_list<Ts...>&&);
+   template <typename T>
+   using tuple_from_type_list = decltype(tuple_from_type_list_impl(std::declval<T>()));
+
+   template <typename T>
+   struct member_fn;
+
+   template <typename R, typename T, typename... Args>
+   struct member_fn<R (T::*)(Args...)>
+   {
+      static constexpr bool is_const = false;
+      static constexpr int num_args = sizeof...(Args);
+      using type = R (T::*)(Args...);
+      using class_type = T;
+      using return_type = R;
+      using arg_types = type_list<Args...>;
+   };
+
+   template <typename R, typename T, typename... Args>
+   struct member_fn<R (T::*)(Args...) const>
+   {
+      static constexpr bool is_const = true;
+      static constexpr int num_args = sizeof...(Args);
+      using type = R (T::*)(Args...) const;
+      using class_type = T;
+      using return_type = R;
+      using arg_types = type_list<Args...>;
    };
 
+   template <typename T>
+   struct is_non_const_member_fn
+   {
+      constexpr operator bool()
+      {
+         if constexpr (std::is_member_function_pointer_v<T>)
+            return !eosio::member_fn<T>::is_const;
+         else
+            return false;
+      }
+   };
+
+   template <typename F, typename... Args, typename... Names>
+   void for_each_named_type(F&& f, type_list<Args...>, Names... names)
+   {
+      (f((remove_cvref_t<Args>*)nullptr, names), ...);
+   }
+
    template <typename T>
    struct is_serializable_container : std::false_type
    {
@@ -64,6 +117,28 @@ namespace eosio
       using value_type = T;
    };
 
+   template <typename T>
+   struct is_std_unique_ptr : std::false_type
+   {
+   };
+
+   template <typename T>
+   struct is_std_unique_ptr<std::unique_ptr<T>> : std::true_type
+   {
+      using value_type = T;
+   };
+
+   template <typename T>
+   struct is_std_reference_wrapper : std::false_type
+   {
+   };
+
+   template <typename T>
+   struct is_std_reference_wrapper<std::reference_wrapper<T>> : std::true_type
+   {
+      using value_type = T;
+   };
+
    template <typename T>
    struct is_binary_extension : std::false_type
    {
diff --git a/libraries/abieos/src/abieos.cpp b/libraries/abieos/src/abieos.cpp
index a206567bb..e0e73ae3c 100644
--- a/libraries/abieos/src/abieos.cpp
+++ b/libraries/abieos/src/abieos.cpp
@@ -2,6 +2,7 @@
 
 #include "eosio/abieos.h"
 #include "abieos.hpp"
+#include "eosio/hex.hpp"
 
 #include <memory>
 
@@ -101,8 +102,8 @@ extern "C" const char* abieos_get_bin_hex(abieos_context* context)
 {
    return handle_exceptions(context, nullptr, [&] {
       context->result_str.clear();
-      hex(context->result_bin.begin(), context->result_bin.end(),
-          std::back_inserter(context->result_str));
+      eosio::hex(context->result_bin.begin(), context->result_bin.end(),
+                 std::back_inserter(context->result_str));
       return context->result_str.c_str();
    });
 }
diff --git a/libraries/abieos/src/abieos.hpp b/libraries/abieos/src/abieos.hpp
index 663f1d258..c0b2f91f6 100644
--- a/libraries/abieos/src/abieos.hpp
+++ b/libraries/abieos/src/abieos.hpp
@@ -63,33 +63,6 @@ namespace abieos
    struct pseudo_array;
    struct pseudo_variant;
 
-   // !!!
-   template <typename SrcIt, typename DestIt>
-   void hex(SrcIt begin, SrcIt end, DestIt dest)
-   {
-      auto nibble = [&dest](uint8_t i) {
-         if (i <= 9)
-            *dest++ = '0' + i;
-         else
-            *dest++ = 'A' + i - 10;
-      };
-      while (begin != end)
-      {
-         nibble(((uint8_t)*begin) >> 4);
-         nibble(((uint8_t)*begin) & 0xf);
-         ++begin;
-      }
-   }
-
-   // !!!
-   template <typename SrcIt>
-   std::string hex(SrcIt begin, SrcIt end)
-   {
-      std::string s;
-      hex(begin, end, std::back_inserter(s));
-      return s;
-   }
-
    // !!!
    template <typename SrcIt, typename DestIt>
    ABIEOS_NODISCARD bool unhex(std::string& error, SrcIt begin, SrcIt end, DestIt dest)
diff --git a/libraries/abieos/src/test.cpp b/libraries/abieos/src/test.cpp
index 436c37862..4b8fd74a6 100644
--- a/libraries/abieos/src/test.cpp
+++ b/libraries/abieos/src/test.cpp
@@ -252,8 +252,8 @@ std::string string_to_hex(const std::string& s)
 {
    std::string result;
    uint8_t size = s.size();
-   abieos::hex(&size, &size + 1, std::back_inserter(result));
-   abieos::hex(s.begin(), s.end(), std::back_inserter(result));
+   eosio::hex(&size, &size + 1, std::back_inserter(result));
+   eosio::hex(s.begin(), s.end(), std::back_inserter(result));
    return result;
 }
 
diff --git a/libraries/clchain/CMakeLists.txt b/libraries/clchain/CMakeLists.txt
new file mode 100644
index 000000000..da89b71d1
--- /dev/null
+++ b/libraries/clchain/CMakeLists.txt
@@ -0,0 +1,26 @@
+find_package(OpenSSL REQUIRED Crypto)
+
+function(add suffix)
+    add_library(clchain${suffix})
+    target_link_libraries(clchain${suffix} PUBLIC abieos${suffix} boost OpenSSL::Crypto)
+    target_include_directories(clchain${suffix} PUBLIC include)
+    target_sources(clchain${suffix} PRIVATE
+        src/crypto.cpp
+    )
+    if(DEFINED IS_WASM)
+        target_link_libraries(clchain${suffix} PUBLIC wasm-base${suffix})
+        target_sources(clchain${suffix} PRIVATE
+            wasi-polyfill/__wasi_environ_get.cpp
+            wasi-polyfill/__wasi_environ_sizes_get.cpp
+            wasi-polyfill/__wasi_fd_read.cpp
+            wasi-polyfill/__wasi_proc_exit.cpp
+            wasi-polyfill/eosio_assert.cpp
+            wasi-polyfill/prints.cpp
+        )
+    endif()
+endfunction()
+
+add("")
+if(DEFINED IS_WASM)
+    add("-debug")
+endif()
diff --git a/libraries/clchain/include/chainbase/chainbase.hpp b/libraries/clchain/include/chainbase/chainbase.hpp
new file mode 100644
index 000000000..cd6487471
--- /dev/null
+++ b/libraries/clchain/include/chainbase/chainbase.hpp
@@ -0,0 +1,449 @@
+#pragma once
+
+#include <chainbase/undo_index.hpp>
+
+#include <boost/core/demangle.hpp>
+#include <boost/multi_index_container.hpp>
+
+#include <iostream>
+#include <set>
+#include <sstream>
+#include <typeindex>
+#include <typeinfo>
+#include <vector>
+
+namespace chainbase
+{
+   using std::unique_ptr;
+   using std::vector;
+
+   template <typename T>
+   using allocator = std::allocator<T>;
+
+   template <typename T>
+   using node_allocator = std::allocator<T>;
+
+   /**
+    *  Object ID type that includes the type of the object it references
+    */
+   template <typename T>
+   class oid
+   {
+     public:
+      oid(int64_t i = 0) : _id(i) {}
+
+      oid& operator++()
+      {
+         ++_id;
+         return *this;
+      }
+
+      friend bool operator<(const oid& a, const oid& b) { return a._id < b._id; }
+      friend bool operator>(const oid& a, const oid& b) { return a._id > b._id; }
+      friend bool operator<=(const oid& a, const oid& b) { return a._id <= b._id; }
+      friend bool operator>=(const oid& a, const oid& b) { return a._id >= b._id; }
+      friend bool operator==(const oid& a, const oid& b) { return a._id == b._id; }
+      friend bool operator!=(const oid& a, const oid& b) { return a._id != b._id; }
+      friend std::ostream& operator<<(std::ostream& s, const oid& id)
+      {
+         s << boost::core::demangle(typeid(oid<T>).name()) << '(' << id._id << ')';
+         return s;
+      }
+
+      int64_t _id = 0;
+   };
+
+   template <uint16_t TypeNumber, typename Derived>
+   struct object
+   {
+      typedef oid<Derived> id_type;
+      static const uint16_t type_id = TypeNumber;
+   };
+
+   /** this class is ment to be specified to enable lookup of index type by object type using
+    * the SET_INDEX_TYPE macro.
+    **/
+   template <typename T>
+   struct get_index_type
+   {
+   };
+
+   /**
+    *  This macro must be used at global scope and OBJECT_TYPE and INDEX_TYPE must be fully qualified
+    */
+#define CHAINBASE_SET_INDEX_TYPE(OBJECT_TYPE, INDEX_TYPE) \
+   namespace chainbase                                    \
+   {                                                      \
+      template <>                                         \
+      struct get_index_type<OBJECT_TYPE>                  \
+      {                                                   \
+         typedef INDEX_TYPE type;                         \
+      };                                                  \
+   }
+
+#define CHAINBASE_DEFAULT_CONSTRUCTOR(OBJECT_TYPE)     \
+   template <typename Constructor, typename Allocator> \
+   OBJECT_TYPE(Constructor&& c, Allocator&&)           \
+   {                                                   \
+      c(*this);                                        \
+   }
+
+   template <typename MultiIndexType>
+   using generic_index = multi_index_to_undo_index<MultiIndexType>;
+
+   class abstract_session
+   {
+     public:
+      virtual ~abstract_session(){};
+      virtual void push() = 0;
+      virtual void squash() = 0;
+      virtual void undo() = 0;
+   };
+
+   template <typename SessionType>
+   class session_impl : public abstract_session
+   {
+     public:
+      session_impl(SessionType&& s) : _session(std::move(s)) {}
+
+      virtual void push() override { _session.push(); }
+      virtual void squash() override { _session.squash(); }
+      virtual void undo() override { _session.undo(); }
+
+     private:
+      SessionType _session;
+   };
+
+   class abstract_index
+   {
+     public:
+      abstract_index(void* i) : _idx_ptr(i) {}
+      virtual ~abstract_index() {}
+      virtual void set_revision(uint64_t revision) = 0;
+      virtual unique_ptr<abstract_session> start_undo_session(bool enabled) = 0;
+
+      virtual int64_t revision() const = 0;
+      virtual void undo() const = 0;
+      virtual void squash() const = 0;
+      virtual void commit(int64_t revision) const = 0;
+      virtual void undo_all() const = 0;
+      virtual uint32_t type_id() const = 0;
+      virtual uint64_t row_count() const = 0;
+      virtual const std::string& type_name() const = 0;
+      virtual std::pair<int64_t, int64_t> undo_stack_revision_range() const = 0;
+
+      virtual void remove_object(int64_t id) = 0;
+
+      void* get() const { return _idx_ptr; }
+
+     private:
+      void* _idx_ptr;
+   };
+
+   template <typename BaseIndex>
+   class index_impl : public abstract_index
+   {
+     public:
+      index_impl(BaseIndex& base) : abstract_index(&base), _base(base) {}
+
+      virtual unique_ptr<abstract_session> start_undo_session(bool enabled) override
+      {
+         return std::make_unique<session_impl<typename BaseIndex::session>>(
+             _base.start_undo_session(enabled));
+      }
+
+      virtual void set_revision(uint64_t revision) override { _base.set_revision(revision); }
+      virtual int64_t revision() const override { return _base.revision(); }
+      virtual void undo() const override { _base.undo(); }
+      virtual void squash() const override { _base.squash(); }
+      virtual void commit(int64_t revision) const override { _base.commit(revision); }
+      virtual void undo_all() const override { _base.undo_all(); }
+      virtual uint32_t type_id() const override { return BaseIndex::value_type::type_id; }
+      virtual uint64_t row_count() const override { return _base.indices().size(); }
+      virtual const std::string& type_name() const override { return BaseIndex_name; }
+      virtual std::pair<int64_t, int64_t> undo_stack_revision_range() const override
+      {
+         return _base.undo_stack_revision_range();
+      }
+
+      virtual void remove_object(int64_t id) override { return _base.remove_object(id); }
+
+     private:
+      BaseIndex& _base;
+      std::string BaseIndex_name =
+          boost::core::demangle(typeid(typename BaseIndex::value_type).name());
+   };
+
+   template <typename IndexType>
+   class index : public index_impl<IndexType>
+   {
+     public:
+      index(IndexType& i) : index_impl<IndexType>(i) {}
+   };
+
+   class database
+   {
+     public:
+      using database_index_row_count_multiset = std::multiset<std::pair<unsigned, std::string>>;
+
+      database() = default;
+      database(database&&) = default;
+      database& operator=(database&&) = default;
+      ~database()
+      {
+         _index_list.clear();
+         _index_map.clear();
+      }
+
+      struct session
+      {
+        public:
+         session(session&& s) = default;
+         session(vector<std::unique_ptr<abstract_session>>&& s) : _index_sessions(std::move(s)) {}
+
+         ~session() { undo(); }
+
+         void push()
+         {
+            for (auto& i : _index_sessions)
+               i->push();
+            _index_sessions.clear();
+         }
+
+         void squash()
+         {
+            for (auto& i : _index_sessions)
+               i->squash();
+            _index_sessions.clear();
+         }
+
+         void undo()
+         {
+            for (auto& i : _index_sessions)
+               i->undo();
+            _index_sessions.clear();
+         }
+
+        private:
+         friend class database;
+         session() {}
+
+         vector<std::unique_ptr<abstract_session>> _index_sessions;
+      };
+
+      session start_undo_session(bool enabled)
+      {
+         if (enabled)
+         {
+            vector<std::unique_ptr<abstract_session>> _sub_sessions;
+            _sub_sessions.reserve(_index_list.size());
+            for (auto& item : _index_list)
+            {
+               _sub_sessions.push_back(item->start_undo_session(enabled));
+            }
+            return session(std::move(_sub_sessions));
+         }
+         else
+         {
+            return session();
+         }
+      }
+
+      int64_t revision() const
+      {
+         if (_index_list.size() == 0)
+            return -1;
+         return _index_list[0]->revision();
+      }
+
+      std::pair<int64_t, int64_t> undo_stack_revision_range() const
+      {
+         if (_index_list.size() == 0)
+            return {-1, -1};
+         return _index_list[0]->undo_stack_revision_range();
+      }
+
+      void undo()
+      {
+         for (auto& item : _index_list)
+         {
+            item->undo();
+         }
+      }
+
+      void squash()
+      {
+         for (auto& item : _index_list)
+         {
+            item->squash();
+         }
+      }
+
+      void commit(int64_t revision)
+      {
+         for (auto& item : _index_list)
+         {
+            item->commit(revision);
+         }
+      }
+
+      void undo_all()
+      {
+         for (auto& item : _index_list)
+         {
+            item->undo_all();
+         }
+      }
+
+      void set_revision(uint64_t revision)
+      {
+         for (auto i : _index_list)
+            i->set_revision(revision);
+      }
+
+      template <typename index_type>
+      void add_index(index_type& the_index)
+      {
+         const uint16_t type_id = index_type::value_type::type_id;
+         typedef typename index_type::allocator_type index_alloc;
+
+         std::string type_name =
+             boost::core::demangle(typeid(typename index_type::value_type).name());
+
+         if (!(_index_map.size() <= type_id || _index_map[type_id] == nullptr))
+            eosio::check(false, "::type_id is already in use");
+
+         if (type_id >= _index_map.size())
+            _index_map.resize(type_id + 1);
+
+         auto new_index = std::make_unique<index<index_type>>(the_index);
+         _index_list.push_back(&*new_index);
+         _index_map[type_id] = std::move(new_index);
+      }
+
+      template <typename MultiIndexType>
+      const generic_index<MultiIndexType>& get_index() const
+      {
+         typedef generic_index<MultiIndexType> index_type;
+         typedef index_type* index_type_ptr;
+         assert(_index_map.size() > index_type::value_type::type_id);
+         assert(_index_map[index_type::value_type::type_id]);
+         return *index_type_ptr(_index_map[index_type::value_type::type_id]->get());
+      }
+
+      template <typename MultiIndexType, typename ByIndex>
+      auto get_index() const -> decltype(
+          ((generic_index<MultiIndexType>*)(nullptr))->indices().template get<ByIndex>())
+      {
+         typedef generic_index<MultiIndexType> index_type;
+         typedef index_type* index_type_ptr;
+         assert(_index_map.size() > index_type::value_type::type_id);
+         assert(_index_map[index_type::value_type::type_id]);
+         return index_type_ptr(_index_map[index_type::value_type::type_id]->get())
+             ->indices()
+             .template get<ByIndex>();
+      }
+
+      template <typename MultiIndexType>
+      generic_index<MultiIndexType>& get_mutable_index()
+      {
+         typedef generic_index<MultiIndexType> index_type;
+         typedef index_type* index_type_ptr;
+         assert(_index_map.size() > index_type::value_type::type_id);
+         assert(_index_map[index_type::value_type::type_id]);
+         return *index_type_ptr(_index_map[index_type::value_type::type_id]->get());
+      }
+
+      template <typename ObjectType, typename IndexedByType, typename CompatibleKey>
+      const ObjectType* find(CompatibleKey&& key) const
+      {
+         typedef typename get_index_type<ObjectType>::type index_type;
+         const auto& idx = get_index<index_type>().indices().template get<IndexedByType>();
+         auto itr = idx.find(std::forward<CompatibleKey>(key));
+         if (itr == idx.end())
+            return nullptr;
+         return &*itr;
+      }
+
+      template <typename ObjectType>
+      const ObjectType* find(oid<ObjectType> key = oid<ObjectType>()) const
+      {
+         typedef typename get_index_type<ObjectType>::type index_type;
+         return get_index<index_type>().find(key);
+      }
+
+      template <typename ObjectType, typename IndexedByType, typename CompatibleKey>
+      const ObjectType& get(CompatibleKey&& key) const
+      {
+         auto obj = find<ObjectType, IndexedByType>(std::forward<CompatibleKey>(key));
+         if (!obj)
+         {
+            std::stringstream ss;
+            ss << "unknown key (" << boost::core::demangle(typeid(key).name()) << "): " << key;
+            eosio::check(false, ss.str());
+         }
+         return *obj;
+      }
+
+      template <typename ObjectType>
+      const ObjectType& get(const oid<ObjectType>& key = oid<ObjectType>()) const
+      {
+         auto obj = find<ObjectType>(key);
+         if (!obj)
+         {
+            std::stringstream ss;
+            ss << "unknown key (" << boost::core::demangle(typeid(key).name()) << "): " << key._id;
+            eosio::check(false, ss.str());
+         }
+         return *obj;
+      }
+
+      template <typename ObjectType, typename Modifier>
+      void modify(const ObjectType& obj, Modifier&& m)
+      {
+         typedef typename get_index_type<ObjectType>::type index_type;
+         get_mutable_index<index_type>().modify(obj, m);
+      }
+
+      template <typename ObjectType>
+      void remove(const ObjectType& obj)
+      {
+         typedef typename get_index_type<ObjectType>::type index_type;
+         return get_mutable_index<index_type>().remove(obj);
+      }
+
+      template <typename ObjectType, typename Constructor>
+      const ObjectType& create(Constructor&& con)
+      {
+         typedef typename get_index_type<ObjectType>::type index_type;
+         return get_mutable_index<index_type>().emplace(std::forward<Constructor>(con));
+      }
+
+      database_index_row_count_multiset row_count_per_index() const
+      {
+         database_index_row_count_multiset ret;
+         for (const auto& ai_ptr : _index_map)
+         {
+            if (!ai_ptr)
+               continue;
+            ret.emplace(make_pair(ai_ptr->row_count(), ai_ptr->type_name()));
+         }
+         return ret;
+      }
+
+     private:
+      /**
+       * This is a sparse list of known indices kept to accelerate creation of undo sessions
+       */
+      vector<abstract_index*> _index_list;
+
+      /**
+       * This is a full map (size 2^16) of all possible index designed for constant time lookup
+       */
+      vector<unique_ptr<abstract_index>> _index_map;
+   };
+
+   template <typename Object, typename... Args>
+   using shared_multi_index_container =
+       boost::multi_index_container<Object, Args..., chainbase::node_allocator<Object>>;
+}  // namespace chainbase
diff --git a/libraries/clchain/include/chainbase/undo_index.hpp b/libraries/clchain/include/chainbase/undo_index.hpp
new file mode 100644
index 000000000..8102934da
--- /dev/null
+++ b/libraries/clchain/include/chainbase/undo_index.hpp
@@ -0,0 +1,1136 @@
+#pragma once
+
+#include <boost/container/deque.hpp>
+#include <boost/core/demangle.hpp>
+#include <boost/interprocess/interprocess_fwd.hpp>
+#include <boost/intrusive/avltree.hpp>
+#include <boost/intrusive/set.hpp>
+#include <boost/intrusive/slist.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/multi_index_container_fwd.hpp>
+#include <eosio/check.hpp>
+
+#include <cassert>
+#include <memory>
+#include <sstream>
+#include <type_traits>
+
+namespace chainbase
+{
+   template <typename F>
+   struct scope_exit
+   {
+     public:
+      scope_exit(F&& f) : _f(f) {}
+      scope_exit(const scope_exit&) = delete;
+      scope_exit& operator=(const scope_exit&) = delete;
+      ~scope_exit()
+      {
+         if (!_canceled)
+            _f();
+      }
+      void cancel() { _canceled = true; }
+
+     private:
+      F _f;
+      bool _canceled = false;
+   };
+
+   // Adapts multi_index's idea of keys to intrusive
+   template <typename KeyExtractor, typename T>
+   struct get_key
+   {
+      using type = std::decay_t<decltype(KeyExtractor{}(std::declval<const T&>()))>;
+      decltype(auto) operator()(const T& arg) const { return KeyExtractor{}(arg); }
+   };
+
+   template <typename T>
+   struct value_holder
+   {
+      template <typename... A>
+      value_holder(A&&... a) : _item(static_cast<A&&>(a)...)
+      {
+      }
+      T _item;
+   };
+
+   template <class Tag>
+   struct offset_node_base
+   {
+      offset_node_base() = default;
+      offset_node_base(const offset_node_base&) {}
+      constexpr offset_node_base& operator=(const offset_node_base&) { return *this; }
+      std::ptrdiff_t _parent;
+      std::ptrdiff_t _left;
+      std::ptrdiff_t _right;
+      int _color;
+   };
+
+   template <class Tag>
+   struct offset_node_traits
+   {
+      using node = offset_node_base<Tag>;
+      using node_ptr = node*;
+      using const_node_ptr = const node*;
+      using color = int;
+      static node_ptr get_parent(const_node_ptr n)
+      {
+         if (n->_parent == 1)
+            return nullptr;
+         return (node_ptr)((char*)n + n->_parent);
+      }
+      static void set_parent(node_ptr n, node_ptr parent)
+      {
+         if (parent == nullptr)
+            n->_parent = 1;
+         else
+            n->_parent = (char*)parent - (char*)n;
+      }
+      static node_ptr get_left(const_node_ptr n)
+      {
+         if (n->_left == 1)
+            return nullptr;
+         return (node_ptr)((char*)n + n->_left);
+      }
+      static void set_left(node_ptr n, node_ptr left)
+      {
+         if (left == nullptr)
+            n->_left = 1;
+         else
+            n->_left = (char*)left - (char*)n;
+      }
+      static node_ptr get_right(const_node_ptr n)
+      {
+         if (n->_right == 1)
+            return nullptr;
+         return (node_ptr)((char*)n + n->_right);
+      }
+      static void set_right(node_ptr n, node_ptr right)
+      {
+         if (right == nullptr)
+            n->_right = 1;
+         else
+            n->_right = (char*)right - (char*)n;
+      }
+      // red-black tree
+      static color get_color(node_ptr n) { return n->_color; }
+      static void set_color(node_ptr n, color c) { n->_color = c; }
+      static color black() { return 0; }
+      static color red() { return 1; }
+      // avl tree
+      using balance = int;
+      static balance get_balance(node_ptr n) { return n->_color; }
+      static void set_balance(node_ptr n, balance c) { n->_color = c; }
+      static balance negative() { return -1; }
+      static balance zero() { return 0; }
+      static balance positive() { return 1; }
+
+      // list
+      static node_ptr get_next(const_node_ptr n) { return get_right(n); }
+      static void set_next(node_ptr n, node_ptr next) { set_right(n, next); }
+      static node_ptr get_previous(const_node_ptr n) { return get_left(n); }
+      static void set_previous(node_ptr n, node_ptr previous) { set_left(n, previous); }
+   };
+
+   template <typename Node, typename Tag>
+   struct offset_node_value_traits
+   {
+      using node_traits = offset_node_traits<Tag>;
+      using node_ptr = typename node_traits::node_ptr;
+      using const_node_ptr = typename node_traits::const_node_ptr;
+      using value_type = typename Node::value_type;
+      using pointer = value_type*;
+      using const_pointer = const value_type*;
+
+      static node_ptr to_node_ptr(value_type& value)
+      {
+         return node_ptr{static_cast<Node*>(
+             boost::intrusive::get_parent_from_member(&value, &value_holder<value_type>::_item))};
+      }
+      static const_node_ptr to_node_ptr(const value_type& value)
+      {
+         return const_node_ptr{static_cast<const Node*>(
+             boost::intrusive::get_parent_from_member(&value, &value_holder<value_type>::_item))};
+      }
+      static pointer to_value_ptr(node_ptr n) { return pointer{&static_cast<Node*>(&*n)->_item}; }
+      static const_pointer to_value_ptr(const_node_ptr n)
+      {
+         return const_pointer{&static_cast<const Node*>(&*n)->_item};
+      }
+
+      static constexpr boost::intrusive::link_mode_type link_mode = boost::intrusive::normal_link;
+   };
+   template <typename Allocator, typename T>
+   using rebind_alloc_t = typename std::allocator_traits<Allocator>::template rebind_alloc<T>;
+
+   template <typename Index>
+   struct index_tag_impl
+   {
+      using type = void;
+   };
+   template <template <typename...> class Index, typename Tag, typename... T>
+   struct index_tag_impl<Index<boost::multi_index::tag<Tag>, T...>>
+   {
+      using type = Tag;
+   };
+   template <typename Index>
+   using index_tag = typename index_tag_impl<Index>::type;
+
+   template <typename Tag, typename... Indices>
+   using find_tag = boost::mp11::mp_find<boost::mp11::mp_list<index_tag<Indices>...>, Tag>;
+
+   template <typename K, typename Allocator>
+   using hook = offset_node_base<K>;
+
+   template <typename Node, typename OrderedIndex>
+   using set_base = boost::intrusive::avltree<
+       typename Node::value_type,
+       boost::intrusive::value_traits<offset_node_value_traits<Node, OrderedIndex>>,
+       boost::intrusive::key_of_value<
+           get_key<typename OrderedIndex::key_from_value_type, typename Node::value_type>>,
+       boost::intrusive::compare<typename OrderedIndex::compare_type>>;
+
+   template <typename OrderedIndex>
+   constexpr bool is_valid_index = false;
+   template <typename... T>
+   constexpr bool is_valid_index<boost::multi_index::ordered_unique<T...>> = true;
+
+   template <typename Node, typename Tag>
+   using list_base =
+       boost::intrusive::slist<typename Node::value_type,
+                               boost::intrusive::value_traits<offset_node_value_traits<Node, Tag>>>;
+
+   template <typename L, typename It, typename Pred, typename Disposer>
+   void remove_if_after_and_dispose(L& l, It it, It end, Pred&& p, Disposer&& d)
+   {
+      for (;;)
+      {
+         It next = it;
+         ++next;
+         if (next == end)
+            break;
+         if (p(*next))
+         {
+            l.erase_after_and_dispose(it, d);
+         }
+         else
+         {
+            it = next;
+         }
+      }
+   }
+
+   template <typename T, typename Allocator, typename... Indices>
+   class undo_index;
+
+   template <typename Node, typename OrderedIndex>
+   struct set_impl : private set_base<Node, OrderedIndex>
+   {
+      using base_type = set_base<Node, OrderedIndex>;
+      // Allow compatible keys to match multi_index
+      template <typename K>
+      auto find(K&& k) const
+      {
+         return base_type::find(static_cast<K&&>(k), this->key_comp());
+      }
+      template <typename K>
+      auto lower_bound(K&& k) const
+      {
+         return base_type::lower_bound(static_cast<K&&>(k), this->key_comp());
+      }
+      template <typename K>
+      auto upper_bound(K&& k) const
+      {
+         return base_type::upper_bound(static_cast<K&&>(k), this->key_comp());
+      }
+      template <typename K>
+      auto equal_range(K&& k) const
+      {
+         return base_type::equal_range(static_cast<K&&>(k), this->key_comp());
+      }
+      using base_type::begin;
+      using base_type::empty;
+      using base_type::end;
+      using base_type::iterator_to;
+      using base_type::rbegin;
+      using base_type::rend;
+      using base_type::size;
+      template <typename T, typename Allocator, typename... Indices>
+      friend class undo_index;
+   };
+
+   template <typename T, typename S>
+   class chainbase_node_allocator;
+
+   // Allows nested object to use a different allocator from the container.
+   template <template <typename> class A, typename T>
+   auto& propagate_allocator(A<T>& a)
+   {
+      return a;
+   }
+   template <typename T, typename S>
+   auto& propagate_allocator(boost::interprocess::allocator<T, S>& a)
+   {
+      return a;
+   }
+   template <typename T, typename S, std::size_t N>
+   auto propagate_allocator(boost::interprocess::node_allocator<T, S, N>& a)
+   {
+      return boost::interprocess::allocator<T, S>{a.get_segment_manager()};
+   }
+   template <typename T, typename S, std::size_t N>
+   auto propagate_allocator(boost::interprocess::private_node_allocator<T, S, N>& a)
+   {
+      return boost::interprocess::allocator<T, S>{a.get_segment_manager()};
+   }
+   template <typename T, typename S>
+   auto propagate_allocator(chainbase::chainbase_node_allocator<T, S>& a)
+   {
+      return boost::interprocess::allocator<T, S>{a.get_segment_manager()};
+   }
+
+   // Similar to boost::multi_index_container with an undo stack.
+   // Indices should be instances of ordered_unique.
+   template <typename T, typename Allocator, typename... Indices>
+   class undo_index
+   {
+     public:
+      using id_type = std::decay_t<decltype(std::declval<T>().id)>;
+      using value_type = T;
+      using allocator_type = Allocator;
+
+      static_assert((... && is_valid_index<Indices>), "Only ordered_unique indices are supported");
+
+      undo_index() = default;
+      explicit undo_index(const Allocator& a)
+          : _undo_stack{a}, _allocator{a}, _old_values_allocator{a}
+      {
+      }
+      ~undo_index()
+      {
+         dispose_undo();
+         clear_impl<1>();
+         std::get<0>(_indices).clear_and_dispose([&](pointer p) { dispose_node(*p); });
+      }
+
+      void validate() const
+      {
+         if (sizeof(node) != _size_of_value_type || sizeof(*this) != _size_of_this)
+            eosio::check(false, "content of memory does not match data expected by executable");
+      }
+
+      struct node : hook<Indices, Allocator>..., value_holder<T>
+      {
+         using value_type = T;
+         using allocator_type = Allocator;
+         template <typename... A>
+         explicit node(A&&... a) : value_holder<T>{static_cast<A&&>(a)...}
+         {
+         }
+         const T& item() const { return *this; }
+         uint64_t _mtime = 0;  // _monotonic_revision when the node was last modified or created.
+      };
+      static constexpr int erased_flag = 2;  // 0,1,and -1 are used by the tree
+
+      using indices_type = std::tuple<set_impl<node, Indices>...>;
+
+      using index0_set_type = std::tuple_element_t<0, indices_type>;
+      using alloc_traits = typename std::allocator_traits<Allocator>::template rebind_traits<node>;
+
+      static_assert(std::is_same_v<typename index0_set_type::key_type, id_type>,
+                    "first index must be id");
+
+      using index0_type = boost::mp11::mp_first<boost::mp11::mp_list<Indices...>>;
+      struct old_node : hook<index0_type, Allocator>, value_holder<T>
+      {
+         using value_type = T;
+         using allocator_type = Allocator;
+         template <typename... A>
+         explicit old_node(const T& t) : value_holder<T>{t}
+         {
+         }
+         uint64_t _mtime = 0;  // Backup of the node's _mtime, to be restored on undo
+         typename alloc_traits::pointer _current;  // pointer to the actual node
+      };
+
+      using id_pointer = id_type*;
+      using pointer = value_type*;
+      using const_iterator = typename index0_set_type::const_iterator;
+
+      // The undo stack is implemented as a deque of undo_states
+      // that index into a pair of singly linked lists.
+      //
+      // The primary key (id) is managed by the undo_index.  The id's are assigned sequentially to
+      // objects in the order of insertion.  User code MUST NOT modify the primary key.
+      // A given id can only be reused if its insertion is undone.
+      //
+      // Each undo session remembers the state of the table at the point when it was created.
+      //
+      // Within the undo state at the top of the undo stack:
+      // A primary key is new if it is at least old_next_id.
+      //
+      // A primary key is removed if it exists in the removed_values list before removed_values_end.
+      // A node has a flag which indicates whether it has been removed.
+      //
+      // A primary key is modified if it exists in the old_values list before old_values_end
+      //
+      // A primary key exists at most once in either the main table or removed values.
+      // Every primary key in old_values also exists in either the main table OR removed_values.
+      // If a primary key exists in both removed_values AND old_values, undo will restore the value from old_values.
+      // A primary key may appear in old_values any number of times.  If it appears more than once
+      //   within a single undo session, undo will restore the oldest value.
+      //
+      // The following describes the minimal set of operations required to maintain the undo stack:
+      // start session: remember next_id and the current heads of old_values and removed_values.
+      // squash: drop the last undo state
+      // create: nop
+      // modify: push a copy of the object onto old_values
+      // remove: move node to removed index and set removed flag
+      //
+      // Operations on a given key MUST always follow the sequence: CREATE MODIFY* REMOVE?
+      // When undoing multiple operations on the same key, the final result is determined
+      // by the oldest operation.  Therefore, the following optimizations can be applied:
+      //  - A primary key which is new may be discarded from old_values and removed_values
+      //  - If a primary key has multiple modifications, all but the oldest can be discarded.
+      //  - If a primary key is both modified and removed, the modified value can replace
+      //    the removed value, and can then be discarded.
+      // These optimizations may be applied at any time, but are not required by the class
+      // invariants.
+      //
+      // Notes regarding memory:
+      // Nodes in the main table share the same layout as nodes in removed_values and may
+      // be freely moved between the two.  This permits undo to restore removed nodes
+      // without allocating memory.
+      //
+      struct undo_state
+      {
+         typename std::allocator_traits<Allocator>::pointer old_values_end;
+         typename std::allocator_traits<Allocator>::pointer removed_values_end;
+         id_type old_next_id = 0;
+         uint64_t ctime = 0;  // _monotonic_revision at the point the undo_state was created
+      };
+
+      // Exception safety: strong
+      template <typename Constructor>
+      const value_type& emplace(Constructor&& c)
+      {
+         auto p = alloc_traits::allocate(_allocator, 1);
+         auto guard0 = scope_exit{[&] { alloc_traits::deallocate(_allocator, p, 1); }};
+         auto new_id = _next_id;
+         auto constructor = [&](value_type& v) {
+            v.id = new_id;
+            c(v);
+         };
+         alloc_traits::construct(_allocator, &*p, constructor, propagate_allocator(_allocator));
+         auto guard1 = scope_exit{[&] { alloc_traits::destroy(_allocator, &*p); }};
+         if (!insert_impl<1>(p->_item))
+            eosio::check(
+                false, "could not insert object, most likely a uniqueness constraint was violated");
+         std::get<0>(_indices).push_back(
+             p->_item);  // cannot fail and we know that it will definitely insert at the end.
+         on_create(p->_item);
+         ++_next_id;
+         guard1.cancel();
+         guard0.cancel();
+         return p->_item;
+      }
+
+      // Exception safety: basic.
+      // If the modifier leaves the object in a state that conflicts
+      // with another object, it will either be reverted or erased.
+      template <typename Modifier>
+      void modify(const value_type& obj, Modifier&& m)
+      {
+         value_type* backup = on_modify(obj);
+         value_type& node_ref = const_cast<value_type&>(obj);
+         bool success = false;
+         {
+            auto guard0 = scope_exit{[&] {
+               if (!post_modify<true, 1>(node_ref))
+               {  // The object id cannot be modified
+                  if (backup)
+                  {
+                     node_ref = std::move(*backup);
+                     bool success = post_modify<true, 1>(node_ref);
+                     (void)success;
+                     assert(success);
+                     assert(backup == &_old_values.front());
+                     _old_values.pop_front_and_dispose([this](pointer p) { dispose_old(*p); });
+                  }
+                  else
+                  {
+                     remove(obj);
+                  }
+               }
+               else
+               {
+                  success = true;
+               }
+            }};
+            auto old_id = obj.id;
+            m(node_ref);
+            (void)old_id;
+            assert(obj.id == old_id);
+         }
+         if (!success)
+            eosio::check(
+                false, "could not modify object, most likely a uniqueness constraint was violated");
+      }
+
+      // Allows testing whether a value has been removed from the undo_index.
+      //
+      // The lifetime of an object removed through a removed_nodes_tracker
+      // does not end before the removed_nodes_tracker is destroyed or invalidated.
+      //
+      // A removed_nodes_tracker is invalidated by the following members of undo_index:
+      // start_undo_session, commit, squash, and undo.
+      class removed_nodes_tracker
+      {
+        public:
+         explicit removed_nodes_tracker(undo_index& idx) : _self(&idx) {}
+         ~removed_nodes_tracker()
+         {
+            _removed_values.clear_and_dispose(
+                [this](value_type* obj) { _self->dispose_node(*obj); });
+         }
+         removed_nodes_tracker(const removed_nodes_tracker&) = delete;
+         removed_nodes_tracker& operator=(const removed_nodes_tracker&) = delete;
+         bool is_removed(const value_type& obj) const
+         {
+            return undo_index::get_removed_field(obj) == erased_flag;
+         }
+         // Must be used in place of undo_index::remove
+         void remove(const value_type& obj) { _self->remove(obj, *this); }
+
+        private:
+         friend class undo_index;
+         void save(value_type& obj)
+         {
+            undo_index::get_removed_field(obj) = erased_flag;
+            _removed_values.push_front(obj);
+         }
+         undo_index* _self;
+         list_base<node, index0_type> _removed_values;
+      };
+      auto track_removed() { return removed_nodes_tracker(*this); }
+
+      void remove(const value_type& obj) noexcept
+      {
+         auto& node_ref = const_cast<value_type&>(obj);
+         erase_impl(node_ref);
+         if (on_remove(node_ref))
+         {
+            dispose_node(node_ref);
+         }
+      }
+
+     private:
+      void remove(const value_type& obj, removed_nodes_tracker& tracker) noexcept
+      {
+         auto& node_ref = const_cast<value_type&>(obj);
+         erase_impl(node_ref);
+         if (on_remove(node_ref))
+         {
+            tracker.save(node_ref);
+         }
+      }
+
+     public:
+      template <typename CompatibleKey>
+      const value_type* find(CompatibleKey&& key) const
+      {
+         const auto& index = std::get<0>(_indices);
+         auto iter = index.find(static_cast<CompatibleKey&&>(key));
+         if (iter != index.end())
+         {
+            return &*iter;
+         }
+         else
+         {
+            return nullptr;
+         }
+      }
+
+      template <typename CompatibleKey>
+      const value_type& get(CompatibleKey&& key) const
+      {
+         auto ptr = find(static_cast<CompatibleKey&&>(key));
+         if (!ptr)
+         {
+            std::stringstream ss;
+            ss << "key not found (" << boost::core::demangle(typeid(key).name()) << "): " << key;
+            eosio::check(false, ss.str());
+         }
+         return *ptr;
+      }
+
+      void remove_object(int64_t id)
+      {
+         const value_type* val = find(typename value_type::id_type(id));
+         if (!val)
+            eosio::check(false, "key not found: " + std::to_string(id));
+         remove(*val);
+      }
+
+      class session
+      {
+        public:
+         session(undo_index& idx, bool enabled) : _index(idx), _apply(enabled)
+         {
+            if (enabled)
+               idx.add_session();
+         }
+         session(session&& other) : _index(other._index), _apply(other._apply)
+         {
+            other._apply = false;
+         }
+         session& operator=(session&& other)
+         {
+            if (this != &other)
+            {
+               undo();
+               _apply = other._apply;
+               other._apply = false;
+            }
+            return *this;
+         }
+         ~session()
+         {
+            if (_apply)
+               _index.undo();
+         }
+         void push() { _apply = false; }
+         void squash()
+         {
+            if (_apply)
+               _index.squash();
+            _apply = false;
+         }
+         void undo()
+         {
+            if (_apply)
+               _index.undo();
+            _apply = false;
+         }
+
+        private:
+         undo_index& _index;
+         bool _apply = true;
+      };
+
+      int64_t revision() const { return _revision; }
+
+      session start_undo_session(bool enabled) { return session{*this, enabled}; }
+
+      void set_revision(uint64_t revision)
+      {
+         if (_undo_stack.size() != 0)
+            eosio::check(false, "cannot set revision while there is an existing undo stack");
+
+         if (revision > std::numeric_limits<int64_t>::max())
+            eosio::check(false, "revision to set is too high");
+
+         if (static_cast<int64_t>(revision) < _revision)
+            eosio::check(false, "revision cannot decrease");
+
+         _revision = static_cast<int64_t>(revision);
+      }
+
+      std::pair<int64_t, int64_t> undo_stack_revision_range() const
+      {
+         return {_revision - _undo_stack.size(), _revision};
+      }
+
+      /**
+       * Discards all undo history prior to revision
+       */
+      void commit(int64_t revision) noexcept
+      {
+         revision = std::min(revision, _revision);
+         if (revision == _revision)
+         {
+            dispose_undo();
+            _undo_stack.clear();
+         }
+         else if (static_cast<uint64_t>(_revision - revision) < _undo_stack.size())
+         {
+            auto iter = _undo_stack.begin() + (_undo_stack.size() - (_revision - revision));
+            dispose(get_old_values_end(*iter), get_removed_values_end(*iter));
+            _undo_stack.erase(_undo_stack.begin(), iter);
+         }
+      }
+
+      const undo_index& indices() const { return *this; }
+      template <typename Tag>
+      const auto& get() const
+      {
+         return std::get<find_tag<Tag, Indices...>::value>(_indices);
+      }
+
+      template <int N>
+      const auto& get() const
+      {
+         return std::get<N>(_indices);
+      }
+
+      std::size_t size() const { return std::get<0>(_indices).size(); }
+
+      bool empty() const { return std::get<0>(_indices).empty(); }
+
+      template <typename Tag, typename Iter>
+      auto project(Iter iter) const
+      {
+         return project<find_tag<Tag, Indices...>::value>(iter);
+      }
+
+      template <int N, typename Iter>
+      auto project(Iter iter) const
+      {
+         if (iter == get<boost::mp11::mp_find<
+                         boost::mp11::mp_list<typename set_impl<node, Indices>::const_iterator...>,
+                         Iter>::value>()
+                         .end())
+            return get<N>().end();
+         return get<N>().iterator_to(*iter);
+      }
+
+      bool has_undo_session() const { return !_undo_stack.empty(); }
+
+      struct delta
+      {
+         boost::mpl::iterator_range<typename index0_set_type::const_iterator> new_values;
+         boost::mpl::iterator_range<typename list_base<old_node, index0_type>::const_iterator>
+             old_values;
+         boost::mpl::iterator_range<typename list_base<node, index0_type>::const_iterator>
+             removed_values;
+      };
+
+      delta last_undo_session() const
+      {
+         if (_undo_stack.empty())
+            return {{get<0>().end(), get<0>().end()},
+                    {_old_values.end(), _old_values.end()},
+                    {_removed_values.end(), _removed_values.end()}};
+         // Warning: This is safe ONLY as long as nothing exposes the undo stack to client code.
+         // Compressing the undo stack does not change the logical state of the undo_index.
+         const_cast<undo_index*>(this)->compress_last_undo_session();
+         return {{get<0>().lower_bound(_undo_stack.back().old_next_id), get<0>().end()},
+                 {_old_values.begin(), get_old_values_end(_undo_stack.back())},
+                 {_removed_values.begin(), get_removed_values_end(_undo_stack.back())}};
+      }
+
+      auto begin() const { return get<0>().begin(); }
+      auto end() const { return get<0>().end(); }
+
+      void undo_all()
+      {
+         while (!_undo_stack.empty())
+         {
+            undo();
+         }
+      }
+
+      // Resets the contents to the state at the top of the undo stack.
+      void undo() noexcept
+      {
+         if (_undo_stack.empty())
+            return;
+         undo_state& undo_info = _undo_stack.back();
+         // erase all new_ids
+         auto& by_id = std::get<0>(_indices);
+         auto new_ids_iter = by_id.lower_bound(undo_info.old_next_id);
+         by_id.erase_and_dispose(new_ids_iter, by_id.end(), [this](pointer p) {
+            erase_impl<1>(*p);
+            dispose_node(*p);
+         });
+         // replace old_values
+         _old_values.erase_after_and_dispose(
+             _old_values.before_begin(), get_old_values_end(undo_info),
+             [this, &undo_info](pointer p) {
+                auto restored_mtime = to_old_node(*p)._mtime;
+                // Skip restoring values that overwrite an earlier modify in the same session.
+                // Duplicate modifies can only happen because of squash.
+                if (restored_mtime < undo_info.ctime)
+                {
+                   auto iter = &to_old_node(*p)._current->_item;
+                   *iter = std::move(*p);
+                   auto& node_mtime = to_node(*iter)._mtime;
+                   node_mtime = restored_mtime;
+                   if (get_removed_field(*iter) != erased_flag)
+                   {
+                      // Non-unique items are transient and are guaranteed to be fixed
+                      // by the time we finish processing old_values.
+                      post_modify<false, 1>(*iter);
+                   }
+                   else
+                   {
+                      // The item was removed.  It will be inserted when we process removed_values
+                   }
+                }
+                dispose_old(*p);
+             });
+         // insert all removed_values
+         _removed_values.erase_after_and_dispose(
+             _removed_values.before_begin(), get_removed_values_end(undo_info),
+             [this, &undo_info](pointer p) {
+                if (p->id < undo_info.old_next_id)
+                {
+                   get_removed_field(*p) =
+                       0;  // Will be overwritten by tree algorithms, because we're reusing the color.
+                   insert_impl(*p);
+                }
+                else
+                {
+                   dispose_node(*p);
+                }
+             });
+         _next_id = undo_info.old_next_id;
+         _undo_stack.pop_back();
+         --_revision;
+      }
+
+      // Combines the top two states on the undo stack
+      void squash() noexcept { squash_and_compress(); }
+
+      void squash_fast() noexcept
+      {
+         if (_undo_stack.empty())
+         {
+            return;
+         }
+         else if (_undo_stack.size() == 1)
+         {
+            dispose_undo();
+         }
+         _undo_stack.pop_back();
+         --_revision;
+      }
+
+      void squash_and_compress() noexcept
+      {
+         if (_undo_stack.size() >= 2)
+         {
+            compress_impl(_undo_stack[_undo_stack.size() - 2]);
+         }
+         squash_fast();
+      }
+
+      void compress_last_undo_session() noexcept { compress_impl(_undo_stack.back()); }
+
+     private:
+      // Removes elements of the last undo session that would be redundant
+      // if all the sessions after @c session were squashed.
+      //
+      // WARNING: This function leaves any undo sessions after @c session in
+      // an indeterminate state.  The caller MUST use squash to restore the
+      // undo stack to a sane state.
+      void compress_impl(undo_state& session) noexcept
+      {
+         auto session_start = session.ctime;
+         auto old_next_id = session.old_next_id;
+         remove_if_after_and_dispose(
+             _old_values, _old_values.before_begin(), get_old_values_end(_undo_stack.back()),
+             [session_start](value_type& v) {
+                if (to_old_node(v)._mtime >= session_start)
+                   return true;
+                auto& item = to_old_node(v)._current->_item;
+                if (get_removed_field(item) == erased_flag)
+                {
+                   item = std::move(v);
+                   to_node(item)._mtime = to_old_node(v)._mtime;
+                   return true;
+                }
+                return false;
+             },
+             [&](pointer p) { dispose_old(*p); });
+         remove_if_after_and_dispose(
+             _removed_values, _removed_values.before_begin(),
+             get_removed_values_end(_undo_stack.back()),
+             [old_next_id](value_type& v) { return v.id >= old_next_id; },
+             [this](pointer p) { dispose_node(*p); });
+      }
+
+      // starts a new undo session.
+      // Exception safety: strong
+      int64_t add_session()
+      {
+         _undo_stack.emplace_back();
+         _undo_stack.back().old_values_end = _old_values.empty() ? nullptr : &*_old_values.begin();
+         _undo_stack.back().removed_values_end =
+             _removed_values.empty() ? nullptr : &*_removed_values.begin();
+         _undo_stack.back().old_next_id = _next_id;
+         _undo_stack.back().ctime = ++_monotonic_revision;
+         return ++_revision;
+      }
+
+      template <int N = 0>
+      bool insert_impl(value_type& p)
+      {
+         if constexpr (N < sizeof...(Indices))
+         {
+            auto [iter, inserted] = std::get<N>(_indices).insert_unique(p);
+            if (!inserted)
+               return false;
+            auto guard = scope_exit{[this, iter = iter] { std::get<N>(_indices).erase(iter); }};
+            if (insert_impl<N + 1>(p))
+            {
+               guard.cancel();
+               return true;
+            }
+            return false;
+         }
+         return true;
+      }
+
+      // Moves a modified node into the correct location
+      template <bool unique, int N = 0>
+      bool post_modify(value_type& p)
+      {
+         if constexpr (N < sizeof...(Indices))
+         {
+            auto& idx = std::get<N>(_indices);
+            auto iter = idx.iterator_to(p);
+            bool fixup = false;
+            if (iter != idx.begin())
+            {
+               auto copy = iter;
+               --copy;
+               if (!idx.value_comp()(*copy, p))
+                  fixup = true;
+            }
+            ++iter;
+            if (iter != idx.end())
+            {
+               if (!idx.value_comp()(p, *iter))
+                  fixup = true;
+            }
+            if (fixup)
+            {
+               auto iter2 = idx.iterator_to(p);
+               idx.erase(iter2);
+               if constexpr (unique)
+               {
+                  auto [new_pos, inserted] = idx.insert_unique(p);
+                  if (!inserted)
+                  {
+                     idx.insert_before(new_pos, p);
+                     return false;
+                  }
+               }
+               else
+               {
+                  idx.insert_equal(p);
+               }
+            }
+            return post_modify<unique, N + 1>(p);
+         }
+         return true;
+      }
+
+      template <int N = 0>
+      void erase_impl(value_type& p)
+      {
+         if constexpr (N < sizeof...(Indices))
+         {
+            auto& setN = std::get<N>(_indices);
+            setN.erase(setN.iterator_to(p));
+            erase_impl<N + 1>(p);
+         }
+      }
+
+      void on_create(const value_type& value) noexcept
+      {
+         if (!_undo_stack.empty())
+         {
+            // Not in old_values, removed_values, or new_ids
+            to_node(value)._mtime = _monotonic_revision;
+         }
+      }
+
+      value_type* on_modify(const value_type& obj)
+      {
+         if (!_undo_stack.empty())
+         {
+            auto& undo_info = _undo_stack.back();
+            if (to_node(obj)._mtime >= undo_info.ctime)
+            {
+               // Nothing to do
+            }
+            else
+            {
+               // Not in removed_values
+               auto p = old_alloc_traits::allocate(_old_values_allocator, 1);
+               auto guard0 = scope_exit{[&] { _old_values_allocator.deallocate(p, 1); }};
+               old_alloc_traits::construct(_old_values_allocator, &*p, obj);
+               p->_mtime = to_node(obj)._mtime;
+               p->_current = &to_node(obj);
+               guard0.cancel();
+               _old_values.push_front(p->_item);
+               to_node(obj)._mtime = _monotonic_revision;
+               return &p->_item;
+            }
+         }
+         return nullptr;
+      }
+      template <int N = 0>
+      void clear_impl() noexcept
+      {
+         if constexpr (N < sizeof...(Indices))
+         {
+            std::get<N>(_indices).clear();
+            clear_impl<N + 1>();
+         }
+      }
+      void dispose_node(node& node_ref) noexcept
+      {
+         node* p{&node_ref};
+         alloc_traits::destroy(_allocator, p);
+         alloc_traits::deallocate(_allocator, p, 1);
+      }
+      void dispose_node(value_type& node_ref) noexcept
+      {
+         dispose_node(static_cast<node&>(*boost::intrusive::get_parent_from_member(
+             &node_ref, &value_holder<value_type>::_item)));
+      }
+      void dispose_old(old_node& node_ref) noexcept
+      {
+         old_node* p{&node_ref};
+         old_alloc_traits::destroy(_old_values_allocator, p);
+         old_alloc_traits::deallocate(_old_values_allocator, p, 1);
+      }
+      void dispose_old(value_type& node_ref) noexcept
+      {
+         dispose_old(static_cast<old_node&>(*boost::intrusive::get_parent_from_member(
+             &node_ref, &value_holder<value_type>::_item)));
+      }
+      void dispose(typename list_base<old_node, index0_type>::iterator old_start,
+                   typename list_base<node, index0_type>::iterator removed_start) noexcept
+      {
+         // This will leave one element around.  That's okay, because we'll clean it up the next time.
+         if (old_start != _old_values.end())
+            _old_values.erase_after_and_dispose(old_start, _old_values.end(),
+                                                [this](pointer p) { dispose_old(*p); });
+         if (removed_start != _removed_values.end())
+            _removed_values.erase_after_and_dispose(removed_start, _removed_values.end(),
+                                                    [this](pointer p) { dispose_node(*p); });
+      }
+      void dispose_undo() noexcept
+      {
+         _old_values.clear_and_dispose([this](pointer p) { dispose_old(*p); });
+         _removed_values.clear_and_dispose([this](pointer p) { dispose_node(*p); });
+      }
+      static node& to_node(value_type& obj)
+      {
+         return static_cast<node&>(
+             *boost::intrusive::get_parent_from_member(&obj, &value_holder<value_type>::_item));
+      }
+      static node& to_node(const value_type& obj) { return to_node(const_cast<value_type&>(obj)); }
+      static old_node& to_old_node(value_type& obj)
+      {
+         return static_cast<old_node&>(
+             *boost::intrusive::get_parent_from_member(&obj, &value_holder<value_type>::_item));
+      }
+
+      auto get_old_values_end(const undo_state& info)
+      {
+         if (info.old_values_end == nullptr)
+         {
+            return _old_values.end();
+         }
+         else
+         {
+            return _old_values.iterator_to(*info.old_values_end);
+         }
+      }
+
+      auto get_old_values_end(const undo_state& info) const
+      {
+         return static_cast<decltype(_old_values.cend())>(
+             const_cast<undo_index*>(this)->get_old_values_end(info));
+      }
+
+      auto get_removed_values_end(const undo_state& info)
+      {
+         if (info.removed_values_end == nullptr)
+         {
+            return _removed_values.end();
+         }
+         else
+         {
+            return _removed_values.iterator_to(*info.removed_values_end);
+         }
+      }
+
+      auto get_removed_values_end(const undo_state& info) const
+      {
+         return static_cast<decltype(_removed_values.cend())>(
+             const_cast<undo_index*>(this)->get_removed_values_end(info));
+      }
+
+      // returns true if the node should be destroyed
+      bool on_remove(value_type& obj)
+      {
+         if (!_undo_stack.empty())
+         {
+            auto& undo_info = _undo_stack.back();
+            if (obj.id >= undo_info.old_next_id)
+            {
+               return true;
+            }
+            get_removed_field(obj) = erased_flag;
+
+            _removed_values.push_front(obj);
+            return false;
+         }
+         return true;
+      }
+      // Returns the field indicating whether the node has been removed
+      static int& get_removed_field(const value_type& obj)
+      {
+         return static_cast<hook<index0_type, Allocator>&>(to_node(obj))._color;
+      }
+      using old_alloc_traits =
+          typename std::allocator_traits<Allocator>::template rebind_traits<old_node>;
+      indices_type _indices;
+      boost::container::deque<undo_state, rebind_alloc_t<Allocator, undo_state>> _undo_stack;
+      list_base<old_node, index0_type> _old_values;
+      list_base<node, index0_type> _removed_values;
+      rebind_alloc_t<Allocator, node> _allocator;
+      rebind_alloc_t<Allocator, old_node> _old_values_allocator;
+      id_type _next_id = 0;
+      int64_t _revision = 0;
+      uint64_t _monotonic_revision = 0;
+      uint32_t _size_of_value_type = sizeof(node);
+      uint32_t _size_of_this = sizeof(undo_index);
+   };
+
+   template <typename MultiIndexContainer>
+   struct multi_index_to_undo_index_impl;
+
+   template <typename T, typename I, typename A>
+   struct mi_to_ui_ii;
+   template <typename T, typename... I, typename A>
+   struct mi_to_ui_ii<T, boost::mp11::mp_list<I...>, A>
+   {
+      using type = undo_index<T, A, I...>;
+   };
+
+   struct to_mp11
+   {
+      template <typename State, typename T>
+      using apply = boost::mpl::identity<boost::mp11::mp_push_back<State, T>>;
+   };
+
+   template <typename T, typename I, typename A>
+   struct multi_index_to_undo_index_impl<boost::multi_index_container<T, I, A>>
+   {
+      using as_mp11 = typename boost::mpl::fold<I, boost::mp11::mp_list<>, to_mp11>::type;
+      using type = typename mi_to_ui_ii<T, as_mp11, A>::type;
+   };
+
+   // Converts a multi_index_container to a corresponding undo_index.
+   template <typename MultiIndexContainer>
+   using multi_index_to_undo_index =
+       typename multi_index_to_undo_index_impl<MultiIndexContainer>::type;
+}  // namespace chainbase
diff --git a/libraries/clchain/include/clchain/crypto.hpp b/libraries/clchain/include/clchain/crypto.hpp
new file mode 100644
index 000000000..3279b6860
--- /dev/null
+++ b/libraries/clchain/include/clchain/crypto.hpp
@@ -0,0 +1,8 @@
+#pragma once
+
+#include <eosio/fixed_bytes.hpp>
+
+namespace clchain
+{
+   eosio::checksum256 sha256(const char* data, uint32_t length);
+}
diff --git a/libraries/clchain/include/clchain/graphql.hpp b/libraries/clchain/include/clchain/graphql.hpp
new file mode 100644
index 000000000..f1cb80b1c
--- /dev/null
+++ b/libraries/clchain/include/clchain/graphql.hpp
@@ -0,0 +1,834 @@
+#pragma once
+
+#include <cctype>
+#include <charconv>
+#include <eosio/bytes.hpp>
+#include <eosio/fixed_bytes.hpp>
+#include <eosio/for_each_field.hpp>
+#include <eosio/name.hpp>
+#include <eosio/stream.hpp>
+#include <eosio/time.hpp>
+#include <eosio/types.hpp>
+#include <set>
+#include <typeindex>
+
+namespace clchain
+{
+   struct gql_stream;
+}
+
+namespace eosio
+{
+   template <typename T>
+   constexpr bool use_json_string_for_gql(T*)
+   {
+      return false;
+   }
+
+   inline constexpr bool use_json_string_for_gql(bytes*) { return true; }
+   inline constexpr bool use_json_string_for_gql(name*) { return true; }
+   inline constexpr bool use_json_string_for_gql(time_point*) { return true; }
+
+   template <typename T, std::size_t Size>
+   constexpr bool use_json_string_for_gql(fixed_bytes<Size, T>*)
+   {
+      return true;
+   }
+
+   template <typename T>
+   auto get_gql_name(T*) -> std::enable_if_t<use_json_string_for_gql((T*)nullptr), const char*>
+   {
+      return "String";
+   }
+
+   template <typename T, typename OS, typename E>
+   auto gql_query(const T& value,
+                  clchain::gql_stream& input_stream,
+                  OS& output_stream,
+                  const E& error) -> std::enable_if_t<use_json_string_for_gql((T*)nullptr), bool>
+   {
+      to_json(value, output_stream);
+      return true;
+   }
+}  // namespace eosio
+
+namespace clchain
+{
+   template <typename T>
+   struct has_get_gql_name
+   {
+     private:
+      template <typename C>
+      static char test(decltype(get_gql_name((C*)nullptr))*);
+
+      template <typename C>
+      static long test(...);
+
+     public:
+      static constexpr bool value = sizeof(test<T>((const char**)nullptr)) == sizeof(char);
+   };
+
+   template <typename Raw>
+   std::string generate_gql_whole_name(Raw*, bool is_optional = false);
+
+   template <typename Raw>
+   std::string generate_gql_partial_name(Raw*)
+   {
+      using T = eosio::remove_cvref_t<Raw>;
+      if constexpr (std::is_same_v<T, bool>)
+         return "Boolean";
+      else if constexpr (std::is_integral_v<T>)
+      {
+         if constexpr (std::is_signed_v<T> && sizeof(T) <= 4)
+            return "Int";
+         else if constexpr (std::is_unsigned_v<T> && sizeof(T) <= 2)
+            return "Int";
+         else if constexpr (sizeof(T) <= 4)
+            return "Float";
+         else
+            return "String";
+      }
+      else if constexpr (std::is_same_v<T, float> || std::is_same_v<T, double>)
+         return "Float";
+      else if constexpr (std::is_same_v<T, std::string>)
+         return "String";
+      else if constexpr (eosio::is_serializable_container<T>())
+         return "[" + generate_gql_whole_name((typename T::value_type*)nullptr) + "]";
+      else if constexpr (eosio::reflection::has_for_each_field_v<T> && !has_get_gql_name<T>::value)
+         return get_type_name((T*)nullptr);
+      else
+         return get_gql_name((T*)nullptr);
+   }
+
+   template <typename Raw>
+   std::string generate_gql_whole_name(Raw*, bool is_optional)
+   {
+      using T = eosio::remove_cvref_t<Raw>;
+      if constexpr (eosio::is_std_optional<T>())
+         return generate_gql_whole_name((typename T::value_type*)nullptr, true);
+      else if constexpr (std::is_pointer<T>())
+         return generate_gql_whole_name((T) nullptr, true);
+      else if constexpr (eosio::is_std_unique_ptr<T>())
+         return generate_gql_whole_name((typename T::element_type*)nullptr, true);
+      else if constexpr (eosio::is_std_reference_wrapper<T>())
+         return generate_gql_whole_name((typename T::type*)nullptr, false);
+      else if (is_optional)
+         return generate_gql_partial_name((Raw*)nullptr);
+      else
+         return generate_gql_partial_name((Raw*)nullptr) + "!";
+   }
+
+   template <typename Raw, typename S>
+   void fill_gql_schema(Raw*, S& stream, std::set<std::type_index>& defined_types)
+   {
+      using T = eosio::remove_cvref_t<Raw>;
+      if constexpr (eosio::is_std_optional<T>())
+         fill_gql_schema((typename T::value_type*)nullptr, stream, defined_types);
+      else if constexpr (std::is_pointer<T>())
+         fill_gql_schema((T) nullptr, stream, defined_types);
+      else if constexpr (eosio::is_std_unique_ptr<T>())
+         fill_gql_schema((typename T::element_type*)nullptr, stream, defined_types);
+      else if constexpr (eosio::is_std_reference_wrapper<T>())
+         fill_gql_schema((typename T::type*)nullptr, stream, defined_types);
+      else if constexpr (eosio::is_serializable_container<T>())
+         fill_gql_schema((typename T::value_type*)nullptr, stream, defined_types);
+      else if constexpr (eosio::reflection::has_for_each_field_v<T> && !has_get_gql_name<T>::value)
+      {
+         if (defined_types.insert(typeid(T)).second)
+         {
+            eosio::for_each_field<T>([&](const char*, auto member) {
+               fill_gql_schema((eosio::remove_cvref_t<decltype(member((T*)nullptr))>*)nullptr,
+                               stream, defined_types);
+            });
+            eosio::for_each_method<T>([&](const char* name, auto member, auto... arg_names) {
+               using mf = eosio::member_fn<decltype(member)>;
+               using ret = eosio::remove_cvref_t<typename mf::return_type>;
+               if constexpr (mf::is_const)
+               {
+                  eosio::for_each_named_type(
+                      [&](auto* p, const char*) {  //
+                         fill_gql_schema(p, stream, defined_types);
+                      },
+                      typename mf::arg_types{}, arg_names...);
+                  fill_gql_schema((ret*)nullptr, stream, defined_types);
+               }
+            });
+            write_str("type ", stream);
+            write_str(generate_gql_partial_name((Raw*)nullptr), stream);
+            write_str(" {\n", stream);
+            eosio::for_each_field<T>([&](const char* name, auto member) {
+               write_str("    ", stream);
+               write_str(name, stream);
+               write_str(": ", stream);
+               write_str(generate_gql_whole_name(
+                             (eosio::remove_cvref_t<decltype(member((T*)nullptr))>*)nullptr),
+                         stream);
+               write_str("\n", stream);
+            });
+            eosio::for_each_method<T>([&](const char* name, auto member, auto... arg_names) {
+               using mf = eosio::member_fn<decltype(member)>;
+               using ret = eosio::remove_cvref_t<typename mf::return_type>;
+               if constexpr (mf::is_const)
+               {
+                  write_str("    ", stream);
+                  write_str(name, stream);
+                  if constexpr (mf::arg_types::size > 0)
+                  {
+                     write_str("(", stream);
+                     bool first = true;
+                     eosio::for_each_named_type(
+                         [&](auto* p, const char* name) {
+                            if (!first)
+                               write_str(" ", stream);
+                            write_str(name, stream);
+                            write_str(": ", stream);
+                            write_str(generate_gql_whole_name(p), stream);
+                            first = false;
+                         },
+                         typename mf::arg_types{}, arg_names...);
+                     write_str(")", stream);
+                  }
+                  write_str(": ", stream);
+                  write_str(generate_gql_whole_name((ret*)nullptr), stream);
+                  write_str("\n", stream);
+               }
+            });
+            write_str("}\n", stream);
+         }
+      }
+   }
+
+   template <typename Raw, typename S>
+   void fill_gql_schema(Raw*, S& stream)
+   {
+      std::set<std::type_index> defined_types;
+      fill_gql_schema((Raw*)nullptr, stream, defined_types);
+   }
+
+   template <typename T>
+   std::string get_gql_schema(T* p = nullptr)
+   {
+      eosio::size_stream ss;
+      fill_gql_schema((T*)nullptr, ss);
+      std::string result(ss.size, 0);
+      eosio::fixed_buf_stream fbs(result.data(), result.size());
+      fill_gql_schema((T*)nullptr, fbs);
+      eosio::check(fbs.pos == fbs.end, eosio::convert_stream_error(eosio::stream_error::underrun));
+      return result;
+   }
+
+   struct gql_stream
+   {
+      enum token_type
+      {
+         unstarted,
+         eof,
+         error,
+         punctuator,
+         name,
+         string,
+         integer,
+         floating,
+      };
+
+      eosio::input_stream input;
+      token_type current_type = unstarted;
+      std::string_view current_value;
+      char current_puncuator = 0;
+
+      gql_stream(eosio::input_stream input) : input{input} { skip(); }
+      gql_stream(const gql_stream&) = default;
+      gql_stream& operator=(const gql_stream&) = default;
+
+      void skip()
+      {
+         if (current_type == error)
+            return;
+         current_puncuator = 0;
+         current_value = {};
+         while (true)
+         {
+            auto begin = input.pos;
+            if (!input.remaining())
+            {
+               current_type = eof;
+               return;
+            }
+            switch ((uint8_t)input.pos[0])
+            {
+               case '\n':
+               case '\r':
+               case ' ':
+               case '\t':
+               case ',':
+                  ++input.pos;
+                  continue;
+               case 0xEF:
+                  // BOM
+                  if (input.remaining() >= 3 && (uint8_t)input.pos[1] == 0xBB &&
+                      (uint8_t)input.pos[2] == 0xBF)
+                  {
+                     input.pos += 3;
+                     continue;
+                  }
+                  break;
+               case '#':
+                  // note: Doesn't detect and reject code points that the GraphQL spec prohibits
+                  while (input.remaining() && (input.pos[0] != '\n' && input.pos[0] != '\r'))
+                     ++input.pos;
+                  continue;
+               case '$':
+               case '!':
+               case '&':
+               case '(':
+               case ')':
+               case ':':
+               case '=':
+               case '@':
+               case '[':
+               case ']':
+               case '{':
+               case '|':
+               case '}':
+                  current_puncuator = input.pos[0];
+                  ++input.pos;
+                  current_value = {begin, size_t(input.pos - begin)};
+                  current_type = punctuator;
+                  return;
+               case '.':
+                  if (input.remaining() >= 3 && input.pos[1] == '.' && input.pos[2] == '.')
+                  {
+                     current_puncuator = '.';
+                     input.pos += 3;
+                     current_value = {begin, size_t(input.pos - begin)};
+                     current_type = punctuator;
+                     return;
+                  }
+                  break;
+               case '"':
+                  // Notes:
+                  // * Block strings (""") not currently supported and escape processing not
+                  //   currently done; we may have to revisit this if we add either mutation
+                  //   support or searches through text fields, or if clients or client
+                  //   libraries end up using them unnecessarily
+                  // * Doesn't detect and reject unescaped code points that the GraphQL
+                  //   spec prohibits
+                  if (input.remaining() >= 3 && input.pos[1] == '"' && input.pos[2] == '"')
+                  {
+                     current_type = error;
+                     return;
+                  }
+                  ++input.pos;
+                  while (input.remaining() && input.pos[0] != '"')
+                  {
+                     auto ch = *input.pos++;
+                     if (ch == '\\')
+                     {
+                        if (!input.remaining())
+                           return;
+                        ++input.pos;
+                     }
+                  }
+                  if (!input.remaining())
+                     return;
+                  ++input.pos;
+                  current_value = {begin + 1, size_t(input.pos - begin - 2)};
+                  current_type = string;
+                  return;
+               default:;
+            }  // switch (input.pos[0])
+
+            if (input.pos[0] == '_' || std::isalpha((unsigned char)input.pos[0]))
+            {
+               while (input.remaining() &&
+                      (input.pos[0] == '_' || std::isalnum((unsigned char)input.pos[0])))
+                  ++input.pos;
+               current_value = {begin, size_t(input.pos - begin)};
+               current_type = name;
+               return;
+            }
+            else if (input.pos[0] == '-' || std::isdigit((unsigned char)input.pos[0]))
+            {
+               current_type = integer;
+               if (input.pos[0] == '-')
+               {
+                  ++input.pos;
+                  if (!input.remaining() || !std::isdigit((unsigned char)input.pos[0]))
+                  {
+                     current_type = error;
+                     return;
+                  }
+               }
+               if (input.pos[0] == '0')
+                  ++input.pos;
+               else
+                  while (input.remaining() && std::isdigit((unsigned char)input.pos[0]))
+                     ++input.pos;
+               if (input.remaining() && input.pos[0] == '.')
+               {
+                  ++input.pos;
+                  current_type = floating;
+                  if (!input.remaining() || !std::isdigit((unsigned char)input.pos[0]))
+                  {
+                     current_type = error;
+                     return;
+                  }
+                  while (input.remaining() && std::isdigit((unsigned char)input.pos[0]))
+                     ++input.pos;
+               }
+               if (input.remaining() && (input.pos[0] == 'e' || input.pos[0] == 'E'))
+               {
+                  ++input.pos;
+                  current_type = floating;
+                  if (input.remaining() && input.pos[0] == '-')
+                     ++input.pos;
+                  if (!input.remaining() || !std::isdigit((unsigned char)input.pos[0]))
+                  {
+                     current_type = error;
+                     return;
+                  }
+                  while (input.remaining() && std::isdigit((unsigned char)input.pos[0]))
+                     ++input.pos;
+               }
+               if (input.remaining() &&
+                   (input.pos[0] == '_' || std::isalnum((unsigned char)input.pos[0])))
+               {
+                  current_type = error;
+                  return;
+               }
+               current_value = {begin, size_t(input.pos - begin)};
+               return;
+            }  // numbers
+            else
+            {
+               current_value = {begin, size_t(input.pos - begin)};
+               current_type = error;
+               return;
+            }
+         }  // while (true)
+      }     // skip()
+   };       // gql_stream
+
+   template <typename E>
+   auto gql_parse_arg(std::string& arg, gql_stream& input_stream, const E& error)
+   {
+      if (input_stream.current_type == gql_stream::string)
+      {
+         arg = input_stream.current_value;
+         input_stream.skip();
+         return true;
+      }
+      return error("expected String");
+   }
+
+   template <typename T, typename E>
+   auto gql_parse_arg(T& arg, gql_stream& input_stream, const E& error)
+       -> std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, bool>, bool>
+   {
+      if constexpr (std::is_same_v<T, bool>)
+      {
+         if (input_stream.current_type == gql_stream::name && input_stream.current_value == "true")
+         {
+            input_stream.skip();
+            arg = true;
+            return true;
+         }
+         else if (input_stream.current_type == gql_stream::name &&
+                  input_stream.current_value == "false")
+         {
+            input_stream.skip();
+            arg = false;
+            return true;
+         }
+         else
+            return error("expected Boolean");
+      }
+      else
+      {
+         if (input_stream.current_type != gql_stream::integer &&
+             input_stream.current_type != gql_stream::floating &&
+             input_stream.current_type != gql_stream::string)
+            return error("expected number or stringified number");
+         auto begin = input_stream.current_value.data();
+         auto end = begin + input_stream.current_value.size();
+         auto result = std::from_chars<T>(begin, end, arg);
+         if (result.ec == std::errc{} && result.ptr == end)
+         {
+            input_stream.skip();
+            return true;
+         }
+         if (result.ec == std::errc::result_out_of_range)
+            return error("number is out of range");
+         return error("expected number or stringified number");
+      }
+   }
+
+   template <int i, typename... Args>
+   void gql_mark_optional(std::tuple<Args...>& args, bool filled[])
+   {
+      if constexpr (i < sizeof...(Args))
+      {
+         constexpr bool is_optional =
+             eosio::is_std_optional<eosio::remove_cvref_t<decltype(std::get<i>(args))>>();
+         if constexpr (is_optional)
+            filled[i] = true;
+         gql_mark_optional<i + 1>(args, filled);
+      }
+   }
+
+   template <int i, typename... Args, typename E, typename... Arg_names>
+   bool gql_parse_args(std::tuple<Args...>& args,
+                       bool filled[],
+                       bool& found,
+                       gql_stream& input_stream,
+                       const E& error,
+                       const char* arg_name,
+                       Arg_names... arg_names)
+   {
+      constexpr bool is_optional =
+          eosio::is_std_optional<eosio::remove_cvref_t<decltype(std::get<i>(args))>>();
+      if (input_stream.current_value != arg_name)
+         return gql_parse_args<i + 1>(args, filled, found, input_stream, error, arg_names...);
+      input_stream.skip();
+      if (input_stream.current_puncuator != ':')
+         return error("expected :");
+      if (filled[i])
+         return error("duplicate arg");
+      input_stream.skip();
+      if constexpr (is_optional)
+      {
+         if (input_stream.current_type == gql_stream::name && input_stream.current_value == "null")
+            input_stream.skip();
+         else
+         {
+            std::get<i>(args).emplace();
+            if (!gql_parse_arg(*std::get<i>(args), input_stream, error))
+               return false;
+         }
+      }
+      else if (!gql_parse_arg(std::get<i>(args), input_stream, error))
+         return false;
+      filled[i] = true;
+      found = true;
+      return true;
+   }
+
+   template <int i, typename... Args, typename E>
+   bool gql_parse_args(std::tuple<Args...>& args,
+                       bool filled[],
+                       bool& found,
+                       gql_stream& input_stream,
+                       const E& error)
+   {
+      static_assert(i == sizeof...(Args), "mismatched arg names");
+      return true;
+   }
+
+   template <typename E>
+   bool gql_skip_selection_set(gql_stream& input_stream, const E& error)
+   {
+      if (input_stream.current_puncuator != '{')
+         return true;
+      input_stream.skip();
+      while (true)
+      {
+         if (input_stream.current_type == gql_stream::eof)
+            return error("expected }");
+         else if (input_stream.current_puncuator == '{')
+         {
+            if (!gql_skip_selection_set(input_stream, error))
+               return false;
+         }
+         else if (input_stream.current_puncuator == '}')
+         {
+            input_stream.skip();
+            return true;
+         }
+         else
+            input_stream.skip();
+      }
+   }
+
+   template <typename T, typename OS, typename E>
+   auto gql_query(const T& value, gql_stream& input_stream, OS& output_stream, const E& error)
+       -> std::enable_if_t<std::is_arithmetic_v<T> || std::is_same_v<T, std::string>, bool>
+   {
+      eosio::to_json(value, output_stream);
+      return true;
+   }
+
+   template <typename T, typename OS, typename E>
+   auto gql_query(const T& value, gql_stream& input_stream, OS& output_stream, const E& error)
+       -> std::enable_if_t<eosio::is_std_optional<T>() || std::is_pointer<T>() ||
+                               eosio::is_std_unique_ptr<T>(),
+                           bool>
+   {
+      if (value)
+         return gql_query(*value, input_stream, output_stream, error);
+      write_str("null", output_stream);
+      return gql_skip_selection_set(input_stream, error);
+   }
+
+   template <typename T, typename OS, typename E>
+   auto gql_query(const T& value, gql_stream& input_stream, OS& output_stream, const E& error)
+       -> std::enable_if_t<eosio::is_std_reference_wrapper<T>::value, bool>
+   {
+      return gql_query(value.get(), input_stream, output_stream, error);
+   }
+
+   template <typename T, typename OS, typename E>
+   auto gql_query(const T& value, gql_stream& input_stream, OS& output_stream, const E& error)
+       -> std::enable_if_t<eosio::is_serializable_container<T>::value, bool>
+   {
+      output_stream.write('[');
+      bool first = true;
+      for (auto& v : value)
+      {
+         if (first)
+            increase_indent(output_stream);
+         else
+            output_stream.write(',');
+         write_newline(output_stream);
+         first = false;
+         auto copy = input_stream;
+         if (!gql_query(v, copy, output_stream, error))
+            return false;
+      }
+      if (!gql_skip_selection_set(input_stream, error))
+         return false;
+      if (!first)
+      {
+         decrease_indent(output_stream);
+         write_newline(output_stream);
+      }
+      output_stream.write(']');
+      return true;
+   }
+
+   template <typename Raw, typename OS, typename E>
+   auto gql_query(const Raw& value, gql_stream& input_stream, OS& output_stream, const E& error)
+       -> std::enable_if_t<eosio::reflection::has_for_each_field_v<Raw> &&
+                               !has_get_gql_name<Raw>::value,
+                           bool>
+   {
+      using T = eosio::remove_cvref_t<Raw>;
+      if (input_stream.current_puncuator != '{')
+         return error("expected {");
+      input_stream.skip();
+      bool first = true;
+      output_stream.write('{');
+      while (input_stream.current_type == gql_stream::name)
+      {
+         bool found = false;
+         bool ok = true;
+         auto alias = input_stream.current_value;
+         auto field_name = alias;
+         input_stream.skip();
+         if (input_stream.current_puncuator == ':')
+         {
+            input_stream.skip();
+            if (input_stream.current_type != gql_stream::name)
+               return error("expected name after :");
+            field_name = input_stream.current_value;
+            input_stream.skip();
+         }
+         eosio_for_each_field((T*)nullptr, [&](std::string_view name, auto&& member,
+                                               auto... arg_names) {
+            using member_type = decltype(member((T*)nullptr));
+            if constexpr (eosio::is_non_const_member_fn<member_type>())
+               return;
+            else
+            {
+               if (found)
+                  return;
+               if (name == field_name)
+               {
+                  found = true;
+                  if (first)
+                  {
+                     increase_indent(output_stream);
+                     first = false;
+                  }
+                  else
+                     output_stream.write(',');
+                  write_newline(output_stream);
+                  to_json(alias, output_stream);
+                  write_colon(output_stream);
+                  if constexpr (std::is_member_object_pointer_v<member_type>)
+                  {
+                     if (!gql_query(value.*member(&value), input_stream, output_stream, error))
+                        ok = false;
+                  }
+                  else
+                  {
+                     using mf = eosio::member_fn<member_type>;
+                     eosio::tuple_from_type_list<typename mf::arg_types> args;
+                     bool filled[mf::num_args] = {};
+                     if (input_stream.current_puncuator == '(')
+                     {
+                        input_stream.skip();
+                        if (input_stream.current_puncuator == ')')
+                           return (ok = error("empty arg list")), void();
+                        while (input_stream.current_type == gql_stream::name)
+                        {
+                           bool found = false;
+                           if (!gql_parse_args<0>(args, filled, found, input_stream, error,
+                                                  arg_names...))
+                              return (ok = false), void();
+                           if (!found)
+                              return (ok = error("unknown arg '" +
+                                                 (std::string)input_stream.current_value + "'")),
+                                     void();
+                        }
+                        if (input_stream.current_puncuator != ')')
+                           return (ok = error("expected )")), void();
+                        input_stream.skip();
+                     }
+                     gql_mark_optional<0>(args, filled);
+                     if constexpr (mf::num_args > 0)
+                        for (int i = 0; i < mf::num_args; ++i)
+                           if (!filled[i])
+                              return (ok = error("function missing required arg '" +
+                                                 std::string(std::data({arg_names...})[i]) + "'")),
+                                     void();
+                     auto result = std::apply(
+                         [&](auto&&... args) {
+                            return (value.*member(&value))(std::move(args)...);
+                         },
+                         args);
+                     if (!gql_query(result, input_stream, output_stream, error))
+                        return (ok = false), void();
+                  }
+               }
+            }
+         });
+         if (!ok)
+            return false;
+         if (!found)
+            return error((std::string)field_name + " not found");
+      }
+      if (input_stream.current_puncuator != '}')
+         return error("expected }");
+      input_stream.skip();
+      if (!first)
+      {
+         decrease_indent(output_stream);
+         write_newline(output_stream);
+      }
+      output_stream.write('}');
+      return true;
+   }
+
+   template <typename T, typename OS, typename E>
+   bool gql_query_root(const T& value, gql_stream& input_stream, OS& output_stream, const E& error)
+   {
+      if (input_stream.current_type == gql_stream::name)
+      {
+         if (input_stream.current_value == "query")
+         {
+            input_stream.skip();
+            if (input_stream.current_type == gql_stream::name)
+               input_stream.skip();
+            if (input_stream.current_puncuator == '(')
+               return error("variables not supported");
+            if (input_stream.current_puncuator == '@')
+               return error("directives not supported");
+         }
+         else if (input_stream.current_value == "subscriptions")
+            return error("subscriptions not supported");
+         else if (input_stream.current_value == "mutation")
+            return error("mutations not supported");
+         else if (input_stream.current_value == "fragment")
+            return error("fragments not supported");
+         else
+            return error("expected query");
+      }
+      if (!gql_query(value, input_stream, output_stream, error))
+         return false;
+      if (input_stream.current_type == gql_stream::eof)
+         return true;
+      if (input_stream.current_type == gql_stream::name)
+      {
+         if (input_stream.current_value == "query")
+            return error("multiple queries not supported");
+         if (input_stream.current_value == "fragment")
+            return error("fragments not supported");
+         if (input_stream.current_value == "subscription")
+            return error("subscriptions not supported");
+         if (input_stream.current_value == "mutation")
+            return error("mutations not supported");
+      }
+      return error("expected end of input");
+   }
+
+   template <typename Stream = eosio::time_point_include_z_stream<eosio::string_stream>, typename T>
+   std::string gql_query(const T& value, std::string_view query, std::string_view variables)
+   {
+      gql_stream input_stream{query};
+      std::string result;
+      Stream output_stream(result);
+      output_stream.write('{');
+      increase_indent(output_stream);
+      write_newline(output_stream);
+      write_str("\"data\": ", output_stream);
+      std::string error;
+      bool ok = true;
+      if (!variables.empty())
+      {
+         error = "variables not supported; argument must be empty";
+         ok = false;
+      }
+      else
+         ok = gql_query_root(value, input_stream, output_stream, [&](const auto& e) {
+            error = e;
+            return false;
+         });
+      if (!ok)
+      {
+         result.clear();
+         Stream error_stream(result);
+         error_stream.write('{');
+         increase_indent(error_stream);
+         write_newline(error_stream);
+         write_str("\"errors\": {", error_stream);
+         increase_indent(error_stream);
+         write_newline(error_stream);
+         write_str("\"message\": ", error_stream);
+         eosio::to_json(error, error_stream);
+         decrease_indent(error_stream);
+         write_newline(error_stream);
+         error_stream.write('}');
+         decrease_indent(error_stream);
+         write_newline(error_stream);
+         error_stream.write('}');
+         return result;
+      }
+      decrease_indent(output_stream);
+      write_newline(output_stream);
+      output_stream.write('}');
+      return result;
+   }
+
+   template <typename T>
+   std::string format_gql_query(const T& value, std::string_view query)
+   {
+      return gql_query<
+          eosio::time_point_include_z_stream<eosio::pretty_stream<eosio::string_stream>>>(value,
+                                                                                          query);
+   }
+}  // namespace clchain
+
+namespace eosio
+{
+   template <typename E>
+   auto gql_parse_arg(eosio::name& arg, clchain::gql_stream& input_stream, const E& error)
+   {
+      if (input_stream.current_type == clchain::gql_stream::string)
+      {
+         arg.value = eosio::string_to_name(input_stream.current_value);
+         input_stream.skip();
+         return true;
+      }
+      return error("expected String");
+   }
+}  // namespace eosio
diff --git a/libraries/clchain/include/clchain/graphql_connection.hpp b/libraries/clchain/include/clchain/graphql_connection.hpp
new file mode 100644
index 000000000..ef42b74d0
--- /dev/null
+++ b/libraries/clchain/include/clchain/graphql_connection.hpp
@@ -0,0 +1,161 @@
+#pragma once
+
+#include <clchain/graphql.hpp>
+#include <eosio/from_bin.hpp>
+#include <eosio/reflection2.hpp>
+#include <eosio/to_bin.hpp>
+
+namespace clchain
+{
+   struct PageInfo
+   {
+      bool hasPreviousPage = false;
+      bool hasNextPage = false;
+      std::string startCursor;
+      std::string endCursor;
+   };
+   EOSIO_REFLECT2(PageInfo, hasPreviousPage, hasNextPage, startCursor, endCursor)
+
+   template <typename T, const char* ConnectionName, const char* EdgeName>
+   struct ConnectionConfig
+   {
+      using value_type = T;
+      static constexpr const char* connection_name = ConnectionName;
+      static constexpr const char* edge_name = EdgeName;
+   };
+
+   template <typename Config>
+   struct Edge
+   {
+      using config = Config;
+
+      typename Config::value_type node;
+      std::string cursor;
+   };
+   template <typename Config>
+   [[maybe_unused]] inline const char* get_type_name(Edge<Config>*)
+   {
+      return Config::edge_name;
+   }
+   template <typename Config, typename F>
+   constexpr void eosio_for_each_field(Edge<Config>*, F f)
+   {
+      EOSIO_REFLECT2_FOR_EACH_FIELD(Edge<Config>, node, cursor)
+   }
+
+   template <typename Config>
+   struct Connection
+   {
+      using config = Config;
+
+      std::vector<Edge<Config>> edges;
+      PageInfo pageInfo;
+   };
+   template <typename Config>
+   [[maybe_unused]] inline const char* get_type_name(Connection<Config>*)
+   {
+      return Config::connection_name;
+   }
+   template <typename Config, typename F>
+   constexpr void eosio_for_each_field(Connection<Config>*, F f)
+   {
+      EOSIO_REFLECT2_FOR_EACH_FIELD(Connection<Config>, edges, pageInfo)
+   }
+
+   // To enable cursors to function correctly, container must not have duplicate keys
+   template <typename Connection,
+             typename Key,
+             typename T,
+             typename To_key,
+             typename To_node,
+             typename Lower_bound,
+             typename Upper_bound>
+   Connection make_connection(const std::optional<Key>& gt,
+                              const std::optional<Key>& ge,
+                              const std::optional<Key>& lt,
+                              const std::optional<Key>& le,
+                              std::optional<uint32_t> first,
+                              std::optional<uint32_t> last,
+                              const std::optional<std::string>& before,
+                              const std::optional<std::string>& after,
+                              const T& container,
+                              To_key&& to_key,
+                              To_node&& to_node,
+                              Lower_bound&& lower_bound,
+                              Upper_bound&& upper_bound)
+   {
+      auto compare_it = [&](const auto& a, const auto& b) {
+         if (a == container.end())
+            return false;
+         if (b == container.end())
+            return true;
+         return to_key(*a) < to_key(*b);
+      };
+      auto key_from_hex = [&](const std::optional<std::string>& s) -> std::optional<Key> {
+         if (!s || s->empty())
+            return {};
+         // TODO: prevent from_bin aborting
+         std::vector<char> bytes;
+         bytes.reserve(s->size() / 2);
+         if (eosio::unhex(std::back_inserter(bytes), s->begin(), s->end()))
+            return eosio::convert_from_bin<Key>(bytes);
+         return {};
+      };
+
+      auto rangeBegin = container.begin();
+      auto rangeEnd = container.end();
+      if (ge)
+         rangeBegin = std::max(rangeBegin, lower_bound(container, *ge), compare_it);
+      if (gt)
+         rangeBegin = std::max(rangeBegin, upper_bound(container, *gt), compare_it);
+      if (le)
+         rangeEnd = std::min(rangeEnd, upper_bound(container, *le), compare_it);
+      if (lt)
+         rangeEnd = std::min(rangeEnd, lower_bound(container, *lt), compare_it);
+      rangeEnd = std::max(rangeBegin, rangeEnd, compare_it);
+
+      auto it = rangeBegin;
+      auto end = rangeEnd;
+      if (auto key = key_from_hex(after))
+         it = std::clamp(upper_bound(container, *key), rangeBegin, rangeEnd, compare_it);
+      if (auto key = key_from_hex(before))
+         end = std::clamp(lower_bound(container, *key), rangeBegin, rangeEnd, compare_it);
+      end = std::max(it, end, compare_it);
+
+      Connection result;
+      auto add_edge = [&](const auto& it) {
+         auto bin = eosio::convert_to_bin(to_key(*it));
+         auto cursor = eosio::hex(bin.begin(), bin.end());
+         result.edges.push_back(Edge<typename Connection::config>{to_node(*it), std::move(cursor)});
+      };
+
+      if (last && !first)
+      {
+         result.pageInfo.hasNextPage = end != rangeEnd;
+         for (; it != end && (*last)-- > 0; --end)
+            add_edge(std::prev(end));
+         result.pageInfo.hasPreviousPage = end != rangeBegin;
+         std::reverse(result.edges.begin(), result.edges.end());
+      }
+      else
+      {
+         result.pageInfo.hasPreviousPage = it != rangeBegin;
+         for (; it != end && (!first || (*first)-- > 0); ++it)
+            add_edge(it);
+         result.pageInfo.hasNextPage = it != rangeEnd;
+         if (last && *last < result.edges.size())
+         {
+            result.pageInfo.hasPreviousPage = true;
+            result.edges.erase(result.edges.begin(),
+                               result.edges.begin() + (result.edges.size() - *last));
+         }
+      }
+
+      if (!result.edges.empty())
+      {
+         result.pageInfo.startCursor = result.edges.front().cursor;
+         result.pageInfo.endCursor = result.edges.back().cursor;
+      }
+      return result;
+   }
+}  // namespace clchain
diff --git a/libraries/clchain/include/clchain/subchain.hpp b/libraries/clchain/include/clchain/subchain.hpp
new file mode 100644
index 000000000..b51f7c13b
--- /dev/null
+++ b/libraries/clchain/include/clchain/subchain.hpp
@@ -0,0 +1,222 @@
+#pragma once
+
+#include <clchain/graphql_connection.hpp>
+#include <eosio/bytes.hpp>
+#include <eosio/fixed_bytes.hpp>
+#include <eosio/name.hpp>
+#include <eosio/time.hpp>
+
+namespace subchain
+{
+   struct action
+   {
+      uint64_t seq = 0;
+      eosio::name firstReceiver;
+      eosio::name receiver;
+      eosio::name name;
+      eosio::bytes hexData;
+   };
+   EOSIO_REFLECT(action, seq, firstReceiver, receiver, name, hexData)
+
+   struct transaction
+   {
+      eosio::checksum256 id;
+      std::vector<action> actions;
+   };
+   EOSIO_REFLECT(transaction, id, actions)
+
+   struct eosio_block
+   {
+      uint32_t num = 0;
+      eosio::checksum256 id;
+      eosio::checksum256 previous;
+      eosio::time_point timestamp;
+      std::vector<transaction> transactions;
+   };
+   EOSIO_REFLECT(eosio_block, num, id, previous, timestamp, transactions)
+
+   struct block
+   {
+      uint32_t num = 0;
+      eosio::checksum256 previous;
+      eosio_block eosioBlock;
+   };
+   EOSIO_REFLECT(block, num, previous, eosioBlock)
+
+   struct block_with_id : block
+   {
+      eosio::checksum256 id;
+   };
+   EOSIO_REFLECT(block_with_id, id, base block)
+
+   inline const block& deref(const block& block) { return block; }
+   inline const block& deref(const std::unique_ptr<block>& block) { return *block; }
+   inline const block_with_id& deref(const block_with_id& block) { return block; }
+   inline const block_with_id& deref(const std::unique_ptr<block_with_id>& block) { return *block; }
+   inline uint32_t get_eosio_num(uint32_t num) { return num; }
+   inline uint32_t get_eosio_num(const auto& block) { return deref(block).eosioBlock.num; }
+   inline constexpr auto by_eosio_num = [](const auto& a, const auto& b) {
+      return get_eosio_num(a) < get_eosio_num(b);
+   };
+
+   struct block_log
+   {
+      enum status
+      {
+         appended,
+         duplicate,
+         unlinkable,
+      };
+
+      static constexpr const char* status_str[] = {
+          "appended",
+          "duplicate",
+          "unlinkable",
+      };
+
+      std::vector<std::unique_ptr<block_with_id>> blocks;
+      uint32_t irreversible = 0;
+
+      auto lower_bound_by_num(uint32_t num) const
+      {
+         if (blocks.empty())
+            return blocks.end();
+         auto head = blocks.front()->num;
+         if (num <= head)
+            return blocks.begin();
+         if (num - head < blocks.size())
+            return blocks.begin() + (num - head);
+         return blocks.end();
+      }
+
+      auto upper_bound_by_num(uint32_t num) const
+      {
+         if (num == ~uint32_t(0))
+            return blocks.end();
+         return lower_bound_by_num(num + 1);
+      }
+
+      const block_with_id* head() const
+      {
+         if (blocks.empty())
+            return nullptr;
+         return &*blocks.back();
+      }
+
+      const block_with_id* block_by_num(uint32_t num) const
+      {
+         auto it = lower_bound_by_num(num);
+         if (it != blocks.end() && (*it)->num == num)
+            return &**it;
+         return nullptr;
+      }
+
+      const block_with_id* block_by_eosio_num(uint32_t num) const
+      {
+         auto it = std::lower_bound(blocks.begin(), blocks.end(), num, by_eosio_num);
+         if (it != blocks.end() && get_eosio_num(*it) == num)
+            return &**it;
+         return nullptr;
+      }
+
+      const block_with_id* block_before_num(uint32_t num) const
+      {
+         auto it = lower_bound_by_num(num);
+         if (it != blocks.begin())
+            return &*it[-1];
+         return nullptr;
+      }
+
+      const block_with_id* block_before_eosio_num(uint32_t num) const
+      {
+         auto it = std::lower_bound(blocks.begin(), blocks.end(), num, by_eosio_num);
+         if (it != blocks.begin())
+            return &*it[-1];
+         return nullptr;
+      }
+
+      std::pair<status, size_t> add_block(const block_with_id& block)
+      {
+         size_t num_forked = 0;
+         auto it = lower_bound_by_num(block.num);
+         if (it != blocks.end() && block.id == it[0]->id)
+            return {duplicate, 0};
+         if (it == blocks.begin() && block.num != 1)
+            return {unlinkable, 0};
+         if (it != blocks.begin())
+            if (block.previous != it[-1]->id || block.num != it[-1]->num + 1)
+               return {unlinkable, 0};
+         if (it != blocks.end() && it[0]->num <= irreversible)
+            return {unlinkable, 0};
+         num_forked = blocks.end() - it;
+         blocks.erase(it, blocks.end());
+         blocks.push_back(std::make_unique<block_with_id>(block));
+         return {appended, num_forked};
+      }
+
+      size_t undo(uint32_t block_num)
+      {
+         if (block_num <= irreversible)
+            return 0;
+         auto it = lower_bound_by_num(block_num);
+         if (it == blocks.end() || it[0]->num != block_num)
+            return 0;
+         size_t num_removed = blocks.end() - it;
+         blocks.erase(it, blocks.end());
+         return num_removed;
+      }
+
+      // Keep only 1 irreversible block
+      void trim()
+      {
+         auto it = lower_bound_by_num(irreversible);
+         blocks.erase(blocks.begin(), it);
+      }
+   };
+   EOSIO_REFLECT2(block_log, blocks, irreversible)
+
+   constexpr inline const char BlockConnection_name[] = "BlockConnection";
+   constexpr inline const char BlockEdge_name[] = "BlockEdge";
+   using BlockConnection =
+       clchain::Connection<clchain::ConnectionConfig<std::reference_wrapper<const block_with_id>,
+                                                     BlockConnection_name,
+                                                     BlockEdge_name>>;
+
+   struct BlockLog
+   {
+      block_log& log;
+
+      BlockConnection blocks(std::optional<uint32_t> gt,
+                             std::optional<uint32_t> ge,
+                             std::optional<uint32_t> lt,
+                             std::optional<uint32_t> le,
+                             std::optional<uint32_t> first,
+                             std::optional<uint32_t> last,
+                             std::optional<std::string> before,
+                             std::optional<std::string> after) const
+      {
+         return clchain::make_connection<BlockConnection, uint32_t>(
+             gt, ge, lt, le, first, last, before, after,     //
+             log.blocks,                                     //
+             [](auto& block) { return block->num; },         //
+             [](auto& block) { return std::cref(*block); },  //
+             [&](auto& blocks, auto block_num) { return log.lower_bound_by_num(block_num); },
+             [&](auto& blocks, auto block_num) { return log.upper_bound_by_num(block_num); });
+      }
+
+      const block_with_id* head() const { return log.head(); }
+      const block_with_id* irreversible() const { return log.block_by_num(log.irreversible); }
+      const block_with_id* blockByNum(uint32_t num) const { return log.block_by_num(num); }
+      const block_with_id* blockByEosioNum(uint32_t num) const
+      {
+         return log.block_by_eosio_num(num);
+      }
+   };
+   EOSIO_REFLECT2(BlockLog,
+                  method(blocks, "gt", "ge", "lt", "le", "first", "last", "before", "after"),
+                  head,
+                  irreversible,
+                  method(blockByNum, "num"),
+                  method(blockByEosioNum, "num"))
+
+}  // namespace subchain
diff --git a/libraries/clchain/src/crypto.cpp b/libraries/clchain/src/crypto.cpp
new file mode 100644
index 000000000..230279a4e
--- /dev/null
+++ b/libraries/clchain/src/crypto.cpp
@@ -0,0 +1,13 @@
+#include <clchain/crypto.hpp>
+
+#include <openssl/sha.h>
+
+namespace clchain
+{
+   eosio::checksum256 sha256(const char* data, uint32_t length)
+   {
+      std::array<unsigned char, 256 / 8> result;
+      SHA256((const unsigned char*)data, length, result.data());
+      return result;
+   }
+}  // namespace clchain
diff --git a/libraries/clchain/wasi-polyfill/__wasi_environ_get.cpp b/libraries/clchain/wasi-polyfill/__wasi_environ_get.cpp
new file mode 100644
index 000000000..013fadc46
--- /dev/null
+++ b/libraries/clchain/wasi-polyfill/__wasi_environ_get.cpp
@@ -0,0 +1,8 @@
+#include <wasi/api.h>
+#include "polyfill_helpers.hpp"
+
+extern "C" __wasi_errno_t __wasi_environ_get(uint8_t** environ, uint8_t* environ_buf)
+    __attribute__((__import_module__("wasi_snapshot_preview1"), __import_name__("environ_get")))
+{
+   polyfill::abort_message("__wasi_environ_get not implemented");
+}
diff --git a/libraries/clchain/wasi-polyfill/__wasi_environ_sizes_get.cpp b/libraries/clchain/wasi-polyfill/__wasi_environ_sizes_get.cpp
new file mode 100644
index 000000000..ed66c3505
--- /dev/null
+++ b/libraries/clchain/wasi-polyfill/__wasi_environ_sizes_get.cpp
@@ -0,0 +1,10 @@
+#include <wasi/api.h>
+#include "polyfill_helpers.hpp"
+
+extern "C" __wasi_errno_t __wasi_environ_sizes_get(__wasi_size_t* environc,
+                                                   __wasi_size_t* environ_buf_size)
+    __attribute__((__import_module__("wasi_snapshot_preview1"),
+                   __import_name__("environ_sizes_get")))
+{
+   polyfill::abort_message("__wasi_environ_sizes_get not implemented");
+}
diff --git a/libraries/clchain/wasi-polyfill/__wasi_fd_read.cpp b/libraries/clchain/wasi-polyfill/__wasi_fd_read.cpp
new file mode 100644
index 000000000..73f38aec9
--- /dev/null
+++ b/libraries/clchain/wasi-polyfill/__wasi_fd_read.cpp
@@ -0,0 +1,11 @@
+#include <wasi/api.h>
+#include "polyfill_helpers.hpp"
+
+extern "C" __wasi_errno_t __wasi_fd_read(__wasi_fd_t fd,
+                                         const __wasi_iovec_t* iovs,
+                                         size_t iovs_len,
+                                         __wasi_size_t* nread)
+    __attribute__((__import_module__("wasi_snapshot_preview1"), __import_name__("fd_read")))
+{
+   polyfill::abort_message("__wasi_fd_read not implemented");
+}
diff --git a/libraries/clchain/wasi-polyfill/__wasi_proc_exit.cpp b/libraries/clchain/wasi-polyfill/__wasi_proc_exit.cpp
new file mode 100644
index 000000000..a998498d8
--- /dev/null
+++ b/libraries/clchain/wasi-polyfill/__wasi_proc_exit.cpp
@@ -0,0 +1,9 @@
+#include <wasi/api.h>
+
+extern "C" _Noreturn void __wasi_proc_exit(__wasi_exitcode_t code)
+    __attribute__((__import_module__("wasi_snapshot_preview1"), __import_name__("proc_exit")))
+{
+   [[clang::import_module("clchain"), clang::import_name("exit"), noreturn]] void import_exit(
+       int32_t code);
+   import_exit(code);
+}
diff --git a/libraries/clchain/wasi-polyfill/eosio_assert.cpp b/libraries/clchain/wasi-polyfill/eosio_assert.cpp
new file mode 100644
index 000000000..fde4bb5d1
--- /dev/null
+++ b/libraries/clchain/wasi-polyfill/eosio_assert.cpp
@@ -0,0 +1,16 @@
+#include <string.h>
+#include "polyfill_helpers.hpp"
+
+extern "C"
+{
+   [[clang::import_name("eosio_assert_message"), noreturn]] void
+   eosio_assert_message(uint32_t, const char* msg, uint32_t len)
+   {
+      polyfill::abort_message(msg, len);
+   }
+
+   [[clang::import_name("eosio_assert"), noreturn]] void eosio_assert(uint32_t, const char* msg)
+   {
+      polyfill::abort_message(msg, strlen(msg));
+   }
+}
diff --git a/libraries/clchain/wasi-polyfill/polyfill_helpers.hpp b/libraries/clchain/wasi-polyfill/polyfill_helpers.hpp
new file mode 100644
index 000000000..8001a38c4
--- /dev/null
+++ b/libraries/clchain/wasi-polyfill/polyfill_helpers.hpp
@@ -0,0 +1,15 @@
+#pragma once
+
+#include <stdint.h>
+
+namespace polyfill
+{
+   [[noreturn, clang::import_module("clchain"), clang::import_name("abort_message")]] void
+   abort_message(const char*, uint32_t);
+
+   template <int size>
+   [[noreturn]] inline void abort_message(const char (&msg)[size])
+   {
+      abort_message(msg, size - 1);
+   }
+}  // namespace polyfill
diff --git a/libraries/clchain/wasi-polyfill/prints.cpp b/libraries/clchain/wasi-polyfill/prints.cpp
new file mode 100644
index 000000000..33a854c91
--- /dev/null
+++ b/libraries/clchain/wasi-polyfill/prints.cpp
@@ -0,0 +1,14 @@
+#include <stdint.h>
+#include <string.h>
+
+extern "C" void prints_l(const char* str, uint32_t len)
+{
+   [[clang::import_module("clchain"), clang::import_name("console")]] void import_console(
+       const char*, uint32_t);
+   import_console(str, len);
+}
+
+extern "C" void prints(const char* cstr)
+{
+   prints_l(cstr, strlen(cstr));
+}
diff --git a/package.json b/package.json
index 81c452c4b..877563dfd 100644
--- a/package.json
+++ b/package.json
@@ -1,5 +1,5 @@
 {
-    "name": "eden",
+    "name": "edenos",
     "private": true,
     "workspaces": [
         "packages/*"
diff --git a/packages/box/.env b/packages/box/.env
index 1cb2def68..45e3ab0ef 100644
--- a/packages/box/.env
+++ b/packages/box/.env
@@ -6,3 +6,16 @@ EOS_RPC_HOST = "wax-test.eosdac.io"
 EOS_RPC_PORT = "443"
 EDEN_CONTRACT_ACCOUNT = "test.edev"
 IPFS_PINATA_JWT = "<set-pinata-jwt-here>"
+
+SUBCHAIN_EDEN_CONTRACT = "genesis.eden"
+SUBCHAIN_TOKEN_CONTRACT = "eosio.token"
+SUBCHAIN_AA_CONTRACT = "atomicassets"
+SUBCHAIN_AA_MARKET_CONTRACT = "atomicmarket"
+SUBCHAIN_WASM = "../../build/eden-micro-chain.wasm"
+SUBCHAIN_STATE = "state"
+
+DFUSE_API_KEY = ""
+DFUSE_API_NETWORK = "eos.dfuse.eosnation.io"
+DFUSE_AUTH_NETWORK = "https://auth.eosnation.io"
+DFUSE_FIRST_BLOCK = "183705819"
+DFUSE_JSON_TRX_FILE = "dfuse-transactions.json"
diff --git a/packages/box/.gitignore b/packages/box/.gitignore
index 06a60c1ad..26583f0b4 100644
--- a/packages/box/.gitignore
+++ b/packages/box/.gitignore
@@ -1,2 +1,4 @@
 tmp/
 .env.local
+dfuse-transactions*.json
+state
diff --git a/packages/box/README.md b/packages/box/README.md
index e516fe548..5862f7b27 100644
--- a/packages/box/README.md
+++ b/packages/box/README.md
@@ -33,6 +33,21 @@ In the above configuration we are defining that we support two eden contract act
 
 Right now we don't support a configurable way of supporting new actions. You would need to change the `config.ts` and recompile the code. We will always keep this config maintained with what is required by Eden but we also have plans to make it more flexible to handle another contract uploads in the box as well.
 
+### Subchain settings
+
+The default settings enable subchain support, using `eos.dfuse.eosnation.io` to grab history related to the `genesis.eden` contract on `EOS`.
+
+- `SUBCHAIN_DISABLE`: if present disables subchain support
+- `DFUSE_PREVENT_CONNECT`: if present disables connecting to dfuse
+- `SUBCHAIN_EDEN_CONTRACT`, `SUBCHAIN_TOKEN_CONTRACT`, `SUBCHAIN_AA_CONTRACT`, and `SUBCHAIN_AA_MARKET_CONTRACT`: contracts to filter
+- `SUBCHAIN_WASM`: location of `eden-micro-chain.wasm`
+- `SUBCHAIN_STATE`: location where to store the wasm's state
+- `DFUSE_API_KEY` is optional. Not currently necessary with the document rate this consumes.
+- `DFUSE_API_NETWORK` defaults to `eos.dfuse.eosnation.io`. Do not include the protocol in this field.
+- `DFUSE_AUTH_NETWORK` defaults to `https://auth.eosnation.io`. This requires the protocol (https).
+- `DFUSE_FIRST_BLOCK`: which block to start at. For `genesis.eden` on `EOS`, use 183705819
+- `DFUSE_JSON_TRX_FILE`: location to cache dfuse results. Defaults to `dfuse-transactions.json`
+
 ## Building Image and Publishing to GHCR
 
 ```sh
diff --git a/packages/box/package.json b/packages/box/package.json
index 61f58ea4a..c6842c006 100644
--- a/packages/box/package.json
+++ b/packages/box/package.json
@@ -11,9 +11,10 @@
         "compile": "tsc -p tsconfig.build.json",
         "prepublishOnly": "yarn run build",
         "lint": "eslint --ext .js,.ts src",
-        "test": "yarn run build"
+        "test": "echo"
     },
     "dependencies": {
+        "@dfuse/client": "^0.3.20",
         "@edenos/common": "^0.1.0",
         "axios": "^0.21.1",
         "body-parser": "^1.19.0",
@@ -30,6 +31,7 @@
         "multer": "^1.4.2",
         "node-fetch": "^2.6.1",
         "winston": "^3.3.3",
+        "ws": "^8.0.0",
         "zod": "^3.0.0-beta.1"
     },
     "devDependencies": {
@@ -38,6 +40,8 @@
         "@types/morgan": "^1.9.2",
         "@types/multer": "^1.4.6",
         "@types/node": "^15.12.4",
+        "@types/node-fetch": "^2.5.12",
+        "@types/ws": "^7.4.7",
         "rimraf": "^3.0.2",
         "ts-node": "^10.0.0",
         "ts-node-dev": "^1.1.6",
diff --git a/packages/box/src/config.ts b/packages/box/src/config.ts
index 3f27bec78..ee2fe006c 100644
--- a/packages/box/src/config.ts
+++ b/packages/box/src/config.ts
@@ -51,4 +51,26 @@ logger.info(
         JSON.stringify(validUploadActions, undefined, 2)
 );
 
+export const subchainConfig = {
+    enable: !("SUBCHAIN_DISABLE" in process.env),
+    eden: process.env.SUBCHAIN_EDEN_CONTRACT || "genesis.eden",
+    token: process.env.SUBCHAIN_TOKEN_CONTRACT || "eosio.token",
+    atomic: process.env.SUBCHAIN_AA_CONTRACT || "atomicassets",
+    atomicMarket: process.env.SUBCHAIN_AA_MARKET_CONTRACT || "atomicmarket",
+    wasmFile: process.env.SUBCHAIN_WASM || "../../build/eden-micro-chain.wasm",
+    stateFile: process.env.SUBCHAIN_STATE || "state",
+};
+console.info(subchainConfig);
+
+export const dfuseConfig = {
+    apiKey: process.env.DFUSE_API_KEY || "",
+    apiNetwork: process.env.DFUSE_API_NETWORK || "eos.dfuse.eosnation.io",
+    authNetwork: process.env.DFUSE_AUTH_NETWORK || "https://auth.eosnation.io",
+    firstBlock: +(process.env.DFUSE_FIRST_BLOCK as any) || 1,
+    jsonTrxFile:
+        process.env.DFUSE_JSON_TRX_FILE || "dfuse-transactions.json",
+    preventConnect: "DFUSE_PREVENT_CONNECT" in process.env,
+};
+console.info({ ...dfuseConfig, apiKey: "<secret>" });
+
 logger.info("<== Env Configs Loaded!");
diff --git a/packages/box/src/dfuse-receiver.ts b/packages/box/src/dfuse-receiver.ts
new file mode 100644
index 000000000..bbe595d55
--- /dev/null
+++ b/packages/box/src/dfuse-receiver.ts
@@ -0,0 +1,243 @@
+import { createDfuseClient, GraphqlStreamMessage, Stream } from "@dfuse/client";
+import * as fs from "fs";
+import nodeFetch from "node-fetch";
+import WebSocketClient from "ws";
+import { performance } from "perf_hooks";
+import { dfuseConfig, subchainConfig } from "./config";
+import { Storage } from "./subchain-storage";
+import logger from "./logger";
+
+const query = `
+subscription ($query: String!, $cursor: String, $limit: Int64, $low: Int64,
+              $high: Int64, $irrev: Boolean, $interval: Uint32) {
+    searchTransactionsForward(
+                query: $query, lowBlockNum: $low, highBlockNum: $high,
+                limit: $limit, cursor: $cursor, irreversibleOnly: $irrev,
+                liveMarkerInterval: $interval) {
+        undo
+        cursor
+        irreversibleBlockNum
+        block {
+            num
+            id
+            timestamp
+            previous
+        }
+        trace {
+            id
+            status
+            matchingActions {
+                seq
+                receiver
+                account
+                name
+                hexData
+            }
+        }
+    }
+}`;
+
+interface JsonTrx {
+    undo: boolean;
+    cursor: string;
+    irreversibleBlockNum: number;
+    block: {
+        num: number;
+        id: string;
+        timestamp: string;
+        previous: string;
+    };
+    trace: {
+        id: string;
+        status: string;
+        matchingActions: [
+            {
+                seq: number;
+                receiver: string;
+                account: string;
+                name: string;
+                hexData: string;
+            }
+        ];
+    };
+}
+
+async function webSocketFactory(
+    url: string,
+    protocols: string[] = []
+): Promise<WebSocketClient> {
+    const webSocket = new WebSocketClient(url, protocols, {
+        handshakeTimeout: 30 * 1000, // 30s
+        maxPayload: 10 * 1024 * 1024,
+    });
+    return webSocket;
+}
+
+export default class DfuseReceiver {
+    storage: Storage;
+    jsonTransactions: JsonTrx[] = [];
+    unpushedTransactions: JsonTrx[] = [];
+    numSaved = 0;
+
+    queryString = `(
+        auth:${subchainConfig.eden} -action:setcode -action:setabi ||
+        receiver:${subchainConfig.eden} account:${subchainConfig.eden} ||
+        receiver:${subchainConfig.eden} account:${subchainConfig.token} ||
+        receiver:${subchainConfig.eden} account:${subchainConfig.atomic} ||
+        receiver:${subchainConfig.eden} account:${subchainConfig.atomicMarket}
+    )`;
+
+    variables = {
+        query: this.queryString,
+        cursor: "",
+        low: dfuseConfig.firstBlock,
+        limit: 0,
+        irrev: false,
+        interval: 30,
+    };
+
+    dfuseClient = createDfuseClient({
+        apiKey: dfuseConfig.apiKey,
+        network: dfuseConfig.apiNetwork,
+        authUrl: dfuseConfig.authNetwork,
+        httpClientOptions: {
+            fetch: nodeFetch,
+        },
+        graphqlStreamClientOptions: {
+            socketOptions: {
+                webSocketFactory: (url) =>
+                    webSocketFactory(url, ["graphql-ws"]),
+            },
+        },
+        streamClientOptions: {
+            socketOptions: {
+                webSocketFactory,
+            },
+        },
+    });
+
+    constructor(storage: Storage) {
+        this.storage = storage;
+    }
+
+    pushTrx(trx: JsonTrx) {
+        if (this.unpushedTransactions.length) {
+            const prev = this.unpushedTransactions[
+                this.unpushedTransactions.length - 1
+            ];
+            if (trx.undo != prev.undo || trx.block.id != prev.block.id) {
+                if (prev.undo) this.storage.undoEosioNum(prev.block.num);
+                else if (prev.trace) {
+                    const block = { ...prev.block, transactions: [] as any[] };
+                    for (let t of this.unpushedTransactions) {
+                        block.transactions.push({
+                            id: t.trace.id,
+                            actions: t.trace.matchingActions.map((a) => ({
+                                seq: a.seq,
+                                firstReceiver: a.account,
+                                receiver: a.receiver,
+                                name: a.name,
+                                hexData: a.hexData,
+                            })),
+                        });
+                    }
+                    this.storage.pushJsonBlock(
+                        JSON.stringify(block),
+                        prev.irreversibleBlockNum
+                    );
+                }
+                this.unpushedTransactions = [];
+            }
+        }
+        if (trx.trace !== null) this.unpushedTransactions.push(trx);
+    }
+
+    onMessage(message: GraphqlStreamMessage<any>, stream: Stream): void {
+        if (message.type === "data") {
+            const trx: JsonTrx = message.data.searchTransactionsForward;
+            const prev =
+                this.jsonTransactions.length > 0
+                    ? this.jsonTransactions[this.jsonTransactions.length - 1]
+                    : null;
+            logger.info(
+                `${trx.undo ? "undo block" : "recv block"} ${trx.block.num} ${
+                    trx.trace
+                        ? "trx " + trx.trace.id
+                        : "no matching transactions"
+                }`
+            );
+            if (trx.trace || (prev && prev.trace)) {
+                this.jsonTransactions.push(trx);
+                this.pushTrx(trx);
+                if (
+                    this.jsonTransactions.length - this.numSaved > 10 ||
+                    !trx.trace
+                ) {
+                    logger.info(
+                        `save ${dfuseConfig.jsonTrxFile}: ${this.jsonTransactions.length} transactions and undo entries`
+                    );
+                    fs.writeFileSync(
+                        dfuseConfig.jsonTrxFile + ".tmp",
+                        JSON.stringify(this.jsonTransactions)
+                    );
+                    fs.renameSync(
+                        dfuseConfig.jsonTrxFile + ".tmp",
+                        dfuseConfig.jsonTrxFile
+                    );
+                    this.storage.saveState();
+                    this.numSaved = this.jsonTransactions.length;
+                }
+            }
+            stream.mark({
+                cursor: trx.cursor,
+            });
+        }
+        if (message.type === "error")
+            logger.error(JSON.stringify(message, null, 4));
+    }
+
+    async start() {
+        try {
+            try {
+                this.jsonTransactions = JSON.parse(
+                    fs.readFileSync(dfuseConfig.jsonTrxFile, "utf8")
+                );
+                this.numSaved = this.jsonTransactions.length;
+            } catch (e) {}
+
+            if (this.jsonTransactions.length)
+                this.variables.cursor = this.jsonTransactions[
+                    this.jsonTransactions.length - 1
+                ].cursor;
+
+            const begin = performance.now();
+            logger.info("pushing existing blocks...");
+            for (let trx of this.jsonTransactions) this.pushTrx(trx);
+            logger.info(`${performance.now() - begin} ms`);
+            this.storage.saveState();
+
+            if (dfuseConfig.preventConnect) return;
+
+            logger.info("connecting to", dfuseConfig.apiNetwork);
+            if (!this.jsonTransactions.length && dfuseConfig.firstBlock === 1)
+                logger.warn(
+                    "Don't have an existing dfuse cursor and DFUSE_FIRST_BLOCK isn't greater than 1; " +
+                        "this may take a while before the first result comes..."
+                );
+
+            const stream = await this.dfuseClient.graphql(
+                query,
+                this.onMessage.bind(this),
+                {
+                    operationType: "subscription",
+                    variables: this.variables,
+                }
+            );
+
+            logger.info("dfuse is now connected");
+        } catch (e: any) {
+            logger.error(e);
+            process.exit(1);
+        }
+    } // start()
+}
diff --git a/packages/box/src/handlers/index.ts b/packages/box/src/handlers/index.ts
index e90d932c6..21906e788 100644
--- a/packages/box/src/handlers/index.ts
+++ b/packages/box/src/handlers/index.ts
@@ -1,2 +1,3 @@
 export * from "./info";
 export * from "./ipfs-upload";
+export * from "./subchain";
diff --git a/packages/box/src/handlers/subchain.ts b/packages/box/src/handlers/subchain.ts
new file mode 100644
index 000000000..9988ad5e2
--- /dev/null
+++ b/packages/box/src/handlers/subchain.ts
@@ -0,0 +1,157 @@
+import express from "express";
+import * as http from "http";
+import * as WebSocket from "ws";
+import path from "path";
+import { Storage } from "../subchain-storage";
+import logger from "../logger";
+import { subchainConfig } from "../config";
+import DfuseReceiver from "../dfuse-receiver";
+import {
+    ClientStatus,
+    ServerMessage,
+    sanitizeClientStatus,
+} from "@edenos/common/dist/subchain/SubchainProtocol";
+
+const storage = new Storage();
+const dfuseReceiver = new DfuseReceiver(storage);
+export const subchainHandler = express.Router();
+
+subchainHandler.get("/eden-micro-chain.wasm", (req, res) => {
+    res.sendFile(path.resolve("../../build/eden-micro-chain.wasm"));
+});
+
+subchainHandler.get("/state", (req, res) => {
+    res.sendFile(path.resolve("./state"));
+});
+
+subchainHandler.use((req, res, next) => {
+    res.status(404).send("404");
+});
+
+// TODO: timeout
+class ConnectionState {
+    ws: WebSocket | null;
+    haveCallback = false;
+    status: ClientStatus | null = null;
+
+    constructor(ws: WebSocket) {
+        this.ws = ws;
+    }
+
+    addCallback() {
+        if (!this.haveCallback) {
+            this.haveCallback = true;
+            storage.callbacks.push(() => {
+                this.haveCallback = false;
+                this.update();
+            });
+        }
+    }
+
+    head() {
+        if (this.status?.blocks.length)
+            return this.status.blocks[this.status.blocks.length - 1].num;
+        return 0;
+    }
+
+    sendMsg(msg: ServerMessage) {
+        this.ws!.send(JSON.stringify(msg));
+    }
+
+    update() {
+        if (!this.ws) return;
+        if (this.ws.readyState !== WebSocket.OPEN) {
+            this.ws.close();
+            this.ws = null;
+            return;
+        }
+        if (!this.status) return;
+        try {
+            let needHeadUpdate = false;
+            while (this.status.blocks.length) {
+                const b = this.status.blocks[this.status.blocks.length - 1];
+                if (b.num > storage.head || b.id !== storage.idForNum(b.num)) {
+                    this.status.blocks.pop();
+                    needHeadUpdate = true;
+                } else {
+                    break;
+                }
+            }
+            while (this.status.maxBlocksToSend > 0) {
+                let needBlock = this.head() + 1;
+                if (needBlock > storage.head) break;
+                const block = storage.getBlock(needBlock);
+                if (!block) throw new Error("Missing block");
+                this.ws.send(block);
+                this.status.maxBlocksToSend--;
+                this.status.blocks.push({
+                    num: needBlock,
+                    id: storage.idForNum(needBlock),
+                });
+                needHeadUpdate = false;
+                let irreversible = Math.min(
+                    storage.blocksWasm!.getIrreversible(),
+                    this.head()
+                );
+                if (irreversible > this.status.irreversible) {
+                    this.sendMsg({ type: "setIrreversible", irreversible });
+                    this.status.irreversible = irreversible;
+                }
+            }
+            // TODO: trim status.blocks
+            if (needHeadUpdate)
+                this.sendMsg({ type: "setHead", head: this.head() });
+            if (!this.status.maxBlocksToSend) {
+                this.sendMsg({ type: "sendStatus" });
+                this.status = null;
+            } else {
+                this.addCallback();
+            }
+        } catch (e) {
+            // TODO: report some errors to client
+            logger.error(e);
+            this.ws.close();
+            this.ws = null;
+        }
+    } // update()
+} // ConnectionState
+
+export function createWSServer(path: string, server: http.Server) {
+    const wss = new WebSocket.Server({
+        server,
+        path: `${path}/eden-microchain`,
+    });
+
+    wss.on("connection", (ws: WebSocket) => {
+        logger.info("incoming ws connection");
+        ws.on("message", (message: string) => {
+            const wsa = ws as any;
+            if (!wsa.connectionState)
+                wsa.connectionState = new ConnectionState(ws);
+            const cs: ConnectionState = wsa.connectionState;
+            try {
+                cs.status = sanitizeClientStatus(JSON.parse(message));
+                cs.update();
+            } catch (e) {
+                // TODO: report some errors to client
+                logger.error(e);
+                cs.ws = null;
+                ws.close();
+            }
+        });
+    });
+}
+
+export async function startSubchain() {
+    try {
+        await storage.instantiate(
+            subchainConfig.eden,
+            subchainConfig.token,
+            subchainConfig.atomic,
+            subchainConfig.atomicMarket
+        );
+        await dfuseReceiver.start();
+    } catch (e: any) {
+        logger.error(e);
+    }
+}
diff --git a/packages/box/src/index.ts b/packages/box/src/index.ts
index aefc7bb06..992df2530 100644
--- a/packages/box/src/index.ts
+++ b/packages/box/src/index.ts
@@ -1,13 +1,16 @@
 import express from "express";
 import cors from "cors";
 import { json as bpJson, urlencoded as bpUrlencoded } from "body-parser";
+import * as http from "http";
 
 import routes from "./routes";
-import { serverConfig, env } from "./config";
+import { serverConfig, env, subchainConfig } from "./config";
 import logger, { setupExpressLogger } from "./logger";
+import { createWSServer, startSubchain } from "./handlers/subchain";
 
 // rest of the code remains same
 const app = express();
+const server = http.createServer(app);
 app.locals.name = serverConfig.appName;
 app.locals.version = serverConfig.appVersion;
 
@@ -18,9 +21,14 @@ app.use(bpUrlencoded({ extended: true }));
 
 app.use("/", routes);
 
-app.listen(serverConfig.port, () => {
+server.listen(serverConfig.port, () => {
     logger.info(
         `Server running at: http://${serverConfig.host}:${serverConfig.port}`
     );
     logger.info(`Environment=${env}`);
 });
+
+if (subchainConfig.enable) {
+    createWSServer("/v1/subchain", server);
+    startSubchain();
+}
diff --git a/packages/box/src/routes.ts b/packages/box/src/routes.ts
index 6da6865eb..d9ad14c54 100644
--- a/packages/box/src/routes.ts
+++ b/packages/box/src/routes.ts
@@ -1,14 +1,17 @@
 import { Router } from "express";
+import { subchainConfig } from "./config";
 
 import {
     infoHandler,
     ipfsUploadConfigHandler,
     ipfsUploadHandler,
+    subchainHandler,
 } from "./handlers";
 
 const router: Router = Router();
 
 router.get("/", infoHandler);
 router.post("/v1/ipfs-upload", ipfsUploadConfigHandler, ipfsUploadHandler);
+if (subchainConfig.enable) router.use("/v1/subchain", subchainHandler);
 
 export default router;
diff --git a/packages/box/src/subchain-storage.ts b/packages/box/src/subchain-storage.ts
new file mode 100644
index 000000000..96fe96160
--- /dev/null
+++ b/packages/box/src/subchain-storage.ts
@@ -0,0 +1,123 @@
+import { EdenSubchain } from "@edenos/common/dist/subchain";
+import * as config from "./config";
+import * as fs from "fs";
+import logger from "./logger";
+
+export class Storage {
+    blocksWasm: EdenSubchain | null = null;
+    stateWasm: EdenSubchain | null = null;
+    head = 0;
+    callbacks: (() => void)[] = [];
+
+    async instantiate(
+        edenAccount: string,
+        tokenAccount: string,
+        atomicAccount: string,
+        atomicmarketAccount: string
+    ) {
+        try {
+            this.blocksWasm = new EdenSubchain();
+            await this.blocksWasm.instantiate(
+                new Uint8Array(fs.readFileSync(config.subchainConfig.wasmFile))
+            );
+            this.blocksWasm.initializeMemory(
+                edenAccount,
+                tokenAccount,
+                atomicAccount,
+                atomicmarketAccount
+            );
+
+            this.stateWasm = new EdenSubchain();
+            await this.stateWasm.instantiate(
+                new Uint8Array(fs.readFileSync(config.subchainConfig.wasmFile))
+            );
+            this.stateWasm.initializeMemory(
+                edenAccount,
+                tokenAccount,
+                atomicAccount,
+                atomicmarketAccount
+            );
+        } catch (e) {
+            this.blocksWasm = null;
+            this.stateWasm = null;
+            throw e;
+        }
+    }
+
+    protect<T>(f: () => T) {
+        if (!this.blocksWasm || !this.stateWasm)
+            throw new Error("wasm state is corrupt");
+        try {
+            return f();
+        } catch (e) {
+            this.blocksWasm = null;
+            this.stateWasm = null;
+            throw e;
+        }
+    }
+
+    saveState() {
+        return this.protect(() => {
+            fs.writeFileSync(
+                config.subchainConfig.stateFile + ".tmp",
+                this.stateWasm!.uint8Array()
+            );
+            fs.renameSync(
+                config.subchainConfig.stateFile + ".tmp",
+                config.subchainConfig.stateFile
+            );
+            logger.info("saved", config.subchainConfig.stateFile);
+        });
+    }
+
+    query(q: string): any {
+        return this.protect(() => {
+            return this.blocksWasm!.query(q);
+        });
+    }
+
+    getBlock(num: number): Uint8Array {
+        return this.protect(() => this.blocksWasm!.getBlock(num))!;
+    }
+
+    idForNum(num: number): string {
+        return this.query(`{blockLog{blockByNum(num:${num}){id}}}`).data
+            .blockLog.blockByNum.id;
+    }
+
+    changed() {
+        const r = this.query("{blockLog{head{num}}}");
+        this.head = r.data.blockLog.head?.num || 0;
+        const cb = this.callbacks;
+        this.callbacks = [];
+        for (let f of cb) {
+            try {
+                f();
+            } catch (e) {
+                logger.error(e);
+            }
+        }
+    }
+
+    undoEosioNum(eosioNum: number) {
+        this.protect(() => {
+            this.blocksWasm!.undoEosioNum(eosioNum);
+            this.stateWasm!.undoEosioNum(eosioNum);
+        });
+        this.changed();
+    }
+
+    pushJsonBlock(jsonBlock: string, irreversible: number) {
+        const result = this.protect(() => {
+            const result = this.blocksWasm!.pushJsonBlock(
+                jsonBlock,
+                irreversible
+            );
+            this.stateWasm!.pushJsonBlock(jsonBlock, irreversible);
+            this.stateWasm!.trimBlocks();
+            return result;
+        });
+        this.changed();
+        return result;
+    }
+}
diff --git a/packages/common/package.json b/packages/common/package.json
index 323a67da3..1a0358e56 100644
--- a/packages/common/package.json
+++ b/packages/common/package.json
@@ -14,7 +14,7 @@
         "compile": "tsc -p tsconfig.build.json",
         "prepublishOnly": "yarn run build",
         "lint": "eslint --ext .js,.ts src",
-        "test": "yarn run build"
+        "test": "echo"
     },
     "dependencies": {
         "cids": "^1.1.6",
@@ -23,9 +23,11 @@
         "hash.js": "^1.1.7",
         "ipfs-http-client": "^50.0.0",
         "ipfs-only-hash": "^4.0.0",
+        "react": "^17.0.2",
         "zod": "^3.0.0-beta.1"
     },
     "devDependencies": {
+        "@types/react": "^17.0.15",
         "rimraf": "^3.0.2",
         "tsconfig-paths": "^3.9.0",
         "typescript": "^4.2.3"
diff --git a/packages/common/src/subchain/EdenSubchain.ts b/packages/common/src/subchain/EdenSubchain.ts
new file mode 100644
index 000000000..db6ceec56
--- /dev/null
+++ b/packages/common/src/subchain/EdenSubchain.ts
@@ -0,0 +1,227 @@
+import { Serialize } from "eosjs";
+
+export class EdenSubchain {
+    module?: WebAssembly.Module;
+    instance?: WebAssembly.Instance;
+    memory?: WebAssembly.Memory;
+    exports: any;
+    consoleBuf = "";
+    initialized = false;
+    corrupt = false;
+    schema = "";
+
+    uint8Array(pos?: number, len?: number) {
+        if (this.corrupt) throw new Error("wasm state is corrupt");
+        return new Uint8Array(this.memory!.buffer, pos, len);
+    }
+
+    decodeStr(pos?: number, len?: number) {
+        return new TextDecoder().decode(this.uint8Array(pos, len));
+    }
+
+    resultAsUint8Array() {
+        return this.uint8Array(
+            this.exports.getResult(),
+            this.exports.getResultSize()
+        );
+    }
+
+    resultAsString() {
+        return this.decodeStr(
+            this.exports.getResult(),
+            this.exports.getResultSize()
+        );
+    }
+
+    imports = {
+        clchain: {
+            abort_message: (pos: number, len: number) => {
+                throw new Error("abort: " + this.decodeStr(pos, len));
+            },
+            console: (pos: number, len: number) => {
+                const s = this.consoleBuf + this.decodeStr(pos, len);
+                const l = s.split("\n");
+                for (let i = 0; i < l.length - 1; ++i) console.log(l[i]);
+                this.consoleBuf = l[l.length - 1];
+            },
+        },
+    };
+
+    async instantiate(module: BufferSource) {
+        const result = await WebAssembly.instantiate(module, this.imports);
+        this.module = result.module;
+        this.instance = result.instance;
+        this.exports = result.instance.exports;
+        this.memory = this.exports.memory;
+        return this;
+    }
+
+    async instantiateStreaming(response: Response | PromiseLike<Response>) {
+        const result = await WebAssembly.instantiateStreaming(
+            response,
+            this.imports
+        );
+        this.module = result.module;
+        this.instance = result.instance;
+        this.exports = result.instance.exports;
+        this.memory = this.exports.memory;
+        return this;
+    }
+
+    protect<T>(f: () => T) {
+        if (this.corrupt) throw new Error("wasm state is corrupt");
+        try {
+            return f();
+        } catch (e) {
+            this.corrupt = true;
+            throw e;
+        }
+    }
+
+    initializeMemory(
+        edenAccount: string,
+        tokenAccount: string,
+        atomicAccount: string,
+        atomicmarketAccount: string
+    ) {
+        if (this.initialized)
+            throw new Error("wasm memory is already initialized");
+        const buf = new Serialize.SerialBuffer();
+        buf.pushName(edenAccount);
+        buf.pushName(tokenAccount);
+        buf.pushName(atomicAccount);
+        buf.pushName(atomicmarketAccount);
+        const edenAccountLow = buf.getUint32();
+        const edenAccountHigh = buf.getUint32();
+        const tokenAccountLow = buf.getUint32();
+        const tokenAccountHigh = buf.getUint32();
+        const atomicAccountLow = buf.getUint32();
+        const atomicAccountHigh = buf.getUint32();
+        const atomicmarketAccountLow = buf.getUint32();
+        const atomicmarketAccountHigh = buf.getUint32();
+        this.protect(() => {
+            this.exports.initialize(
+                edenAccountLow,
+                edenAccountHigh,
+                tokenAccountLow,
+                tokenAccountHigh,
+                atomicAccountLow,
+                atomicAccountHigh,
+                atomicmarketAccountLow,
+                atomicmarketAccountHigh
+            );
+            this.initialized = true;
+        });
+    }
+
+    setMemory(content: ArrayBuffer) {
+        if (this.initialized)
+            throw new Error("wasm memory is already initialized");
+        const u32 = new Uint32Array(content);
+        const growth =
+            (u32.byteLength - this.memory!.buffer.byteLength) / (64 * 1024);
+        if (growth > 0) this.memory!.grow(growth);
+        const dest = new Uint32Array(this.memory!.buffer);
+        for (let i = 0; i < u32.length; ++i) dest[i] = u32[i];
+    }
+
+    setIrreversible(eosioIrreversible: number): number {
+        return this.protect(() => {
+            return this.exports.setIrreversible(eosioIrreversible);
+        });
+    }
+
+    withData<T>(data: Uint8Array, f: (addr: number) => T) {
+        const destAddr = this.exports.allocateMemory(data.length);
+        if (!destAddr) throw new Error("allocateMemory failed");
+        const dest = this.uint8Array(destAddr, data.length);
+        for (let i = 0; i < data.length; ++i) dest[i] = data[i];
+        const result = f(destAddr);
+        this.exports.freeMemory(destAddr);
+        return result;
+    }
+
+    pushJsonBlock(jsonBlock: string, eosioIrreversible: number) {
+        return this.protect(() => {
+            const utf8 = new TextEncoder().encode(jsonBlock);
+            const ok = !this.withData(utf8, (addr) =>
+                this.exports.addEosioBlockJson(
+                    addr,
+                    utf8.length,
+                    eosioIrreversible
+                )
+            );
+            if (!ok) return null;
+            const block = new Uint8Array(this.resultAsUint8Array());
+            const num = new Uint32Array(block.buffer, 32, 8)[0];
+            return { block, num };
+        });
+    }
+
+    pushBlock(block: Uint8Array, eosioIrreversible: number): boolean {
+        return this.protect(() => {
+            return this.withData(block, (addr) => {
+                return this.exports.addBlock(
+                    addr,
+                    block.length,
+                    eosioIrreversible
+                );
+            });
+        });
+    }
+
+    trimBlocks() {
+        this.protect(() => {
+            this.exports.trimBlocks();
+        });
+    }
+
+    undoBlockNum(blockNum: number) {
+        this.protect(() => {
+            this.exports.undoBlockNum(blockNum);
+        });
+    }
+
+    undoEosioNum(eosioNum: number) {
+        this.protect(() => {
+            this.exports.undoEosioNum(eosioNum);
+        });
+    }
+
+    getBlock(num: number) {
+        return this.protect(() => {
+            if (!this.exports.getBlock(num)) return null;
+            return this.resultAsUint8Array();
+        });
+    }
+
+    getSchema() {
+        if (!this.schema.length)
+            this.schema = this.decodeStr(
+                this.exports.getSchema(),
+                this.exports.getSchemaSize()
+            );
+        return this.schema;
+    }
+
+    query(q: string) {
+        const utf8 = new TextEncoder().encode(q);
+        return this.protect(() => {
+            return this.withData(utf8, (addr) => {
+                this.exports.query(addr, utf8.length, 0, 0);
+                return JSON.parse(this.resultAsString());
+            });
+        });
+    }
+
+    getIrreversible(): number {
+        const q = this.query(`{
+            blockLog{
+                irreversible{
+                    num
+                }
+            }
+        }`);
+        return q.data.blockLog.irreversible?.num || 0;
+    }
+} // WrapWasm
diff --git a/packages/common/src/subchain/ReactSubchain.tsx b/packages/common/src/subchain/ReactSubchain.tsx
new file mode 100644
index 000000000..c2b731813
--- /dev/null
+++ b/packages/common/src/subchain/ReactSubchain.tsx
@@ -0,0 +1,123 @@
+import SubchainClient from "./SubchainClient";
+import { useContext, useEffect, useState, createContext } from "react";
+
+export function useCreateEdenChain(
+    edenAccount: string,
+    tokenAccount: string,
+    atomicAccount: string,
+    atomicmarketAccount: string,
+    wasmUrl: string,
+    stateUrl: string,
+    wsUrl: string,
+    slowMo: boolean
+): SubchainClient | null {
+    const [subchain, setSubchain] = useState<SubchainClient | null>(null);
+    useEffect(() => {
+        if (typeof window !== "undefined") {
+            let client: SubchainClient;
+            (async () => {
+                try {
+                    console.log("create SubchainClient");
+                    client = new SubchainClient();
+                    await client.instantiateStreaming(
+                        edenAccount,
+                        tokenAccount,
+                        atomicAccount,
+                        atomicmarketAccount,
+                        fetch(wasmUrl),
+                        fetch(stateUrl),
+                        wsUrl,
+                        slowMo
+                    );
+                    setSubchain(client);
+                } catch (e) {
+                    console.error(e);
+                }
+            })();
+            return () => {
+                console.log("shutdown SubchainClient");
+                if (client) client.shutdown();
+            };
+        }
+    }, []);
+    return subchain;
+}
+
+export const EdenChainContext = createContext<SubchainClient | null>(null);
+
+export function useQuery<T = any>(query: string): T {
+    const client = useContext(EdenChainContext);
+    const [cachedQuery, setCachedQuery] = useState<string | null>();
+    // non-signalling state
+    const [state] = useState({
+        mounted: true,
+        cachedClient: null as SubchainClient | null,
+        subscribed: null as SubchainClient | null,
+        cachedQueryResult: null as any,
+    });
+    useEffect(() => {
+        return () => {
+            state.mounted = false;
+        };
+    }, []);
+    useEffect(() => {
+        if (client && state.subscribed !== client) {
+            state.subscribed = client;
+            client.notifications.push((c) => {
+                if (state.mounted && c === state.subscribed) {
+                    setCachedQuery(null);
+                    state.subscribed = null;
+                }
+            });
+        }
+    });
+    if (state.cachedClient !== client || query !== cachedQuery) {
+        state.cachedClient = client;
+        setCachedQuery(query);
+        if (client?.subchain) {
+            state.cachedQueryResult = client.subchain.query(query);
+        } else {
+            state.cachedQueryResult = null;
+        }
+    }
+    return state.cachedQueryResult;
+}
+
+interface PageInfo {
+    hasPreviousPage: boolean;
+    hasNextPage: boolean;
+    startCursor: string;
+    endCursor: string;
+}
+
+export function usePagedQuery<T = any>(
+    query: string,
+    pageSize: number,
+    getPageInfo: (result: T) => PageInfo | null | undefined
+) {
+    const [args, setArgs] = useState(`first:${pageSize}`);
+    const result = useQuery<T>(query.replace("@page@", args));
+    const pageInfo = getPageInfo(result) || {
+        hasPreviousPage: false,
+        hasNextPage: false,
+        startCursor: "",
+        endCursor: "",
+    };
+    return {
+        result,
+        hasPreviousPage: pageInfo.hasPreviousPage,
+        hasNextPage: pageInfo.hasNextPage,
+        next() {
+            setArgs(`first:${pageSize} after:"${pageInfo.endCursor}"`);
+        },
+        previous() {
+            setArgs(`last:${pageSize} before:"${pageInfo.startCursor}"`);
+        },
+        first() {
+            setArgs(`first:${pageSize}`);
+        },
+        last() {
+            setArgs(`last:${pageSize}`);
+        },
+    };
+}
diff --git a/packages/common/src/subchain/SubchainClient.ts b/packages/common/src/subchain/SubchainClient.ts
new file mode 100644
index 000000000..aadecaf2a
--- /dev/null
+++ b/packages/common/src/subchain/SubchainClient.ts
@@ -0,0 +1,144 @@
+import { EdenSubchain } from "./EdenSubchain";
+import {
+    BlockInfo,
+    ClientStatus,
+    sanitizeServerMessage,
+} from "./SubchainProtocol";
+
+export default class SubchainClient {
+    subchain = new EdenSubchain();
+    shuttingDown = false;
+    blocksUrl = "";
+    slowmo = false;
+    ws: WebSocket | null = null;
+    notifications: ((client: SubchainClient) => void)[] = [];
+
+    async instantiateStreaming(
+        edenAccount: string,
+        tokenAccount: string,
+        atomicAccount: string,
+        atomicmarketAccount: string,
+        wasmResponse: PromiseLike<Response>,
+        stateResponse: PromiseLike<Response>,
+        blocksUrl: string,
+        slowmo = false
+    ) {
+        this.blocksUrl = blocksUrl;
+        this.slowmo = slowmo;
+        if (this.shuttingDown) return this.shutdown();
+        const [, state] = await Promise.all([
+            this.subchain.instantiateStreaming(wasmResponse),
+            stateResponse.then((resp) => {
+                if (resp.ok) return resp.arrayBuffer();
+                return null;
+            }),
+        ]);
+        if (this.shuttingDown) return this.shutdown();
+        if (state) {
+            this.subchain.setMemory(state);
+        } else {
+            this.subchain.initializeMemory(
+                edenAccount,
+                tokenAccount,
+                atomicAccount,
+                atomicmarketAccount
+            );
+        }
+        this.connect();
+    }
+
+    connect() {
+        if (this.shuttingDown) return this.shutdown();
+        this.ws = new WebSocket(this.blocksUrl);
+        this.ws.onclose = () => {
+            console.error("Closed connection to " + this.blocksUrl);
+            this.ws = null;
+            if (!this.shuttingDown) setTimeout(() => this.connect(), 500);
+        };
+        this.ws.onerror = () => {
+            console.error("Error connecting to " + this.blocksUrl);
+            this.ws = null;
+        };
+        this.ws.onopen = () => {
+            console.log("Connected to " + this.blocksUrl);
+            if (this.slowmo) {
+                setTimeout(() => this.sendStatus(), 1000);
+            } else {
+                this.sendStatus();
+            }
+        };
+        this.ws.onmessage = (ev: MessageEvent<any>) => this.onmessage(ev);
+    }
+
+    async sendStatus() {
+        if (this.shuttingDown) return this.shutdown();
+        if (!this.ws) return;
+        const irreversible: number = this.subchain.getIrreversible();
+        const blocks: BlockInfo[] = this.subchain
+            .query(
+                `{blockLog{blocks(ge:${irreversible}){edges{node{num id}}}}}`
+            )
+            .data.blockLog.blocks.edges.map((e: any) => e.node);
+        const stat: ClientStatus = {
+            maxBlocksToSend: this.slowmo ? 1 : 1000,
+            irreversible,
+            blocks,
+        };
+        if (this.slowmo)
+            setTimeout(() => this.ws?.send(JSON.stringify(stat)), 50);
+        else this.ws.send(JSON.stringify(stat));
+    }
+
+    messageQueue: (Promise<ArrayBuffer> | string)[] = [];
+    processingQueue = false;
+
+    async processQueue() {
+        if (this.processingQueue) return;
+        this.processingQueue = true;
+        try {
+            while (this.messageQueue.length) {
+                if (this.shuttingDown) return this.shutdown();
+                const data = this.messageQueue.shift();
+                if (data instanceof Promise) {
+                    const d = await data;
+                    this.subchain.pushBlock(new Uint8Array(d), 0);
+                } else {
+                    const msg = sanitizeServerMessage(JSON.parse(data!));
+                    if (msg.type === "sendStatus") {
+                        await this.sendStatus();
+                    } else if (msg.type === "setHead") {
+                        this.subchain.undoBlockNum(msg.head! + 1);
+                    } else if (msg.type === "setIrreversible") {
+                        this.subchain.setIrreversible(msg.irreversible!);
+                        this.subchain.trimBlocks();
+                    }
+                }
+            }
+        } catch (e) {
+            console.error(e);
+        }
+        const n = this.notifications;
+        this.notifications = [];
+        for (let f of n) f(this);
+        this.processingQueue = false;
+    }
+
+    async onmessage(ev: MessageEvent<any>) {
+        if (this.shuttingDown) return this.shutdown();
+        if (ev.data instanceof Blob) {
+            this.messageQueue.push(ev.data.arrayBuffer());
+            this.processQueue();
+        } else if (typeof ev.data === "string") {
+            this.messageQueue.push(ev.data);
+            this.processQueue();
+        }
+    }
+
+    shutdown() {
+        this.shuttingDown = true;
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+}
diff --git a/packages/common/src/subchain/SubchainProtocol.ts b/packages/common/src/subchain/SubchainProtocol.ts
new file mode 100644
index 000000000..f56f1c8b8
--- /dev/null
+++ b/packages/common/src/subchain/SubchainProtocol.ts
@@ -0,0 +1,46 @@
+import { array } from "zod";
+
+export interface BlockInfo {
+    num: number;
+    id: string;
+}
+
+export interface ClientStatus {
+    maxBlocksToSend: number;
+    irreversible: number;
+    blocks: BlockInfo[];
+}
+
+export interface ServerMessage {
+    type: string;
+    head?: number;
+    irreversible?: number;
+}
+
+export function sanitizeBlockInfo(src: any): BlockInfo {
+    if (typeof src !== "object") src = {};
+    return {
+        num: src.num >>> 0,
+        id: src.id + "",
+    };
+}
+
+export function sanitizeClientStatus(src: any): ClientStatus {
+    if (typeof src !== "object") src = {};
+    return {
+        maxBlocksToSend: Math.min(src.maxBlocksToSend >>> 0, 1000),
+        irreversible: src.irreversible >>> 0,
+        blocks: Array.isArray(src.blocks)
+            ? src.blocks.map(sanitizeBlockInfo)
+            : [],
+    };
+}
+
+export function sanitizeServerMessage(src: any): ServerMessage {
+    if (typeof src !== "object") src = {};
+    return {
+        type: src.type + "",
+        head: src.head >>> 0,
+        irreversible: src.irreversible >>> 0,
+    };
+}
diff --git a/packages/common/src/subchain/index.ts b/packages/common/src/subchain/index.ts
new file mode 100644
index 000000000..d66d56e2b
--- /dev/null
+++ b/packages/common/src/subchain/index.ts
@@ -0,0 +1,4 @@
+export * from "./EdenSubchain";
+export * from "./ReactSubchain";
+export * from "./SubchainClient";
+export * from "./SubchainProtocol";
diff --git a/packages/common/tsconfig.build.json b/packages/common/tsconfig.build.json
index 433ae900a..d756e26d2 100644
--- a/packages/common/tsconfig.build.json
+++ b/packages/common/tsconfig.build.json
@@ -4,7 +4,8 @@
     "compilerOptions": {
         "resolveJsonModule": true,
         "strict": true,
-        "outDir": "./dist"
+        "outDir": "./dist",
+        "jsx": "react"
     },
 
     "include": ["src/**/*"]
diff --git a/packages/common/tsconfig.json b/packages/common/tsconfig.json
index b8f195ed4..e510e07b0 100644
--- a/packages/common/tsconfig.json
+++ b/packages/common/tsconfig.json
@@ -2,6 +2,7 @@
     "extends": "../../tsconfig.json",
     "compilerOptions": {
         "resolveJsonModule": true,
-        "strict": true
+        "strict": true,
+        "jsx": "react"
     }
 }
diff --git a/packages/example-history-app/.env b/packages/example-history-app/.env
new file mode 100644
index 000000000..2bc57102a
--- /dev/null
+++ b/packages/example-history-app/.env
@@ -0,0 +1,8 @@
+NEXT_PUBLIC_EDEN_CONTRACT=genesis.eden
+NEXT_PUBLIC_TOKEN_CONTRACT=eosio.token
+NEXT_PUBLIC_AA_CONTRACT=atomicassets
+NEXT_PUBLIC_AA_MARKET_CONTRACT=atomicmarket
+NEXT_PUBLIC_SUBCHAIN_WASM_URL=http://localhost:3032/v1/subchain/eden-micro-chain.wasm
+NEXT_PUBLIC_SUBCHAIN_STATE_URL=http://localhost:3032/v1/subchain/state
+NEXT_PUBLIC_SUBCHAIN_WS_URL=ws://localhost:3032/v1/subchain/eden-microchain
+NEXT_PUBLIC_SUBCHAIN_SLOW_MO=false
diff --git a/packages/example-history-app/.gitignore b/packages/example-history-app/.gitignore
new file mode 100644
index 000000000..5d19e56d6
--- /dev/null
+++ b/packages/example-history-app/.gitignore
@@ -0,0 +1,4 @@
+.next
+.env*.local
+next-env.d.ts
+out
diff --git a/packages/example-history-app/README.md b/packages/example-history-app/README.md
new file mode 100644
index 000000000..3d8586b13
--- /dev/null
+++ b/packages/example-history-app/README.md
@@ -0,0 +1,7 @@
+# Example using subchain queries
+
+This needs `box` running with subchain configured. See [box's readme](../box/README.md).
+
+See [.env](.env) for the set of environment variables that need to be configured. The 3 `*_URL` environment variables should normally point to the same box server to prevent state file corruption.
+
+Set `NEXT_PUBLIC_SUBCHAIN_SLOW_MO` to `true` to see how the UI responds to a gradually-updating event stream.
diff --git a/packages/example-history-app/next.config.js b/packages/example-history-app/next.config.js
new file mode 100644
index 000000000..149d75550
--- /dev/null
+++ b/packages/example-history-app/next.config.js
@@ -0,0 +1,24 @@
+module.exports = {
+    target: "serverless",
+    distDir: "dist",
+    // TODO: it was causing `Error: Can't resolve 'bufferutil' in '/.../node_modules/ws/lib'
+    // revisit it to use webpack5
+    // future: {
+    //     webpack5: true,
+    // },
+    webpack: (config, { buildId, dev, isServer, defaultLoaders, webpack }) => {
+        // // Note: we provide webpack above so you should not `require` it
+        // // Perform customizations to webpack config
+        // config.plugins.push(new webpack.IgnorePlugin(/\/__tests__\//))
+
+        // Fixes build with ts/lerna monorepo workspaces
+        const tsRule = config.module.rules.find(
+            (rule) => rule.test && rule.test.toString().includes("tsx|ts")
+        );
+        tsRule.include = undefined;
+        tsRule.exclude = /node_modules/;
+
+        // Important: return the modified config
+        return config;
+    },
+};
diff --git a/packages/example-history-app/package.json b/packages/example-history-app/package.json
new file mode 100644
index 000000000..70a77c29e
--- /dev/null
+++ b/packages/example-history-app/package.json
@@ -0,0 +1,25 @@
+{
+    "name": "@edenos/example-history-app",
+    "description": "Eden WebApp",
+    "version": "0.1.0",
+    "license": "MIT",
+    "scripts": {
+        "dev": "next dev -p 3001",
+        "build": "next build",
+        "start": "next start -p 3001",
+        "test": "echo"
+    },
+    "dependencies": {
+        "@edenos/common": "^0.1.0",
+        "next": "^11.0.1",
+        "react": "^17.0.2",
+        "react-dom": "^17.0.2"
+    },
+    "devDependencies": {
+        "cypress": "^8.1.0",
+        "eslint-config-next": "^11.0.1",
+        "graphiql": "^1.4.2",
+        "graphql": "^15.5.1",
+        "typescript": "^4.3.5"
+    }
+}
diff --git a/packages/example-history-app/src/components/header.tsx b/packages/example-history-app/src/components/header.tsx
new file mode 100644
index 000000000..b882207e6
--- /dev/null
+++ b/packages/example-history-app/src/components/header.tsx
@@ -0,0 +1,50 @@
+import Link from "next/link";
+import { useQuery } from "@edenos/common/dist/subchain";
+
+export default function Header() {
+    const info = useQuery(`{
+        blockLog {
+            head {
+                num
+                eosioBlock {
+                    num
+                }
+            }
+        }
+    }`);
+    return (
+        <div>
+            <div style={{ margin: 10 }}>
+                <table>
+                    <tbody>
+                        <tr>
+                            <td>block:</td>
+                            <td>{info?.data?.blockLog.head?.num}</td>
+                        </tr>
+                        <tr>
+                            <td>eosio block:</td>
+                            <td>{info?.data?.blockLog.head?.eosioBlock.num}</td>
+                        </tr>
+                    </tbody>
+                </table>
+            </div>
+            <ul>
+                <li>
+                    <Link href="/">
+                        <a>Members</a>
+                    </Link>
+                </li>
+                <li>
+                    <Link href="/simple_members">
+                        <a>Simple Members</a>
+                    </Link>
+                </li>
+                <li>
+                    <Link href="/graphiql">
+                        <a>GraphiQL</a>
+                    </Link>
+                </li>
+            </ul>
+        </div>
+    );
+}
diff --git a/packages/example-history-app/src/pages/_app.tsx b/packages/example-history-app/src/pages/_app.tsx
new file mode 100644
index 000000000..b3712c562
--- /dev/null
+++ b/packages/example-history-app/src/pages/_app.tsx
@@ -0,0 +1,43 @@
+import { AppProps } from "next/app";
+import {
+    useCreateEdenChain,
+    EdenChainContext,
+} from "@edenos/common/dist/subchain";
+import "../../../../node_modules/graphiql/graphiql.min.css";
+
+if (
+    !process.env.NEXT_PUBLIC_EDEN_CONTRACT ||
+    !process.env.NEXT_PUBLIC_TOKEN_CONTRACT ||
+    !process.env.NEXT_PUBLIC_AA_CONTRACT ||
+    !process.env.NEXT_PUBLIC_AA_MARKET_CONTRACT ||
+    !process.env.NEXT_PUBLIC_SUBCHAIN_WASM_URL ||
+    !process.env.NEXT_PUBLIC_SUBCHAIN_STATE_URL ||
+    !process.env.NEXT_PUBLIC_SUBCHAIN_WS_URL ||
+    !process.env.NEXT_PUBLIC_SUBCHAIN_SLOW_MO
+) {
+    throw new Error("ExampleHistoryApp Environment Variables are not set");
+}
+
+const MyApp = ({ Component, pageProps }: AppProps) => {
+    const subchain = useCreateEdenChain(
+        process.env.NEXT_PUBLIC_EDEN_CONTRACT || "genesis.eden",
+        process.env.NEXT_PUBLIC_TOKEN_CONTRACT || "eosio.token",
+        process.env.NEXT_PUBLIC_AA_CONTRACT || "atomicassets",
+        process.env.NEXT_PUBLIC_AA_MARKET_CONTRACT || "atomicmarket",
+        process.env.NEXT_PUBLIC_SUBCHAIN_WASM_URL ||
+            "http://localhost:3032/v1/subchain/eden-micro-chain.wasm",
+        process.env.NEXT_PUBLIC_SUBCHAIN_SLOW_MO === "true"
+            ? "bad_state_file_name_for_slow_mo"
+            : process.env.NEXT_PUBLIC_SUBCHAIN_STATE_URL ||
+                  "http://localhost:3032/v1/subchain/state",
+        process.env.NEXT_PUBLIC_SUBCHAIN_WS_URL ||
+            "ws://localhost:3032/v1/subchain/eden-microchain",
+        process.env.NEXT_PUBLIC_SUBCHAIN_SLOW_MO === "true"
+    );
+    return (
+        <EdenChainContext.Provider value={subchain}>
+            <Component {...{ ...pageProps, subchain }} />
+        </EdenChainContext.Provider>
+    );
+};
+export default MyApp;
diff --git a/packages/example-history-app/src/pages/graphiql.tsx b/packages/example-history-app/src/pages/graphiql.tsx
new file mode 100644
index 000000000..5669f524e
--- /dev/null
+++ b/packages/example-history-app/src/pages/graphiql.tsx
@@ -0,0 +1,81 @@
+import Head from "next/head";
+import GraphiQL from "graphiql";
+import Header from "../components/header";
+import { buildSchema, GraphQLSchema } from "graphql";
+import { useContext } from "react";
+import { EdenChainContext, EdenSubchain } from "@edenos/common/dist/subchain";
+
+function createFetcher(subchain: EdenSubchain) {
+    return async ({ query }: { query: string }) => subchain.query(query);
+}
+
+const defaultQuery = `# GraphiQL is talking to a WASM running in the browser.
+# The WASM is preloaded with state which includes a subset
+# of blocks on the EOS blockchain with actions related to
+# the genesis.eden contract.
+
+{
+  members(first: 3, after: "30A95491D3189537") {
+    edges {
+      cursor
+      node {
+        account
+        inviter
+        profile {
+          name
+          img
+          bio
+        }
+      }
+    }
+  }
+}`;
+
+let schema: GraphQLSchema | null = null;
+
+export default function GraphiQLPage() {
+    const client = useContext(EdenChainContext);
+    if (client?.subchain && !schema)
+        schema = buildSchema(client.subchain.getSchema());
+    return (
+        <div>
+            <style global jsx>{`
+                html,
+                body,
+                body > div:first-child,
+                div#__next,
+                div#__next > div {
+                    height: 100%;
+                    border: 0;
+                    margin: 0;
+                    padding: 0;
+                }
+            `}</style>
+            <Head>
+                <title>GraphiQL</title>
+            </Head>
+            <main style={{ height: "100%" }}>
+                <div
+                    style={{
+                        display: "flex",
+                        flexDirection: "column",
+                        height: "100%",
+                    }}
+                >
+                    <Header />
+                    {client?.subchain && (
+                        <div style={{ flexGrow: 1 }}>
+                            <GraphiQL
+                                {...{
+                                    fetcher: createFetcher(client.subchain),
+                                    defaultQuery,
+                                    schema: schema!,
+                                }}
+                            />
+                        </div>
+                    )}
+                </div>
+            </main>
+        </div>
+    );
+}
diff --git a/packages/example-history-app/src/pages/index.tsx b/packages/example-history-app/src/pages/index.tsx
new file mode 100644
index 000000000..1f466a6f9
--- /dev/null
+++ b/packages/example-history-app/src/pages/index.tsx
@@ -0,0 +1,144 @@
+import Head from "next/head";
+import Header from "../components/header";
+import { usePagedQuery } from "@edenos/common/dist/subchain";
+
+const query = `
+{
+  members(@page@) {
+    pageInfo {
+      hasPreviousPage
+      hasNextPage
+      startCursor
+      endCursor
+    }
+    edges {
+      node {
+        account
+        profile {
+          name
+          img
+          bio
+        }
+      }
+    }
+  }
+}`;
+
+interface QueryResult {
+    data?: {
+        members: {
+            pageInfo: {
+                hasPreviousPage: boolean;
+                hasNextPage: boolean;
+                startCursor: string;
+                endCursor: string;
+            };
+            edges: [
+                {
+                    node: {
+                        account: string;
+                        profile: {
+                            name: string;
+                            img: string;
+                            bio: string;
+                        };
+                    };
+                }
+            ];
+        };
+    };
+}
+
+function Members() {
+    const pagedResult = usePagedQuery<QueryResult>(
+        query,
+        4,
+        (result) => result?.data?.members.pageInfo
+    );
+    return (
+        <div style={{ flexGrow: 1, margin: "10px" }}>
+            <h1>Members</h1>
+
+            <button disabled={!pagedResult.result} onClick={pagedResult.first}>
+                first
+            </button>
+            <button
+                disabled={!pagedResult.hasPreviousPage}
+                onClick={pagedResult.previous}
+            >
+                prev
+            </button>
+            <button
+                disabled={!pagedResult.hasNextPage}
+                onClick={pagedResult.next}
+            >
+                next
+            </button>
+            <button disabled={!pagedResult.result} onClick={pagedResult.last}>
+                last
+            </button>
+
+            {pagedResult.result?.data?.members.edges.map((edge) => (
+                <table
+                    key={edge.node.account}
+                    style={{ margin: 20, borderStyle: "solid" }}
+                >
+                    <tbody>
+                        <tr>
+                            <td>
+                                <b>Name:</b>
+                            </td>
+                            <td>{edge.node.profile.name}</td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <b>Image:</b>
+                            </td>
+                            <td>{edge.node.profile.img}</td>
+                        </tr>
+                        <tr>
+                            <td>
+                                <b>Bio:</b>
+                            </td>
+                            <td>{edge.node.profile.bio}</td>
+                        </tr>
+                    </tbody>
+                </table>
+            ))}
+        </div>
+    );
+}
+
+export default function Page() {
+    return (
+        <div>
+            <style global jsx>{`
+                html,
+                body,
+                body > div:first-child,
+                div#__next,
+                div#__next > div {
+                    height: 100%;
+                    border: 0;
+                    margin: 0;
+                    padding: 0;
+                }
+            `}</style>
+            <Head>
+                <title>Members</title>
+            </Head>
+            <main style={{ height: "100%" }}>
+                <div
+                    style={{
+                        display: "flex",
+                        flexDirection: "column",
+                        height: "100%",
+                    }}
+                >
+                    <Header />
+                    <Members />
+                </div>
+            </main>
+        </div>
+    );
+}
diff --git a/packages/example-history-app/src/pages/simple_members.tsx b/packages/example-history-app/src/pages/simple_members.tsx
new file mode 100644
index 000000000..1217c018b
--- /dev/null
+++ b/packages/example-history-app/src/pages/simple_members.tsx
@@ -0,0 +1,89 @@
+import Head from "next/head";
+import Header from "../components/header";
+import { Fragment } from "react";
+import { usePagedQuery } from "@edenos/common/dist/subchain";
+
+const query = `
+{
+  members(@page@) {
+    pageInfo{hasPreviousPage hasNextPage startCursor endCursor}
+    edges{node{account}}
+  }
+}`;
+
+function Members() {
+    const pagedResult = usePagedQuery(
+        query,
+        10,
+        (result) => result?.data?.members.pageInfo
+    );
+    return (
+        <Fragment>
+            <div>
+                <button
+                    disabled={!pagedResult.result}
+                    onClick={pagedResult.first}
+                >
+                    first
+                </button>
+                <button
+                    disabled={!pagedResult.hasPreviousPage}
+                    onClick={pagedResult.previous}
+                >
+                    prev
+                </button>
+                <button
+                    disabled={!pagedResult.hasNextPage}
+                    onClick={pagedResult.next}
+                >
+                    next
+                </button>
+                <button
+                    disabled={!pagedResult.result}
+                    onClick={pagedResult.last}
+                >
+                    last
+                </button>
+            </div>
+            <ul>
+                {pagedResult.result?.data?.members.edges.map((edge: any) => (
+                    <li key={edge.node.account}>{edge.node.account}</li>
+                ))}
+            </ul>
+        </Fragment>
+    );
+}
+
+export default function Page() {
+    return (
+        <div>
+            <style global jsx>{`
+                html,
+                body,
+                body > div:first-child,
+                div#__next,
+                div#__next > div {
+                    height: 100%;
+                    border: 0;
+                    margin: 0;
+                    padding: 0;
+                }
+            `}</style>
+            <Head>
+                <title>Members</title>
+            </Head>
+            <main style={{ height: "100%" }}>
+                <div
+                    style={{
+                        display: "flex",
+                        flexDirection: "column",
+                        height: "100%",
+                    }}
+                >
+                    <Header />
+                    <Members />
+                </div>
+            </main>
+        </div>
+    );
+}
diff --git a/packages/example-history-app/tsconfig.json b/packages/example-history-app/tsconfig.json
new file mode 100644
index 000000000..6123dc2ad
--- /dev/null
+++ b/packages/example-history-app/tsconfig.json
@@ -0,0 +1,21 @@
+{
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "lib": ["dom", "dom.iterable", "esnext"],
+        "baseUrl": "src",
+        "paths": {
+            "@edenos/*": ["packages/*/src"]
+        },
+        "allowJs": true,
+        "strict": true,
+        "forceConsistentCasingInFileNames": true,
+        "noEmit": true,
+        "moduleResolution": "node",
+        "resolveJsonModule": true,
+        "isolatedModules": true,
+        "jsx": "preserve",
+        "types": ["cypress"]
+    },
+    "exclude": ["node_modules"],
+    "include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"]
+}
diff --git a/wasm/CMakeLists.txt b/wasm/CMakeLists.txt
index d23b2be43..b966a3253 100644
--- a/wasm/CMakeLists.txt
+++ b/wasm/CMakeLists.txt
@@ -62,9 +62,104 @@ endfunction()
 add_clsdk_base_lib("")
 add_clsdk_base_lib("-debug")
 
+set(DEP_URL https://github.com/eoscommunity/Eden/releases/download/deps)
+set(GMP_ARCHIVE gmp-6.2.1.tar.zst)
+set(GMP_EXTRACTED gmp-6.2.1)
+set(OPENSSL_ARCHIVE openssl-1.1.1k.tar.gz)
+set(OPENSSL_EXTRACTED openssl-1.1.1k)
+set(ZLIB_ARCHIVE zlib-1.2.11.tar.gz)
+set(ZLIB_EXTRACTED zlib-1.2.11)
+set(DEP_PREFIX ${CMAKE_BINARY_DIR}/deps)
+
+function(download url archive)
+    if(NOT EXISTS ${archive})
+        message("Downloading ${url}")
+        file(DOWNLOAD ${url} ${archive}
+            STATUS download_status
+            TIMEOUT 60
+            SHOW_PROGRESS
+            TLS_VERIFY ON)
+        list(POP_BACK download_status BOOST_DOWNLOAD_STATUS_MSG)
+        if(NOT download_status EQUAL 0)
+            file(REMOVE ${archive})
+            message(FATAL_ERROR "Download ${url} failed. ${BOOST_DOWNLOAD_STATUS_MSG}")
+        endif()
+    endif()
+endfunction()
+
+# These builds are done at generation time so cmake's find_* commands can find them
+
+if(NOT EXISTS ${DEP_PREFIX}/lib/libz.a)
+    download(${DEP_URL}/${ZLIB_ARCHIVE} ${DEP_PREFIX}/${ZLIB_ARCHIVE})
+    message("building zlib")
+    execute_process(
+        WORKING_DIRECTORY ${DEP_PREFIX}
+        COMMAND bash -c "\
+               rm -rf ${ZLIB_EXTRACTED}                                             \
+            && tar xf ${ZLIB_ARCHIVE}                                               \
+            && cd ${ZLIB_EXTRACTED}                                                 \
+            && export CC=\"${CMAKE_C_COMPILER_LAUNCHER} ${CMAKE_C_COMPILER}\"       \
+            && export CXX=\"${CMAKE_CXX_COMPILER_LAUNCHER} ${CMAKE_CXX_COMPILER}\"  \
+            && export AR=${CMAKE_AR}                                                \
+            && export RANLIB=${CMAKE_RANLIB}                                        \
+            && export CFLAGS=\"--sysroot=${CMAKE_SYSROOT}\"                         \
+            && ./configure --prefix=${DEP_PREFIX} --static                          \
+            && make -j                                                              \
+            && make -j install                                                      \
+        "
+    )
+endif()
+
+if(NOT EXISTS ${DEP_PREFIX}/lib/libgmp.a)
+    download(${DEP_URL}/${GMP_ARCHIVE} ${DEP_PREFIX}/${GMP_ARCHIVE})
+    message("building gmp")
+    execute_process(
+        WORKING_DIRECTORY ${DEP_PREFIX}
+        COMMAND bash -c "\
+               rm -rf ${GMP_EXTRACTED}                                                      \
+            && tar xf ${GMP_ARCHIVE}                                                        \
+            && cd ${GMP_EXTRACTED}                                                          \
+            && ./configure                                                                  \
+                CC=\"${CMAKE_C_COMPILER_LAUNCHER} ${CMAKE_C_COMPILER}\"                     \
+                CFLAGS=\"--sysroot=${CMAKE_SYSROOT} -D_WASI_EMULATED_SIGNAL\"               \
+                LDFLAGS=-lwasi-emulated-signal                                              \
+                --prefix=${DEP_PREFIX}                                                      \
+                --host none                                                                 \
+                --disable-assembly   \                                                      \
+            && make -j                                                                      \
+            && make -j install                                                              \
+        "
+    )
+endif()
+
+if(NOT EXISTS ${DEP_PREFIX}/lib/libssl.a)
+    download(${DEP_URL}/${OPENSSL_ARCHIVE} ${DEP_PREFIX}/${OPENSSL_ARCHIVE})
+    message("building openssl")
+    set(OPENSSL_BUILD_FLAGS "--sysroot=${CMAKE_SYSROOT} -D_WASI_EMULATED_SIGNAL -DNO_SYSLOG -DOPENSSL_NO_SECURE_MEMORY")
+    execute_process(
+        WORKING_DIRECTORY ${DEP_PREFIX}
+        COMMAND bash -c "\
+               rm -rf ${OPENSSL_EXTRACTED}                                                  \
+            && tar xf ${OPENSSL_ARCHIVE}                                                    \
+            && cd ${OPENSSL_EXTRACTED}                                                      \
+            && ./Configure linux-generic32                                                  \
+                --prefix=${DEP_PREFIX}                                                      \
+                no-afalgeng no-asm no-dso no-shared no-sock no-tests no-threads no-ui       \
+                CC=\"${CMAKE_C_COMPILER_LAUNCHER} ${CMAKE_C_COMPILER}\"                     \
+                CXX=\"${CMAKE_CXX_COMPILER_LAUNCHER} ${CMAKE_CXX_COMPILER}\"                \
+                AR=${CMAKE_AR}                                                              \
+                RANLIB=${CMAKE_RANLIB}                                                      \
+                CFLAGS=\"${OPENSSL_BUILD_FLAGS}\"                                           \
+                CXXFLAGS=\"${OPENSSL_BUILD_FLAGS}\"                                         \
+            && make -j install_dev install_engines                                          \
+        "
+    )
+endif()
+
 add_subdirectory(../contracts contracts)
-add_subdirectory(../libraries libraries)
 add_subdirectory(../external external)
+add_subdirectory(../libraries libraries)
+add_subdirectory(../programs programs)
 add_subdirectory(boost)
 add_subdirectory(atomicassets)
 add_subdirectory(atomicmarket)
diff --git a/yarn.lock b/yarn.lock
index 3ad1be315..9a8648a21 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -643,6 +643,14 @@
     "@babel/plugin-transform-react-jsx-self" "^7.0.0"
     "@babel/plugin-transform-react-jsx-source" "^7.0.0"
 
+"@babel/runtime-corejs3@^7.10.2":
+  version "7.14.9"
+  resolved "https://registry.yarnpkg.com/@babel/runtime-corejs3/-/runtime-corejs3-7.14.9.tgz#fb21b1cf11650dcb8fcf4de2e6b3b8cf411da3f3"
+  integrity sha512-64RiH2ON4/y8qYtoa8rUiyam/tUVyGqRyNYhe+vCRGmjnV4bUlZvY+mwd0RrmLoCpJpdq3RsrNqKb7SJdw/4kw==
+  dependencies:
+    core-js-pure "^3.16.0"
+    regenerator-runtime "^0.13.4"
+
 "@babel/runtime@7.12.5":
   version "7.12.5"
   resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.12.5.tgz#410e7e487441e1b360c29be715d870d9b985882e"
@@ -657,6 +665,13 @@
   dependencies:
     regenerator-runtime "^0.13.2"
 
+"@babel/runtime@^7.10.2", "@babel/runtime@^7.11.2":
+  version "7.14.8"
+  resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.14.8.tgz#7119a56f421018852694290b9f9148097391b446"
+  integrity sha512-twj3L8Og5SaCRCErB4x4ajbvBIVV77CGeFglHpeg5WC5FF8TZzBWXtTJ4MqaD9QszLYTtr+IsaAL2rEUevb+eg==
+  dependencies:
+    regenerator-runtime "^0.13.4"
+
 "@babel/runtime@^7.12.5", "@babel/runtime@^7.5.5", "@babel/runtime@^7.6.2", "@babel/runtime@^7.7.2", "@babel/runtime@^7.8.4":
   version "7.14.0"
   resolved "https://registry.yarnpkg.com/@babel/runtime/-/runtime-7.14.0.tgz#46794bc20b612c5f75e62dd071e24dfd95f1cbe6"
@@ -780,6 +795,14 @@
     enabled "2.0.x"
     kuler "^2.0.0"
 
+"@dfuse/client@^0.3.20":
+  version "0.3.20"
+  resolved "https://registry.yarnpkg.com/@dfuse/client/-/client-0.3.20.tgz#43bb07607132c454489aca3f2f05d3cb74967601"
+  integrity sha512-KzBIiSh+AHv9oVZb0RDCYjy8tnN761bRxyW6DSMxDYBObB1p1m2GpPNxbIvBgeJNddO7/kK8xL6HNY9mGjWJww==
+  dependencies:
+    "@types/debug" "^0.0.31"
+    debug "^4.1.0"
+
 "@emotion/is-prop-valid@^0.8.1":
   version "0.8.8"
   resolved "https://registry.yarnpkg.com/@emotion/is-prop-valid/-/is-prop-valid-0.8.8.tgz#db28b1c4368a259b60a97311d6a952d4fd01ac1a"
@@ -819,6 +842,17 @@
   dependencies:
     purgecss "^3.1.3"
 
+"@graphiql/toolkit@^0.2.0":
+  version "0.2.2"
+  resolved "https://registry.yarnpkg.com/@graphiql/toolkit/-/toolkit-0.2.2.tgz#193d570afcf686c9ee61c92054c1782b9f3c1255"
+  integrity sha512-kDgYhqnS4p4LqSo1KvLd3tbX8Hhdj0ZrgQuGsosjjEnahiPYmmylxUL1p9lj6348OsypcTlCncGpEjeb9S3TiQ==
+  dependencies:
+    "@n1ru4l/push-pull-async-iterable-iterator" "^2.1.4"
+    graphql-ws "^4.3.2"
+    meros "^1.1.4"
+  optionalDependencies:
+    subscriptions-transport-ws "^0.9.18"
+
 "@greymass/eosio@^0.4.0":
   version "0.4.1"
   resolved "https://registry.yarnpkg.com/@greymass/eosio/-/eosio-0.4.1.tgz#7bad8418442cdcf71a304a56f167cabb15f1ff6c"
@@ -849,6 +883,14 @@
     "@hapi/boom" "9.x.x"
     "@hapi/hoek" "9.x.x"
 
+"@hapi/accept@5.0.2":
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/@hapi/accept/-/accept-5.0.2.tgz#ab7043b037e68b722f93f376afb05e85c0699523"
+  integrity sha512-CmzBx/bXUR8451fnZRuZAJRlzgm0Jgu5dltTX/bszmR2lheb9BpyN47Q1RbaGTsvFzn0PXAEs+lXDKfshccYZw==
+  dependencies:
+    "@hapi/boom" "9.x.x"
+    "@hapi/hoek" "9.x.x"
+
 "@hapi/boom@9.x.x":
   version "9.1.2"
   resolved "https://registry.yarnpkg.com/@hapi/boom/-/boom-9.1.2.tgz#48bd41d67437164a2d636e3b5bc954f8c8dc5e38"
@@ -1583,16 +1625,36 @@
   resolved "https://registry.yarnpkg.com/@multiformats/base-x/-/base-x-4.0.1.tgz#95ff0fa58711789d53aefb2590a8b7a4e715d121"
   integrity sha512-eMk0b9ReBbV23xXU693TAIrLyeO5iTgBZGSJfpqriG8UkYvr/hC9u9pyMlAakDNHWmbhMZCDs6KQO0jzKD8OTw==
 
+"@n1ru4l/push-pull-async-iterable-iterator@^2.1.4":
+  version "2.1.4"
+  resolved "https://registry.yarnpkg.com/@n1ru4l/push-pull-async-iterable-iterator/-/push-pull-async-iterable-iterator-2.1.4.tgz#a90225474352f9f159bff979905f707b9c6bcf04"
+  integrity sha512-qLIvoOUJ+zritv+BlzcBMePKNjKQzH9Rb2i9W98YXxf/M62Lye8qH0peyiU8yJ1tL0kfulWi31BoK10E6BKJeA==
+
 "@next/env@10.1.3":
   version "10.1.3"
   resolved "https://registry.yarnpkg.com/@next/env/-/env-10.1.3.tgz#29e5d62919b4a7b1859f8d36169848dc3f5ddebe"
   integrity sha512-q7z7NvmRs66lCQmVJtKjDxVtMTjSwP6ExVzaH46pbTH60MHgzEJ9H4jXrFLTihPmCIvpAv6Ai04jbS8dcg1ZMQ==
 
+"@next/env@11.0.1":
+  version "11.0.1"
+  resolved "https://registry.yarnpkg.com/@next/env/-/env-11.0.1.tgz#6dc96ac76f1663ab747340e907e8933f190cc8fd"
+  integrity sha512-yZfKh2U6R9tEYyNUrs2V3SBvCMufkJ07xMH5uWy8wqcl5gAXoEw6A/1LDqwX3j7pUutF9d1ZxpdGDA3Uag+aQQ==
+
+"@next/eslint-plugin-next@11.0.1":
+  version "11.0.1"
+  resolved "https://registry.yarnpkg.com/@next/eslint-plugin-next/-/eslint-plugin-next-11.0.1.tgz#5dd3264a40fadcf28eba00d914d69103422bb7e6"
+  integrity sha512-UzdX3y6XSrj9YuASUb/p4sRvfjP2klj2YgIOfMwrWoLTTPJQMh00hREB9Ftr7m7RIxjVSAaaLXIRLdxvq948GA==
+
 "@next/polyfill-module@10.1.3":
   version "10.1.3"
   resolved "https://registry.yarnpkg.com/@next/polyfill-module/-/polyfill-module-10.1.3.tgz#beafe89bc4235d436fa0ed02c9d2a5d311fb0238"
   integrity sha512-1DtUVcuoBJAn5IrxIZQjUG1KTPkiXMYloykPSkRxawimgvG9dRj2kscU+4KGNSFxHoxW9c68VRCb+7MDz5aGGw==
 
+"@next/polyfill-module@11.0.1":
+  version "11.0.1"
+  resolved "https://registry.yarnpkg.com/@next/polyfill-module/-/polyfill-module-11.0.1.tgz#ca2a110c1c44672cbcff6c2b983f0c0549d87291"
+  integrity sha512-Cjs7rrKCg4CF4Jhri8PCKlBXhszTfOQNl9AjzdNy4K5jXFyxyoSzuX2rK4IuoyE+yGp5A3XJCBEmOQ4xbUp9Mg==
+
 "@next/react-dev-overlay@10.1.3":
   version "10.1.3"
   resolved "https://registry.yarnpkg.com/@next/react-dev-overlay/-/react-dev-overlay-10.1.3.tgz#ee1c6033b29be9b383e061bd9705021d131ea445"
@@ -1610,11 +1672,33 @@
     stacktrace-parser "0.1.10"
     strip-ansi "6.0.0"
 
+"@next/react-dev-overlay@11.0.1":
+  version "11.0.1"
+  resolved "https://registry.yarnpkg.com/@next/react-dev-overlay/-/react-dev-overlay-11.0.1.tgz#3c481e83347255abd466dcf7e59ac8a79a0d7fd6"
+  integrity sha512-lvUjMVpLsgzADs9Q8wtC5LNqvfdN+M0BDMSrqr04EDWAyyX0vURHC9hkvLbyEYWyh+WW32pwjKBXdkMnJhoqMg==
+  dependencies:
+    "@babel/code-frame" "7.12.11"
+    anser "1.4.9"
+    chalk "4.0.0"
+    classnames "2.2.6"
+    css.escape "1.5.1"
+    data-uri-to-buffer "3.0.1"
+    platform "1.3.6"
+    shell-quote "1.7.2"
+    source-map "0.8.0-beta.0"
+    stacktrace-parser "0.1.10"
+    strip-ansi "6.0.0"
+
 "@next/react-refresh-utils@10.1.3":
   version "10.1.3"
   resolved "https://registry.yarnpkg.com/@next/react-refresh-utils/-/react-refresh-utils-10.1.3.tgz#65b3e1b9846c02452787fde1d54ad9c54b506dbd"
   integrity sha512-P4GJZuLKfD/o42JvGZ/xP4Hxg68vd3NeZxOLqIuQKFjjaYgC2IrO+lE5PTwGmRkytjfprJC+9j7Jss/xQAS6QA==
 
+"@next/react-refresh-utils@11.0.1":
+  version "11.0.1"
+  resolved "https://registry.yarnpkg.com/@next/react-refresh-utils/-/react-refresh-utils-11.0.1.tgz#a7509f22b6f70c13101a26573afd295295f1c020"
+  integrity sha512-K347DM6Z7gBSE+TfUaTTceWvbj0B6iNAsFZXbFZOlfg3uyz2sbKpzPYYFocCc27yjLaS8OfR8DEdS2mZXi8Saw==
+
 "@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"
@@ -1868,6 +1952,11 @@
   resolved "https://registry.yarnpkg.com/@protobufjs/utf8/-/utf8-1.1.0.tgz#a777360b5b39a1a2e5106f8e858f2fd2d060c570"
   integrity sha1-p3c2C1s5oaLlEG+OhY8v0tBgxXA=
 
+"@rushstack/eslint-patch@^1.0.6":
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/@rushstack/eslint-patch/-/eslint-patch-1.0.6.tgz#023d72a5c4531b4ce204528971700a78a85a0c50"
+  integrity sha512-Myxw//kzromB9yWgS8qYGuGVf91oBUUJpNvy5eM50sqvmKLbKjwLxohJnkWGTeeI9v9IBMtPLxz5Gc60FIfvCA==
+
 "@samverschueren/stream-to-observable@^0.3.0":
   version "0.3.1"
   resolved "https://registry.yarnpkg.com/@samverschueren/stream-to-observable/-/stream-to-observable-0.3.1.tgz#a21117b19ee9be70c379ec1877537ef2e1c63301"
@@ -1963,6 +2052,11 @@
   resolved "https://registry.yarnpkg.com/@types/cors/-/cors-2.8.10.tgz#61cc8469849e5bcdd0c7044122265c39cec10cf4"
   integrity sha512-C7srjHiVG3Ey1nR6d511dtDkCEjxuN9W1HWAEjGq8kpcwmNM6JJkpC0xvabM7BXTG2wDq8Eu33iH9aQKa7IvLQ==
 
+"@types/debug@^0.0.31":
+  version "0.0.31"
+  resolved "https://registry.yarnpkg.com/@types/debug/-/debug-0.0.31.tgz#bac8d8aab6a823e91deb7f79083b2a35fa638f33"
+  integrity sha512-LS1MCPaQKqspg7FvexuhmDbWUhE2yIJ+4AgVIyObfc06/UKZ8REgxGNjZc82wPLWmbeOm7S+gSsLgo75TanG4A==
+
 "@types/elliptic@6.4.10":
   version "6.4.10"
   resolved "https://registry.yarnpkg.com/@types/elliptic/-/elliptic-6.4.10.tgz#352078ebc911484e30fc0d1eca3e3c865bf0e8f8"
@@ -2033,6 +2127,14 @@
   dependencies:
     "@types/express" "*"
 
+"@types/node-fetch@^2.5.12":
+  version "2.5.12"
+  resolved "https://registry.yarnpkg.com/@types/node-fetch/-/node-fetch-2.5.12.tgz#8a6f779b1d4e60b7a57fb6fd48d84fb545b9cc66"
+  integrity sha512-MKgC4dlq4kKNa/mYrwpKfzQMB5X3ee5U6fSprkKpToBqBmX4nFZL9cW5jl6sWn+xpRJ7ypWh2yyqqr8UUCstSw==
+  dependencies:
+    "@types/node" "*"
+    form-data "^3.0.0"
+
 "@types/node@*":
   version "14.14.37"
   resolved "https://registry.yarnpkg.com/@types/node/-/node-14.14.37.tgz#a3dd8da4eb84a996c36e331df98d82abd76b516e"
@@ -2111,6 +2213,15 @@
     "@types/scheduler" "*"
     csstype "^3.0.2"
 
+"@types/react@^17.0.15":
+  version "17.0.15"
+  resolved "https://registry.yarnpkg.com/@types/react/-/react-17.0.15.tgz#c7533dc38025677e312606502df7656a6ea626d0"
+  integrity sha512-uTKHDK9STXFHLaKv6IMnwp52fm0hwU+N89w/p9grdUqcFA6WuqDyPhaWopbNyE1k/VhgzmHl8pu1L4wITtmlLw==
+  dependencies:
+    "@types/prop-types" "*"
+    "@types/scheduler" "*"
+    csstype "^3.0.2"
+
 "@types/scheduler@*":
   version "0.16.1"
   resolved "https://registry.yarnpkg.com/@types/scheduler/-/scheduler-0.16.1.tgz#18845205e86ff0038517aab7a18a62a6b9f71275"
@@ -2149,6 +2260,20 @@
   resolved "https://registry.yarnpkg.com/@types/uuid/-/uuid-8.3.1.tgz#1a32969cf8f0364b3d8c8af9cc3555b7805df14f"
   integrity sha512-Y2mHTRAbqfFkpjldbkHGY8JIzRN6XqYRliG8/24FcHm2D2PwW24fl5xMRTVGdrb7iMrwCaIEbLWerGIkXuFWVg==
 
+"@types/ws@^7.4.7":
+  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/yauzl@^2.9.1":
+  version "2.9.2"
+  resolved "https://registry.yarnpkg.com/@types/yauzl/-/yauzl-2.9.2.tgz#c48e5d56aff1444409e39fa164b0b4d4552a7b7a"
+  integrity sha512-8uALY5LTvSuHgloDVUvWP3pIauILm+8/0pDMokuDYIoNsOkSwd5AiHBTSEJjKTDcZr5z8UpgOWZkxBF4iJftoA==
+  dependencies:
+    "@types/node" "*"
+
 "@typescript-eslint/eslint-plugin@^4.5.0":
   version "4.20.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/eslint-plugin/-/eslint-plugin-4.20.0.tgz#9d8794bd99aad9153092ad13c96164e3082e9a92"
@@ -2175,6 +2300,16 @@
     eslint-scope "^5.0.0"
     eslint-utils "^2.0.0"
 
+"@typescript-eslint/parser@^4.20.0":
+  version "4.29.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-4.29.0.tgz#e5367ca3c63636bb5d8e0748fcbab7a4f4a04289"
+  integrity sha512-+92YRNHFdXgq+GhWQPT2bmjX09X7EH36JfgN2/4wmhtwV/HPxozpCNst8jrWcngLtEVd/4zAwA6BKojAlf+YqA==
+  dependencies:
+    "@typescript-eslint/scope-manager" "4.29.0"
+    "@typescript-eslint/types" "4.29.0"
+    "@typescript-eslint/typescript-estree" "4.29.0"
+    debug "^4.3.1"
+
 "@typescript-eslint/parser@^4.5.0":
   version "4.20.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/parser/-/parser-4.20.0.tgz#8dd403c8b4258b99194972d9799e201b8d083bdd"
@@ -2193,11 +2328,24 @@
     "@typescript-eslint/types" "4.20.0"
     "@typescript-eslint/visitor-keys" "4.20.0"
 
+"@typescript-eslint/scope-manager@4.29.0":
+  version "4.29.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/scope-manager/-/scope-manager-4.29.0.tgz#cf5474f87321bedf416ef65839b693bddd838599"
+  integrity sha512-HPq7XAaDMM3DpmuijxLV9Io8/6pQnliiXMQUcAdjpJJSR+fdmbD/zHCd7hMkjJn04UQtCQBtshgxClzg6NIS2w==
+  dependencies:
+    "@typescript-eslint/types" "4.29.0"
+    "@typescript-eslint/visitor-keys" "4.29.0"
+
 "@typescript-eslint/types@4.20.0":
   version "4.20.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.20.0.tgz#c6cf5ef3c9b1c8f699a9bbdafb7a1da1ca781225"
   integrity sha512-cYY+1PIjei1nk49JAPnH1VEnu7OYdWRdJhYI5wiKOUMhLTG1qsx5cQxCUTuwWCmQoyriadz3Ni8HZmGSofeC+w==
 
+"@typescript-eslint/types@4.29.0":
+  version "4.29.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/types/-/types-4.29.0.tgz#c8f1a1e4441ea4aca9b3109241adbc145f7f8a4e"
+  integrity sha512-2YJM6XfWfi8pgU2HRhTp7WgRw78TCRO3dOmSpAvIQ8MOv4B46JD2chnhpNT7Jq8j0APlIbzO1Bach734xxUl4A==
+
 "@typescript-eslint/typescript-estree@4.20.0":
   version "4.20.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.20.0.tgz#8b3b08f85f18a8da5d88f65cb400f013e88ab7be"
@@ -2211,6 +2359,19 @@
     semver "^7.3.2"
     tsutils "^3.17.1"
 
+"@typescript-eslint/typescript-estree@4.29.0":
+  version "4.29.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/typescript-estree/-/typescript-estree-4.29.0.tgz#af7ab547757b86c91bfdbc54ff86845410856256"
+  integrity sha512-8ZpNHDIOyqzzgZrQW9+xQ4k5hM62Xy2R4RPO3DQxMc5Rq5QkCdSpk/drka+DL9w6sXNzV5nrdlBmf8+x495QXQ==
+  dependencies:
+    "@typescript-eslint/types" "4.29.0"
+    "@typescript-eslint/visitor-keys" "4.29.0"
+    debug "^4.3.1"
+    globby "^11.0.3"
+    is-glob "^4.0.1"
+    semver "^7.3.5"
+    tsutils "^3.21.0"
+
 "@typescript-eslint/visitor-keys@4.20.0":
   version "4.20.0"
   resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.20.0.tgz#1e84db034da13f208325e6bfc995c3b75f7dbd62"
@@ -2219,6 +2380,14 @@
     "@typescript-eslint/types" "4.20.0"
     eslint-visitor-keys "^2.0.0"
 
+"@typescript-eslint/visitor-keys@4.29.0":
+  version "4.29.0"
+  resolved "https://registry.yarnpkg.com/@typescript-eslint/visitor-keys/-/visitor-keys-4.29.0.tgz#1ff60f240def4d85ea68d4fd2e4e9759b7850c04"
+  integrity sha512-LoaofO1C/jAJYs0uEpYMXfHboGXzOJeV118X4OsZu9f7rG7Pr9B3+4HTU8+err81rADa4xfQmAxnRnPAI2jp+Q==
+  dependencies:
+    "@typescript-eslint/types" "4.29.0"
+    eslint-visitor-keys "^2.0.0"
+
 JSONStream@^1.0.4:
   version "1.3.5"
   resolved "https://registry.yarnpkg.com/JSONStream/-/JSONStream-1.3.5.tgz#3208c1f08d3a4d99261ab64f92302bc15e111ca0"
@@ -2357,7 +2526,7 @@ ansi-escapes@^3.0.0:
   resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-3.2.0.tgz#8780b98ff9dbf5638152d1f1fe5c1d7b4442976b"
   integrity sha512-cBhpre4ma+U0T1oM5fXg7Dy1Jw7zzwv7lt/GoCpr+hDQJoYnKVPLL4dCvSEFMmQurOQvSrwT7SL/DAlhBI97RQ==
 
-ansi-escapes@^4.2.1:
+ansi-escapes@^4.2.1, ansi-escapes@^4.3.0:
   version "4.3.2"
   resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-4.3.2.tgz#6b2291d1db7d98b6521d5f1efa42d0f3a9feb65e"
   integrity sha512-gKXj5ALrKWQLsYG9jlTRmR/xKluxHV+Z9QEwNIgCfM1/uwPMCuzVVnh5mwTd+OuBZcwSIMbqssNWRm1lE51QaQ==
@@ -2467,6 +2636,14 @@ argparse@^1.0.7:
   dependencies:
     sprintf-js "~1.0.2"
 
+aria-query@^4.2.2:
+  version "4.2.2"
+  resolved "https://registry.yarnpkg.com/aria-query/-/aria-query-4.2.2.tgz#0d2ca6c9aceb56b8977e9fed6aed7e15bbd2f83b"
+  integrity sha512-o/HelwhuKpTj/frsOsbNLNgnNGVIFsVP/SW2BSF14gVl7kAfMOJ6/8wUAUvG1R1NHKrfG+2sHZTu0yauT1qBrA==
+  dependencies:
+    "@babel/runtime" "^7.10.2"
+    "@babel/runtime-corejs3" "^7.10.2"
+
 array-differ@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/array-differ/-/array-differ-3.0.0.tgz#3cbb3d0f316810eafcc47624734237d6aee4ae6b"
@@ -2492,7 +2669,7 @@ array-ify@^1.0.0:
   resolved "https://registry.yarnpkg.com/array-ify/-/array-ify-1.0.0.tgz#9e528762b4a9066ad163a6962a364418e9626ece"
   integrity sha1-nlKHYrSpBmrRY6aWKjZEGOlibs4=
 
-array-includes@^3.1.1:
+array-includes@^3.1.1, array-includes@^3.1.2, array-includes@^3.1.3:
   version "3.1.3"
   resolved "https://registry.yarnpkg.com/array-includes/-/array-includes-3.1.3.tgz#c7f619b382ad2afaf5326cddfdc0afc61af7690a"
   integrity sha512-gcem1KlBU7c9rB+Rq8/3PPKsK2kjqeEBa3bD5kkQo4nYlOHQCJqIJFqBXDEfwaRuYTT4E+FxA9xez7Gf/e3Q7A==
@@ -2517,6 +2694,16 @@ array.prototype.flat@^1.2.3:
     define-properties "^1.1.3"
     es-abstract "^1.18.0-next.1"
 
+array.prototype.flatmap@^1.2.4:
+  version "1.2.4"
+  resolved "https://registry.yarnpkg.com/array.prototype.flatmap/-/array.prototype.flatmap-1.2.4.tgz#94cfd47cc1556ec0747d97f7c7738c58122004c9"
+  integrity sha512-r9Z0zYoxqHz60vvQbWEdXIEtCwHF0yxaWfno9qzXeNHvfyl3BZqygmGzb84dsubyaXLH4husF+NFgMSdpZhk2Q==
+  dependencies:
+    call-bind "^1.0.0"
+    define-properties "^1.1.3"
+    es-abstract "^1.18.0-next.1"
+    function-bind "^1.1.1"
+
 arrify@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d"
@@ -2582,6 +2769,11 @@ assert@^1.1.1:
     object-assign "^4.1.1"
     util "0.10.3"
 
+ast-types-flow@^0.0.7:
+  version "0.0.7"
+  resolved "https://registry.yarnpkg.com/ast-types-flow/-/ast-types-flow-0.0.7.tgz#f70b735c6bca1a5c9c22d982c3e39e7feba3bdad"
+  integrity sha1-9wtzXGvKGlycItmCw+Oef+ujva0=
+
 ast-types@0.13.2:
   version "0.13.2"
   resolved "https://registry.yarnpkg.com/ast-types/-/ast-types-0.13.2.tgz#df39b677a911a83f3a049644fb74fdded23cea48"
@@ -2641,6 +2833,11 @@ aws4@^1.8.0:
   resolved "https://registry.yarnpkg.com/aws4/-/aws4-1.11.0.tgz#d61f46d83b2519250e2784daf5b09479a8b41c59"
   integrity sha512-xh1Rl34h6Fi1DC2WWKfxUTVqRsNnr6LsKz2+hfwDxQJWmrx8+c7ylaqBMcHfl1U1r2dsifOvKX3LQuLNZ+XSvA==
 
+axe-core@^4.0.2:
+  version "4.3.2"
+  resolved "https://registry.yarnpkg.com/axe-core/-/axe-core-4.3.2.tgz#fcf8777b82c62cfc69c7e9f32c0d2226287680e7"
+  integrity sha512-5LMaDRWm8ZFPAEdzTYmgjjEdj1YnQcpfrVajO/sn/LhbpGp0Y0H64c2hLZI1gRMxfA+w1S71Uc/nHaOXgcCvGg==
+
 axios@^0.21.1:
   version "0.21.1"
   resolved "https://registry.yarnpkg.com/axios/-/axios-0.21.1.tgz#22563481962f4d6bde9a76d516ef0e5d3c09b2b8"
@@ -2648,6 +2845,11 @@ axios@^0.21.1:
   dependencies:
     follow-redirects "^1.10.0"
 
+axobject-query@^2.2.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/axobject-query/-/axobject-query-2.2.0.tgz#943d47e10c0b704aa42275e20edf3722648989be"
+  integrity sha512-Td525n+iPOOyUQIeBfcASuG6uJsDOITl7Mds5gFyerkWiX7qhUTdYUBlSgNMyVqtSJqwpt1kXGLdUt6SykLMRA==
+
 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"
@@ -2678,6 +2880,11 @@ babel-runtime@6.26.0:
     core-js "^2.4.0"
     regenerator-runtime "^0.11.0"
 
+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=
+
 balanced-match@^1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767"
@@ -2935,7 +3142,7 @@ browserslist@4.16.1:
     escalade "^3.1.1"
     node-releases "^1.1.69"
 
-browserslist@^4.14.5, browserslist@^4.3.4:
+browserslist@4.16.6, browserslist@^4.14.5, browserslist@^4.3.4:
   version "4.16.6"
   resolved "https://registry.yarnpkg.com/browserslist/-/browserslist-4.16.6.tgz#d7901277a5a88e554ed305b183ec9b0c08f66fa2"
   integrity sha512-Wspk/PqO+4W9qp5iUTJsa1B/QrYn1keNCcEP5OvP7WBwT4KaDly0uONYmC6Xa3Z5IqnUgS0KcgLYu1l74x0ZXQ==
@@ -3135,6 +3342,11 @@ caniuse-lite@^1.0.30001173, caniuse-lite@^1.0.30001179, caniuse-lite@^1.0.300011
   resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001207.tgz#364d47d35a3007e528f69adb6fecb07c2bb2cc50"
   integrity sha512-UPQZdmAsyp2qfCTiMU/zqGSWOYaY9F9LL61V8f+8MrubsaDGpaHD9HRV/EWZGULZn0Hxu48SKzI5DgFwTvHuYw==
 
+caniuse-lite@^1.0.30001202, caniuse-lite@^1.0.30001228:
+  version "1.0.30001248"
+  resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001248.tgz#26ab45e340f155ea5da2920dadb76a533cb8ebce"
+  integrity sha512-NwlQbJkxUFJ8nMErnGtT0QTM2TJ33xgz4KXJSMIrjXIbDVdaYueGyjOrLKRtJC+rTiWfi6j5cnZN1NBiSBJGNw==
+
 caniuse-lite@^1.0.30001219:
   version "1.0.30001222"
   resolved "https://registry.yarnpkg.com/caniuse-lite/-/caniuse-lite-1.0.30001222.tgz#2789b8487282cbbe1700924f53951303d28086a9"
@@ -3313,6 +3525,14 @@ cli-truncate@^0.2.1:
     slice-ansi "0.0.4"
     string-width "^1.0.1"
 
+cli-truncate@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/cli-truncate/-/cli-truncate-2.1.0.tgz#c39e28bf05edcde5be3b98992a22deed5a2b93c7"
+  integrity sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==
+  dependencies:
+    slice-ansi "^3.0.0"
+    string-width "^4.2.0"
+
 cli-width@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-3.0.0.tgz#a2f48437a2caa9a22436e794bf071ec9e61cedf6"
@@ -3353,6 +3573,19 @@ code-point-at@^1.0.0:
   resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77"
   integrity sha1-DQcLTQQ6W+ozovGkDi7bPZpMz3c=
 
+codemirror-graphql@^1.0.0:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/codemirror-graphql/-/codemirror-graphql-1.0.2.tgz#cfbfb4ab9ed81467dc606848c5eb84e1f5d82766"
+  integrity sha512-D4+BdYa6iQnDlio4mBk1Yap5ROCqEWapSFLkiKGatx/I0dF6euzdwd0um3Ndudw6rFQbNuT7hpcH8tnBO6VOfQ==
+  dependencies:
+    graphql-language-service-interface "^2.8.2"
+    graphql-language-service-parser "^1.9.0"
+
+codemirror@^5.54.0:
+  version "5.62.2"
+  resolved "https://registry.yarnpkg.com/codemirror/-/codemirror-5.62.2.tgz#bce6d19c9829e6e788f83886d48ecf5c1e106e65"
+  integrity sha512-tVFMUa4J3Q8JUd1KL9yQzQB0/BJt7ZYZujZmTPgo/54Lpuq3ez4C8x/ATUY/wv7b7X3AUq8o3Xd+2C5ZrCGWHw==
+
 color-convert@^1.9.0, color-convert@^1.9.1:
   version "1.9.3"
   resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
@@ -3634,6 +3867,18 @@ cookie@0.4.0:
   resolved "https://registry.yarnpkg.com/cookie/-/cookie-0.4.0.tgz#beb437e7022b3b6d49019d088665303ebe9c14ba"
   integrity sha512-+Hp8fLp57wnUSt0tY0tHEXh4voZRDnoIrZPqlo3DPiI4y9lwg/jqx+1Om94/W6ZaPDOUbnjOt/99w66zk+l1Xg==
 
+copy-to-clipboard@^3.2.0:
+  version "3.3.1"
+  resolved "https://registry.yarnpkg.com/copy-to-clipboard/-/copy-to-clipboard-3.3.1.tgz#115aa1a9998ffab6196f93076ad6da3b913662ae"
+  integrity sha512-i13qo6kIHTTpCm8/Wup+0b1mVWETvu2kIMzKoK8FpkLkFxlt0znUAHcMzox+T8sPlqtZXq3CulEjQHsYiGFJUw==
+  dependencies:
+    toggle-selection "^1.0.6"
+
+core-js-pure@^3.16.0:
+  version "3.16.0"
+  resolved "https://registry.yarnpkg.com/core-js-pure/-/core-js-pure-3.16.0.tgz#218e07add3f1844e53fab195c47871fc5ba18de8"
+  integrity sha512-wzlhZNepF/QA9yvx3ePDgNGudU5KDB8lu/TRPKelYA/QtSnkS/cLl2W+TIdEX1FAFcBr0YpY7tPDlcmXJ7AyiQ==
+
 core-js@^2.4.0:
   version "2.6.12"
   resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.6.12.tgz#d9333dfa7b065e347cc5682219d6f690859cc2ec"
@@ -3784,6 +4029,13 @@ cssnano-preset-simple@1.2.2:
     caniuse-lite "^1.0.30001179"
     postcss "^7.0.32"
 
+cssnano-preset-simple@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/cssnano-preset-simple/-/cssnano-preset-simple-2.0.0.tgz#b55e72cb970713f425560a0e141b0335249e2f96"
+  integrity sha512-HkufSLkaBJbKBFx/7aj5HmCK9Ni/JedRQm0mT2qBzMG/dEuJOLnMt2lK6K1rwOOyV4j9aSY+knbW9WoS7BYpzg==
+  dependencies:
+    caniuse-lite "^1.0.30001202"
+
 cssnano-simple@1.2.2:
   version "1.2.2"
   resolved "https://registry.yarnpkg.com/cssnano-simple/-/cssnano-simple-1.2.2.tgz#72c2c3970e67123c3b4130894a30dc1050267007"
@@ -3792,6 +4044,13 @@ cssnano-simple@1.2.2:
     cssnano-preset-simple "1.2.2"
     postcss "^7.0.32"
 
+cssnano-simple@2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/cssnano-simple/-/cssnano-simple-2.0.0.tgz#930d9dcd8ba105c5a62ce719cb00854da58b5c05"
+  integrity sha512-0G3TXaFxlh/szPEG/o3VcmCwl0N3E60XNb9YZZijew5eIs6fLjJuOPxQd9yEBaX2p/YfJtt49i4vYi38iH6/6w==
+  dependencies:
+    cssnano-preset-simple "^2.0.0"
+
 csstype@^3.0.2:
   version "3.0.7"
   resolved "https://registry.yarnpkg.com/csstype/-/csstype-3.0.7.tgz#2a5fb75e1015e84dd15692f71e89a1450290950b"
@@ -3849,6 +4108,58 @@ cypress@^7.2.0:
     url "^0.11.0"
     yauzl "^2.10.0"
 
+cypress@^8.1.0:
+  version "8.2.0"
+  resolved "https://registry.yarnpkg.com/cypress/-/cypress-8.2.0.tgz#1e4e9f6218324e82a95c1b9cad7f3965ba663d7f"
+  integrity sha512-jg7S5VxxslwsgEyAkCE9ZCkFADxOUY1bSWScp1cWnga88K0TZgFQ0zdxyG9Mw/4spLGuvkriIZ62am+TR6C04w==
+  dependencies:
+    "@cypress/request" "^2.88.5"
+    "@cypress/xvfb" "^1.2.4"
+    "@types/node" "^14.14.31"
+    "@types/sinonjs__fake-timers" "^6.0.2"
+    "@types/sizzle" "^2.3.2"
+    arch "^2.2.0"
+    blob-util "^2.0.2"
+    bluebird "^3.7.2"
+    cachedir "^2.3.0"
+    chalk "^4.1.0"
+    check-more-types "^2.24.0"
+    cli-cursor "^3.1.0"
+    cli-table3 "~0.6.0"
+    commander "^5.1.0"
+    common-tags "^1.8.0"
+    dayjs "^1.10.4"
+    debug "^4.3.2"
+    enquirer "^2.3.6"
+    eventemitter2 "^6.4.3"
+    execa "4.1.0"
+    executable "^4.1.1"
+    extract-zip "2.0.1"
+    figures "^3.2.0"
+    fs-extra "^9.1.0"
+    getos "^3.2.1"
+    is-ci "^3.0.0"
+    is-installed-globally "~0.4.0"
+    lazy-ass "^1.6.0"
+    listr2 "^3.8.3"
+    lodash "^4.17.21"
+    log-symbols "^4.0.0"
+    minimist "^1.2.5"
+    ospath "^1.2.2"
+    pretty-bytes "^5.6.0"
+    ramda "~0.27.1"
+    request-progress "^3.0.0"
+    supports-color "^8.1.1"
+    tmp "~0.2.1"
+    untildify "^4.0.0"
+    url "^0.11.0"
+    yauzl "^2.10.0"
+
+damerau-levenshtein@^1.0.6:
+  version "1.0.7"
+  resolved "https://registry.yarnpkg.com/damerau-levenshtein/-/damerau-levenshtein-1.0.7.tgz#64368003512a1a6992593741a09a9d31a836f55d"
+  integrity sha512-VvdQIPGdWP0SqFXghj79Wf/5LArmreyMsGLa6FG6iC4t3j7j5s71TrwWmT/4akbDQIqjfACkLZmjXhA7g2oUZw==
+
 dargs@^7.0.0:
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/dargs/-/dargs-7.0.0.tgz#04015c41de0bcb69ec84050f3d9be0caf8d6d5cc"
@@ -3903,7 +4214,7 @@ debug@4, debug@^4.0.1, debug@^4.1.0, debug@^4.1.1, debug@^4.3.1:
   dependencies:
     ms "2.1.2"
 
-debug@4.3.2:
+debug@4.3.2, debug@^4.3.2:
   version "4.3.2"
   resolved "https://registry.yarnpkg.com/debug/-/debug-4.3.2.tgz#f0a49c18ac8779e31d4a0c6029dfb76873c7428b"
   integrity sha512-mOp8wKcvj7XxC78zLgw/ZA+6TSgkoE2C/ienthhRD298T7UNwAg9diBpLRxC0mOezLl4B0xV7M0cCO6P/O0Xhw==
@@ -4095,6 +4406,13 @@ doctrine@1.5.0:
     esutils "^2.0.2"
     isarray "^1.0.0"
 
+doctrine@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-2.1.0.tgz#5cd01fc101621b42c4cd7f5d1a66243716d3f39d"
+  integrity sha512-35mSku4ZXK0vfCuHEDAwt55dg2jNajHZ1odvF+8SSr82EsZY4QmXfuWso8oEd8zRhVObSN18aM0CjSdoBX7zIw==
+  dependencies:
+    esutils "^2.0.2"
+
 doctrine@^3.0.0:
   version "3.0.0"
   resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-3.0.0.tgz#addebead72a6574db783639dc87a121773973961"
@@ -4143,6 +4461,11 @@ dotenv@^8.0.0:
   resolved "https://registry.yarnpkg.com/dotenv/-/dotenv-8.6.0.tgz#061af664d19f7f4d8fc6e4ff9b584ce237adcb8b"
   integrity sha512-IrPdXQsk2BbzvCBGBOTmmSH5SodmqZNt4ERAZDmW4CT+tL8VtvinqywuANaFu4bOMWki16nqf0e4oC0QIaDr/g==
 
+dset@^3.1.0:
+  version "3.1.0"
+  resolved "https://registry.yarnpkg.com/dset/-/dset-3.1.0.tgz#23feb6df93816ea452566308b1374d6e869b0d7b"
+  integrity sha512-7xTQ5DzyE59Nn+7ZgXDXjKAGSGmXZHqttMVVz1r4QNfmGpyj+cm2YtI3II0c/+4zS4a9yq2mBhgdeq2QnpcYlw==
+
 duplexer@^0.1.1:
   version "0.1.2"
   resolved "https://registry.yarnpkg.com/duplexer/-/duplexer-0.1.2.tgz#3abe43aef3835f8ae077d136ddce0f276b0400e6"
@@ -4262,6 +4585,11 @@ emoji-regex@^8.0.0:
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-8.0.0.tgz#e818fd69ce5ccfcb404594f842963bf53164cc37"
   integrity sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==
 
+emoji-regex@^9.0.0:
+  version "9.2.2"
+  resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-9.2.2.tgz#840c8803b0d8047f4ff0cf963176b32d4ef3ed72"
+  integrity sha512-L18DaJsXSUk2+42pv8mLs5jJT2hqFkFE4j21wOmgbUqsZ2hL72NsUU785g9RXgo3s0ZNgVl42TiHp3ZtOv/Vyg==
+
 emojis-list@^2.0.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/emojis-list/-/emojis-list-2.1.0.tgz#4daa4d9db00f9819880c79fa457ae5b09a1fd389"
@@ -4291,13 +4619,23 @@ end-of-stream@^1.1.0:
   dependencies:
     once "^1.4.0"
 
-enquirer@^2.3.5:
+enquirer@^2.3.5, enquirer@^2.3.6:
   version "2.3.6"
   resolved "https://registry.yarnpkg.com/enquirer/-/enquirer-2.3.6.tgz#2a7fe5dd634a1e4125a975ec994ff5456dc3734d"
   integrity sha512-yjNnPr315/FjS4zIsUxYguYUPP2e1NK4d7E7ZOLiyYCcbFBiTMyID+2wvm2w6+pZ/odMA7cRkjhsPbltwBOrLg==
   dependencies:
     ansi-colors "^4.1.1"
 
+entities@^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.0.0:
+  version "2.0.3"
+  resolved "https://registry.yarnpkg.com/entities/-/entities-2.0.3.tgz#5c487e5742ab93c15abb5da22759b8590ec03b7f"
+  integrity sha512-MyoZ0jgnLvB2X3Lg5HqpFmn1kybDiIfEQmKzTb5apr51Rb+T3KdmMiqa70T+bhGnyv7bQ6WMj2QMHpGMmlrUYQ==
+
 env-paths@^2.2.0:
   version "2.2.1"
   resolved "https://registry.yarnpkg.com/env-paths/-/env-paths-2.2.1.tgz#420399d416ce1fbe9bc0a07c62fa68d67fd0f8f2"
@@ -4437,6 +4775,29 @@ es-abstract@^1.18.0-next.1, es-abstract@^1.18.0-next.2:
     string.prototype.trimstart "^1.0.4"
     unbox-primitive "^1.0.0"
 
+es-abstract@^1.18.2:
+  version "1.18.5"
+  resolved "https://registry.yarnpkg.com/es-abstract/-/es-abstract-1.18.5.tgz#9b10de7d4c206a3581fd5b2124233e04db49ae19"
+  integrity sha512-DDggyJLoS91CkJjgauM5c0yZMjiD1uK3KcaCeAmffGwZ+ODWzOkPN4QwRbsK5DOFf06fywmyLci3ZD8jLGhVYA==
+  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"
+    internal-slot "^1.0.3"
+    is-callable "^1.2.3"
+    is-negative-zero "^2.0.1"
+    is-regex "^1.1.3"
+    is-string "^1.0.6"
+    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-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"
@@ -4471,6 +4832,21 @@ escape-string-regexp@^1.0.2, escape-string-regexp@^1.0.5:
   resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
   integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
 
+eslint-config-next@^11.0.1:
+  version "11.0.1"
+  resolved "https://registry.yarnpkg.com/eslint-config-next/-/eslint-config-next-11.0.1.tgz#abdd2565a6fa5841556a89ba935f044bec173d0b"
+  integrity sha512-yy63K4Bmy8amE6VMb26CZK6G99cfVX3JaMTvuvmq/LL8/b8vKHcauUZREBTAQ+2DrIvlH4YrFXrkQ1vpYDL9Eg==
+  dependencies:
+    "@next/eslint-plugin-next" "11.0.1"
+    "@rushstack/eslint-patch" "^1.0.6"
+    "@typescript-eslint/parser" "^4.20.0"
+    eslint-import-resolver-node "^0.3.4"
+    eslint-import-resolver-typescript "^2.4.0"
+    eslint-plugin-import "^2.22.1"
+    eslint-plugin-jsx-a11y "^6.4.1"
+    eslint-plugin-react "^7.23.1"
+    eslint-plugin-react-hooks "^4.2.0"
+
 eslint-config-prettier@^8.1.0:
   version "8.1.0"
   resolved "https://registry.yarnpkg.com/eslint-config-prettier/-/eslint-config-prettier-8.1.0.tgz#4ef1eaf97afe5176e6a75ddfb57c335121abc5a6"
@@ -4484,6 +4860,17 @@ eslint-import-resolver-node@^0.3.4:
     debug "^2.6.9"
     resolve "^1.13.1"
 
+eslint-import-resolver-typescript@^2.4.0:
+  version "2.4.0"
+  resolved "https://registry.yarnpkg.com/eslint-import-resolver-typescript/-/eslint-import-resolver-typescript-2.4.0.tgz#ec1e7063ebe807f0362a7320543aaed6fe1100e1"
+  integrity sha512-useJKURidCcldRLCNKWemr1fFQL1SzB3G4a0li6lFGvlc5xGe1hY343bvG07cbpCzPuM/lK19FIJB3XGFSkplA==
+  dependencies:
+    debug "^4.1.1"
+    glob "^7.1.6"
+    is-glob "^4.0.1"
+    resolve "^1.17.0"
+    tsconfig-paths "^3.9.0"
+
 eslint-module-utils@^2.6.0:
   version "2.6.0"
   resolved "https://registry.yarnpkg.com/eslint-module-utils/-/eslint-module-utils-2.6.0.tgz#579ebd094f56af7797d19c9866c9c9486629bfa6"
@@ -4511,6 +4898,23 @@ eslint-plugin-import@^2.22.1:
     resolve "^1.17.0"
     tsconfig-paths "^3.9.0"
 
+eslint-plugin-jsx-a11y@^6.4.1:
+  version "6.4.1"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-jsx-a11y/-/eslint-plugin-jsx-a11y-6.4.1.tgz#a2d84caa49756942f42f1ffab9002436391718fd"
+  integrity sha512-0rGPJBbwHoGNPU73/QCLP/vveMlM1b1Z9PponxO87jfr6tuH5ligXbDT6nHSSzBC8ovX2Z+BQu7Bk5D/Xgq9zg==
+  dependencies:
+    "@babel/runtime" "^7.11.2"
+    aria-query "^4.2.2"
+    array-includes "^3.1.1"
+    ast-types-flow "^0.0.7"
+    axe-core "^4.0.2"
+    axobject-query "^2.2.0"
+    damerau-levenshtein "^1.0.6"
+    emoji-regex "^9.0.0"
+    has "^1.0.3"
+    jsx-ast-utils "^3.1.0"
+    language-tags "^1.0.5"
+
 eslint-plugin-prettier@^3.3.1:
   version "3.3.1"
   resolved "https://registry.yarnpkg.com/eslint-plugin-prettier/-/eslint-plugin-prettier-3.3.1.tgz#7079cfa2497078905011e6f82e8dd8453d1371b7"
@@ -4518,6 +4922,29 @@ eslint-plugin-prettier@^3.3.1:
   dependencies:
     prettier-linter-helpers "^1.0.0"
 
+eslint-plugin-react-hooks@^4.2.0:
+  version "4.2.0"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-react-hooks/-/eslint-plugin-react-hooks-4.2.0.tgz#8c229c268d468956334c943bb45fc860280f5556"
+  integrity sha512-623WEiZJqxR7VdxFCKLI6d6LLpwJkGPYKODnkH3D7WpOG5KM8yWueBd8TLsNAetEJNF5iJmolaAKO3F8yzyVBQ==
+
+eslint-plugin-react@^7.23.1:
+  version "7.24.0"
+  resolved "https://registry.yarnpkg.com/eslint-plugin-react/-/eslint-plugin-react-7.24.0.tgz#eadedfa351a6f36b490aa17f4fa9b14e842b9eb4"
+  integrity sha512-KJJIx2SYx7PBx3ONe/mEeMz4YE0Lcr7feJTCMyyKb/341NcjuAgim3Acgan89GfPv7nxXK2+0slu0CWXYM4x+Q==
+  dependencies:
+    array-includes "^3.1.3"
+    array.prototype.flatmap "^1.2.4"
+    doctrine "^2.1.0"
+    has "^1.0.3"
+    jsx-ast-utils "^2.4.1 || ^3.0.0"
+    minimatch "^3.0.4"
+    object.entries "^1.1.4"
+    object.fromentries "^2.0.4"
+    object.values "^1.1.4"
+    prop-types "^15.7.2"
+    resolve "^2.0.0-next.3"
+    string.prototype.matchall "^4.0.5"
+
 eslint-scope@^5.0.0, eslint-scope@^5.1.1:
   version "5.1.1"
   resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-5.1.1.tgz#e786e59a66cb92b3f6c1fb0d508aab174848f48c"
@@ -4644,6 +5071,11 @@ eventemitter2@^6.4.3:
   resolved "https://registry.yarnpkg.com/eventemitter2/-/eventemitter2-6.4.4.tgz#aa96e8275c4dbeb017a5d0e03780c65612a1202b"
   integrity sha512-HLU3NDY6wARrLCEwyGKRBvuWYyvW6mHYv72SJJAH3iJN3a6eVUvkjFkcxah1bcTgGVBBrFdIopBJPhCQFMLyXw==
 
+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.7"
   resolved "https://registry.yarnpkg.com/eventemitter3/-/eventemitter3-4.0.7.tgz#2de9b68f6528d5644ef5c59526a1b4a07306169f"
@@ -4759,6 +5191,17 @@ external-editor@^3.0.3:
     iconv-lite "^0.4.24"
     tmp "^0.0.33"
 
+extract-zip@2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/extract-zip/-/extract-zip-2.0.1.tgz#663dca56fe46df890d5f131ef4a06d22bb8ba13a"
+  integrity sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==
+  dependencies:
+    debug "^4.1.1"
+    get-stream "^5.1.0"
+    yauzl "^2.10.0"
+  optionalDependencies:
+    "@types/yauzl" "^2.9.1"
+
 extract-zip@^1.7.0:
   version "1.7.0"
   resolved "https://registry.yarnpkg.com/extract-zip/-/extract-zip-1.7.0.tgz#556cc3ae9df7f452c493a0cfb51cc30277940927"
@@ -4862,7 +5305,7 @@ figures@^2.0.0:
   dependencies:
     escape-string-regexp "^1.0.5"
 
-figures@^3.0.0:
+figures@^3.0.0, figures@^3.2.0:
   version "3.2.0"
   resolved "https://registry.yarnpkg.com/figures/-/figures-3.2.0.tgz#625c18bd293c604dc4a8ddb2febf0c88341746af"
   integrity sha512-yaduQFRKLXYOGgEn6AZau90j3ggSOyiqXU0F9JZfeXYhNa+Jk4X+s45A2zg5jns87GAFa34BBm2kXw4XpNcbdg==
@@ -4973,6 +5416,15 @@ forever-agent@~0.6.1:
   resolved "https://registry.yarnpkg.com/forever-agent/-/forever-agent-0.6.1.tgz#fbc71f0c41adeb37f96c577ad1ed42d8fdacca91"
   integrity sha1-+8cfDEGt6zf5bFd60e1C2P2sypE=
 
+form-data@^3.0.0:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/form-data/-/form-data-3.0.1.tgz#ebd53791b78356a99af9a300d4282c4d5eb9755f"
+  integrity sha512-RHkBKtLWUVwd7SqRIvCZMEvAMoGUp0XU+seQiZejj0COz3RI3hWP4sCv3gZWWLjJTd7rGwcsF5eKZGii0r/hbg==
+  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"
@@ -5069,7 +5521,7 @@ get-caller-file@^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, get-intrinsic@^1.1.1:
+get-intrinsic@^1.0.2, 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==
@@ -5118,7 +5570,7 @@ get-stdin@^4.0.1:
   resolved "https://registry.yarnpkg.com/get-stdin/-/get-stdin-4.0.1.tgz#b968c6b0a04384324902e8bf1a5df32579a450fe"
   integrity sha1-uWjGsKBDhDJJAui/Gl3zJXmkUP4=
 
-get-stream@^5.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==
@@ -5263,6 +5715,18 @@ globby@^11.0.1, globby@^11.0.2:
     merge2 "^1.3.0"
     slash "^3.0.0"
 
+globby@^11.0.3:
+  version "11.0.4"
+  resolved "https://registry.yarnpkg.com/globby/-/globby-11.0.4.tgz#2cbaff77c2f2a62e71e9b2813a67b97a3a3001a5"
+  integrity sha512-9O4MVG9ioZJ08ffbcyVYyLOJLk5JQ688pJ4eMGLpdWLHq/Wr1D9BlriLQyL0E+jbkuePVZXYFj47QM/v093wHg==
+  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"
+
 goober@^2.0.15:
   version "2.0.37"
   resolved "https://registry.yarnpkg.com/goober/-/goober-2.0.37.tgz#5598c41f4c19bc1fca2c926e876a58a685faffb8"
@@ -5273,6 +5737,68 @@ graceful-fs@^4.1.11, graceful-fs@^4.1.15, graceful-fs@^4.1.2, graceful-fs@^4.1.6
   resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.6.tgz#ff040b2b0853b23c3d31027523706f1885d76bee"
   integrity sha512-nTnJ528pbqxYanhpDYsi4Rd8MAeaBA67+RZ10CM1m3bTAVFEDcd5AuA4a6W5YkGZ1iNXHzZz8T6TBKLeBuNriQ==
 
+graphiql@^1.4.2:
+  version "1.4.2"
+  resolved "https://registry.yarnpkg.com/graphiql/-/graphiql-1.4.2.tgz#a1dc1a4d8d35f60c90d6d8a9eb62a99756e9fd9b"
+  integrity sha512-TQDuuU/ZqTWV1yQDpVEiKskg0IYA+Wck37DYrrFzLlpgZWRbWiyab1PyHKiRep7J540CgScBg6C/gGCymKyO3g==
+  dependencies:
+    "@graphiql/toolkit" "^0.2.0"
+    codemirror "^5.54.0"
+    codemirror-graphql "^1.0.0"
+    copy-to-clipboard "^3.2.0"
+    dset "^3.1.0"
+    entities "^2.0.0"
+    graphql-language-service "^3.1.2"
+    markdown-it "^10.0.0"
+
+graphql-language-service-interface@^2.8.2:
+  version "2.8.4"
+  resolved "https://registry.yarnpkg.com/graphql-language-service-interface/-/graphql-language-service-interface-2.8.4.tgz#3ff31754e9b295b1abc26b97d286c00835aacff0"
+  integrity sha512-myW8z7HOZkYfhYGKDc0URFkTZChp41Po890W92zuBIhGccckgtiWSJGXaLX+r9QAwVIeZhKaNgEacsyvQb1f/g==
+  dependencies:
+    graphql-language-service-parser "^1.9.0"
+    graphql-language-service-types "^1.8.0"
+    graphql-language-service-utils "^2.5.1"
+    vscode-languageserver-types "^3.15.1"
+
+graphql-language-service-parser@^1.9.0:
+  version "1.9.2"
+  resolved "https://registry.yarnpkg.com/graphql-language-service-parser/-/graphql-language-service-parser-1.9.2.tgz#b2dc45620cb6b9bac8ac175c197c77f0ff12d679"
+  integrity sha512-3txms73cJsXDfJQdR5hI83N2rpTuq9FD6aijdrXAeSuI5B60g32DxjelUkt4Ge+2BvBEDLn5ppXlpVYDC9UQHQ==
+  dependencies:
+    graphql-language-service-types "^1.8.0"
+
+graphql-language-service-types@^1.8.0:
+  version "1.8.2"
+  resolved "https://registry.yarnpkg.com/graphql-language-service-types/-/graphql-language-service-types-1.8.2.tgz#50ae56f69cc24fcfc3daa129b68b0eb9421e8578"
+  integrity sha512-Sj07RHnMwAhEvAt7Jdt1l/x56ZpoNh+V6g+T58CF6GiYqI5l4vXqqRB4d4xHDcNQX98GpJfnf3o8BqPgP3C5Sw==
+
+graphql-language-service-utils@^2.5.1:
+  version "2.5.3"
+  resolved "https://registry.yarnpkg.com/graphql-language-service-utils/-/graphql-language-service-utils-2.5.3.tgz#185f4f65cf8c010871eb9405452a3a0bfdf88748"
+  integrity sha512-ydevEZ0AgzEKQF3hiCbLXuS0o7189Ww/T30WtCKCLaRHDYk9Yyb2PZWdhSTWLxYZTaX2TccV6NtFWvzIC7UP3g==
+  dependencies:
+    graphql-language-service-types "^1.8.0"
+    nullthrows "^1.0.0"
+
+graphql-language-service@^3.1.2:
+  version "3.1.4"
+  resolved "https://registry.yarnpkg.com/graphql-language-service/-/graphql-language-service-3.1.4.tgz#ca8698f70e9923e3267e3d457228bc55a7dd75f9"
+  integrity sha512-AF98AT4wLxkE9q1gRf20Yn0EPgd5SctRiw1IkGFivPr98pEX0sKqUcIcIHePn2mxqf73jlWUJV5v6l/CB1gdqQ==
+  dependencies:
+    graphql-language-service-interface "^2.8.2"
+    graphql-language-service-types "^1.8.0"
+
+graphql-ws@^4.3.2:
+  version "4.9.0"
+  resolved "https://registry.yarnpkg.com/graphql-ws/-/graphql-ws-4.9.0.tgz#5cfd8bb490b35e86583d8322f5d5d099c26e365c"
+  integrity sha512-sHkK9+lUm20/BGawNEWNtVAeJzhZeBg21VmvmLoT5NdGVeZWv5PdIhkcayQIAgjSyyQ17WMKmbDijIPG2On+Ag==
+
+graphql@^15.5.1:
+  version "15.5.1"
+  resolved "https://registry.yarnpkg.com/graphql/-/graphql-15.5.1.tgz#f2f84415d8985e7b84731e7f3536f8bb9d383aad"
+  integrity sha512-FeTRX67T3LoE3LWAxxOlW2K3Bz+rMYAC18rRguK4wgXaTZMiJwSUwDmPFo3UadAKbzirKIg5Qy+sNJXbpPRnQw==
+
 hamt-sharding@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/hamt-sharding/-/hamt-sharding-2.0.0.tgz#1b11f1ce8788074f9a75cdc25090600e4773cfa7"
@@ -5519,6 +6045,13 @@ ignore@^5.1.4:
   resolved "https://registry.yarnpkg.com/ignore/-/ignore-5.1.8.tgz#f150a8b50a34289b33e22f5889abd4d8016f0e57"
   integrity sha512-BMpfD7PpiETpBl/A6S498BaIJ6Y/ABT93ETbby2fP00v4EbvPBXWEoaR1UBPKs3iR53pJY7EtZk5KACI57i1Uw==
 
+image-size@1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/image-size/-/image-size-1.0.0.tgz#58b31fe4743b1cec0a0ac26f5c914d3c5b2f0750"
+  integrity sha512-JLJ6OwBfO1KcA+TvJT+v8gbE6iWbj24LyDNFgFEN0lzegn6cC6a/p3NIDaepMsJjQjlUWqIC7wJv8lBFxPNjcw==
+  dependencies:
+    queue "6.0.2"
+
 import-fresh@^3.0.0, import-fresh@^3.2.1:
   version "3.3.0"
   resolved "https://registry.yarnpkg.com/import-fresh/-/import-fresh-3.3.0.tgz#37162c25fcb9ebaa2e6e53d5b4d88ce17d9e0c2b"
@@ -5657,6 +6190,15 @@ interface-ipld-format@^1.0.0:
     multicodec "^3.0.1"
     multihashes "^4.0.2"
 
+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"
+
 interpret@^1.0.0:
   version "1.4.0"
   resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.4.0.tgz#665ab8bc4da27a774a40584e812e3e0fa45b1a1e"
@@ -6061,6 +6603,14 @@ is-regex@^1.1.2:
     call-bind "^1.0.2"
     has-symbols "^1.0.1"
 
+is-regex@^1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/is-regex/-/is-regex-1.1.3.tgz#d029f9aff6448b93ebbe3f33dac71511fdcbef9f"
+  integrity sha512-qSVXFz28HM7y+IWX6vLCsexdlvzT1PJNFSBuaQLQ5o0IEw8UDYW6/2+eCMVyIsbM8CNLX2a/QWmSpyxYEHY7CQ==
+  dependencies:
+    call-bind "^1.0.2"
+    has-symbols "^1.0.2"
+
 is-ssh@^1.3.0:
   version "1.3.2"
   resolved "https://registry.yarnpkg.com/is-ssh/-/is-ssh-1.3.2.tgz#a4b82ab63d73976fd8263cceee27f99a88bdae2b"
@@ -6083,6 +6633,11 @@ is-string@^1.0.5:
   resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.5.tgz#40493ed198ef3ff477b8c7f92f644ec82a5cd3a6"
   integrity sha512-buY6VNRjhQMiF1qWDouloZlQbRhDPCebwxSjxMjxgemYT46YMd2NR0/H+fBhEfWX4A/w9TBJ+ol+okqJKFE6vQ==
 
+is-string@^1.0.6:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/is-string/-/is-string-1.0.6.tgz#3fe5d5992fb0d93404f32584d4b0179a71b54a5f"
+  integrity sha512-2gdzbKUuqtQ3lYNrUTQYoClPhm7oQu4UdpSZMp1/DGgkHBT8E2Z1l0yMdb6D4zNAxwDiMv8MdulKROJGNl0Q0w==
+
 is-symbol@^1.0.2, is-symbol@^1.0.3:
   version "1.0.3"
   resolved "https://registry.yarnpkg.com/is-symbol/-/is-symbol-1.0.3.tgz#38e1014b9e6329be0de9d24a414fd7441ec61937"
@@ -6281,6 +6836,11 @@ it-to-stream@^1.0.0:
     p-fifo "^1.0.0"
     readable-stream "^3.6.0"
 
+iterall@^1.2.1:
+  version "1.3.0"
+  resolved "https://registry.yarnpkg.com/iterall/-/iterall-1.3.0.tgz#afcb08492e2915cbd8a0884eb93a8c94d0d72fea"
+  integrity sha512-QZ9qOMdF+QLHxy1QIpUHUU1D5pS2CG2P69LF6L6CPjPYA/XMOmKV3PZpawHoAjHNyB0swdVTRxdYT4tbBbxqwg==
+
 jest-worker@27.0.0-next.5:
   version "27.0.0-next.5"
   resolved "https://registry.yarnpkg.com/jest-worker/-/jest-worker-27.0.0-next.5.tgz#5985ee29b12a4e191f4aae4bb73b97971d86ec28"
@@ -6408,6 +6968,14 @@ jsprim@^1.2.2:
     json-schema "0.2.3"
     verror "1.10.0"
 
+"jsx-ast-utils@^2.4.1 || ^3.0.0", jsx-ast-utils@^3.1.0:
+  version "3.2.0"
+  resolved "https://registry.yarnpkg.com/jsx-ast-utils/-/jsx-ast-utils-3.2.0.tgz#41108d2cec408c3453c1bbe8a4aae9e1e2bd8f82"
+  integrity sha512-EIsmt3O3ljsU6sot/J4E1zDRxfBNrhjyf/OKjlydwgEimQuznlM4Wv7U+ueONJMyEn1WRE0K8dhi3dVAXYT24Q==
+  dependencies:
+    array-includes "^3.1.2"
+    object.assign "^4.1.2"
+
 kind-of@^6.0.2, kind-of@^6.0.3:
   version "6.0.3"
   resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-6.0.3.tgz#07c05034a6c349fa06e24fa35aa76db4580ce4dd"
@@ -6418,6 +6986,18 @@ kuler@^2.0.0:
   resolved "https://registry.yarnpkg.com/kuler/-/kuler-2.0.0.tgz#e2c570a3800388fb44407e851531c1d670b061b3"
   integrity sha512-Xq9nH7KlWZmXAtodXDDRE7vs6DU1gTU8zYDHDiWLSip45Egwq3plLHzPn27NgvzL2r1LMPC1vdqh98sQxtqj4A==
 
+language-subtag-registry@~0.3.2:
+  version "0.3.21"
+  resolved "https://registry.yarnpkg.com/language-subtag-registry/-/language-subtag-registry-0.3.21.tgz#04ac218bea46f04cb039084602c6da9e788dd45a"
+  integrity sha512-L0IqwlIXjilBVVYKFT37X9Ih11Um5NEl9cbJIuU/SwP/zEEAbBPOnEeeuxVMf45ydWQRDQN3Nqc96OgbH1K+Pg==
+
+language-tags@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/language-tags/-/language-tags-1.0.5.tgz#d321dbc4da30ba8bf3024e040fa5c14661f9193a"
+  integrity sha1-0yHbxNowuovzAk4ED6XBRmH5GTo=
+  dependencies:
+    language-subtag-registry "~0.3.2"
+
 lazy-ass@^1.6.0:
   version "1.6.0"
   resolved "https://registry.yarnpkg.com/lazy-ass/-/lazy-ass-1.6.0.tgz#7999655e8646c17f089fdd187d150d3324d54513"
@@ -6489,6 +7069,13 @@ lines-and-columns@^1.1.6:
   resolved "https://registry.yarnpkg.com/lines-and-columns/-/lines-and-columns-1.1.6.tgz#1c00c743b433cd0a4e80758f7b64a57440d9ff00"
   integrity sha1-HADHQ7QzzQpOgHWPe2SldEDZ/wA=
 
+linkify-it@^2.0.0:
+  version "2.2.0"
+  resolved "https://registry.yarnpkg.com/linkify-it/-/linkify-it-2.2.0.tgz#e3b54697e78bf915c70a38acd78fd09e0058b1cf"
+  integrity sha512-GnAl/knGn+i1U/wjBz3akz2stz+HrHLsxMwHQGofCDfPvlf+gDKN58UtfmUquTY4/MXeE2x7k19KQmeoZi94Iw==
+  dependencies:
+    uc.micro "^1.0.1"
+
 listr-silent-renderer@^1.1.1:
   version "1.1.1"
   resolved "https://registry.yarnpkg.com/listr-silent-renderer/-/listr-silent-renderer-1.1.1.tgz#924b5a3757153770bf1a8e3fbf74b8bbf3f9242e"
@@ -6518,6 +7105,19 @@ listr-verbose-renderer@^0.5.0:
     date-fns "^1.27.2"
     figures "^2.0.0"
 
+listr2@^3.8.3:
+  version "3.11.0"
+  resolved "https://registry.yarnpkg.com/listr2/-/listr2-3.11.0.tgz#9771b02407875aa78e73d6e0ff6541bbec0aaee9"
+  integrity sha512-XLJVe2JgXCyQTa3FbSv11lkKExYmEyA4jltVo8z4FX10Vt1Yj8IMekBfwim0BSOM9uj1QMTJvDQQpHyuPbB/dQ==
+  dependencies:
+    cli-truncate "^2.1.0"
+    colorette "^1.2.2"
+    log-update "^4.0.0"
+    p-map "^4.0.0"
+    rxjs "^6.6.7"
+    through "^2.3.8"
+    wrap-ansi "^7.0.0"
+
 listr@^0.14.3:
   version "0.14.3"
   resolved "https://registry.yarnpkg.com/listr/-/listr-0.14.3.tgz#2fea909604e434be464c50bddba0d496928fa586"
@@ -6682,6 +7282,16 @@ log-update@^2.3.0:
     cli-cursor "^2.0.0"
     wrap-ansi "^3.0.1"
 
+log-update@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/log-update/-/log-update-4.0.0.tgz#589ecd352471f2a1c0c570287543a64dfd20e0a1"
+  integrity sha512-9fkkDevMefjg0mmzWFBW8YkFP91OrizzkW3diF7CpG+S2EYdy4+TVfGwz1zeF8x7hCx1ovSPTOE9Ngib74qqUg==
+  dependencies:
+    ansi-escapes "^4.3.0"
+    cli-cursor "^3.1.0"
+    slice-ansi "^4.0.0"
+    wrap-ansi "^6.2.0"
+
 logform@^2.2.0:
   version "2.2.0"
   resolved "https://registry.yarnpkg.com/logform/-/logform-2.2.0.tgz#40f036d19161fc76b68ab50fdc7fe495544492f2"
@@ -6776,6 +7386,17 @@ map-obj@^4.0.0:
   resolved "https://registry.yarnpkg.com/map-obj/-/map-obj-4.2.0.tgz#0e8bc823e2aaca8a0942567d12ed14f389eec153"
   integrity sha512-NAq0fCmZYGz9UFEQyndp7sisrow4GroyGeKluyKC/chuITZsPyOyC1UJZPJlVFImhXdROIP5xqouRLThT3BbpQ==
 
+markdown-it@^10.0.0:
+  version "10.0.0"
+  resolved "https://registry.yarnpkg.com/markdown-it/-/markdown-it-10.0.0.tgz#abfc64f141b1722d663402044e43927f1f50a8dc"
+  integrity sha512-YWOP1j7UbDNz+TumYP1kpwnP0aEa711cJjrAQrzd0UXlbJfc5aAq0F/PZHjiioqDC1NKgvIMX+o+9Bk7yuM2dg==
+  dependencies:
+    argparse "^1.0.7"
+    entities "~2.0.0"
+    linkify-it "^2.0.0"
+    mdurl "^1.0.1"
+    uc.micro "^1.0.5"
+
 match-sorter@^6.0.2:
   version "6.3.0"
   resolved "https://registry.yarnpkg.com/match-sorter/-/match-sorter-6.3.0.tgz#454a1b31ed218cddbce6231a0ecb5fdc549fed01"
@@ -6793,6 +7414,11 @@ md5.js@^1.3.4:
     inherits "^2.0.1"
     safe-buffer "^5.1.2"
 
+mdurl@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/mdurl/-/mdurl-1.0.1.tgz#fe85b2ec75a59037f2adfec100fd6c601761152e"
+  integrity sha1-/oWy7HWlkDfyrf7BAP1sYBdhFS4=
+
 media-typer@0.3.0:
   version "0.3.0"
   resolved "https://registry.yarnpkg.com/media-typer/-/media-typer-0.3.0.tgz#8710d7af0aa626f8fffa1ce00168545263255748"
@@ -6883,6 +7509,11 @@ merge2@^1.3.0:
   resolved "https://registry.yarnpkg.com/merge2/-/merge2-1.4.1.tgz#4368892f885e907455a6fd7dc55c0c9d404990ae"
   integrity sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==
 
+meros@^1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/meros/-/meros-1.1.4.tgz#c17994d3133db8b23807f62bec7f0cb276cfd948"
+  integrity sha512-E9ZXfK9iQfG9s73ars9qvvvbSIkJZF5yOo9j4tcwM5tN8mUKfj/EKN5PzOr3ZH0y5wL7dLAHw3RVEfpQV9Q7VQ==
+
 methods@~1.1.2:
   version "1.1.2"
   resolved "https://registry.yarnpkg.com/methods/-/methods-1.1.2.tgz#5529a4d67654134edcc5266656835b0f851afcee"
@@ -7278,6 +7909,62 @@ next-transpile-modules@~3.3.0:
     micromatch "^4.0.2"
     slash "^3.0.0"
 
+next@^11.0.1:
+  version "11.0.1"
+  resolved "https://registry.yarnpkg.com/next/-/next-11.0.1.tgz#b8e3914d153aaf7143cb98c09bcd3c8230eeb17a"
+  integrity sha512-yR7be7asNbvpVNpi6xxEg28wZ7Gqmj1nOt0sABH9qORmF3+pms2KZ7Cng33oK5nqPIzEEFJD0pp2PCe3/ueMIg==
+  dependencies:
+    "@babel/runtime" "7.12.5"
+    "@hapi/accept" "5.0.2"
+    "@next/env" "11.0.1"
+    "@next/polyfill-module" "11.0.1"
+    "@next/react-dev-overlay" "11.0.1"
+    "@next/react-refresh-utils" "11.0.1"
+    assert "2.0.0"
+    ast-types "0.13.2"
+    browserify-zlib "0.2.0"
+    browserslist "4.16.6"
+    buffer "5.6.0"
+    caniuse-lite "^1.0.30001228"
+    chalk "2.4.2"
+    chokidar "3.5.1"
+    constants-browserify "1.0.0"
+    crypto-browserify "3.12.0"
+    cssnano-simple "2.0.0"
+    domain-browser "4.19.0"
+    encoding "0.1.13"
+    etag "1.8.1"
+    find-cache-dir "3.3.1"
+    get-orientation "1.1.2"
+    https-browserify "1.0.0"
+    image-size "1.0.0"
+    jest-worker "27.0.0-next.5"
+    native-url "0.3.4"
+    node-fetch "2.6.1"
+    node-html-parser "1.4.9"
+    node-libs-browser "^2.2.1"
+    os-browserify "0.3.0"
+    p-limit "3.1.0"
+    path-browserify "1.0.1"
+    pnp-webpack-plugin "1.6.4"
+    postcss "8.2.13"
+    process "0.11.10"
+    prop-types "15.7.2"
+    querystring-es3 "0.2.1"
+    raw-body "2.4.1"
+    react-is "17.0.2"
+    react-refresh "0.8.3"
+    stream-browserify "3.0.0"
+    stream-http "3.1.1"
+    string_decoder "1.3.0"
+    styled-jsx "3.3.2"
+    timers-browserify "2.0.12"
+    tty-browserify "0.0.1"
+    use-subscription "1.5.1"
+    util "0.12.3"
+    vm-browserify "1.1.2"
+    watchpack "2.1.1"
+
 next@~10:
   version "10.1.3"
   resolved "https://registry.yarnpkg.com/next/-/next-10.1.3.tgz#e26e8371343a42bc2ba9be5cb253a7d324d03673"
@@ -7568,6 +8255,11 @@ nprogress@^0.2.0:
   resolved "https://registry.yarnpkg.com/nprogress/-/nprogress-0.2.0.tgz#cb8f34c53213d895723fcbab907e9422adbcafb1"
   integrity sha1-y480xTIT2JVyP8urkH6UIq28r7E=
 
+nullthrows@^1.0.0:
+  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"
@@ -7588,6 +8280,11 @@ object-hash@^2.1.1:
   resolved "https://registry.yarnpkg.com/object-hash/-/object-hash-2.1.1.tgz#9447d0279b4fcf80cff3259bf66a1dc73afabe09"
   integrity sha512-VOJmgmS+7wvXf8CjbQmimtCnEx3IAoLxI3fp2fbWehxrWBcAQFbk+vcwb6vzR0VZv/eNCJ/27j151ZTwqW/JeQ==
 
+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.9.0"
   resolved "https://registry.yarnpkg.com/object-inspect/-/object-inspect-1.9.0.tgz#c90521d74e1127b67266ded3394ad6116986533a"
@@ -7616,6 +8313,25 @@ object.assign@^4.1.0, object.assign@^4.1.2:
     has-symbols "^1.0.1"
     object-keys "^1.1.1"
 
+object.entries@^1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/object.entries/-/object.entries-1.1.4.tgz#43ccf9a50bc5fd5b649d45ab1a579f24e088cafd"
+  integrity sha512-h4LWKWE+wKQGhtMjZEBud7uLGhqyLwj8fpHOarZhD2uY3C9cRtk57VQ89ke3moByLXMedqs3XCHzyb4AmA2DjA==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+    es-abstract "^1.18.2"
+
+object.fromentries@^2.0.4:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/object.fromentries/-/object.fromentries-2.0.4.tgz#26e1ba5c4571c5c6f0890cef4473066456a120b8"
+  integrity sha512-EsFBshs5RUUpQEY1D4q/m59kMfz4YJvxuNCJcv/jWwOJr34EaVnG11ZrZa0UHB3wnzV1wx8m58T4hQL8IuNXlQ==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+    es-abstract "^1.18.0-next.2"
+    has "^1.0.3"
+
 object.getownpropertydescriptors@^2.0.3:
   version "2.1.2"
   resolved "https://registry.yarnpkg.com/object.getownpropertydescriptors/-/object.getownpropertydescriptors-2.1.2.tgz#1bd63aeacf0d5d2d2f31b5e393b03a7c601a23f7"
@@ -7635,6 +8351,15 @@ object.values@^1.1.1:
     es-abstract "^1.18.0-next.2"
     has "^1.0.3"
 
+object.values@^1.1.4:
+  version "1.1.4"
+  resolved "https://registry.yarnpkg.com/object.values/-/object.values-1.1.4.tgz#0d273762833e816b693a637d30073e7051535b30"
+  integrity sha512-TnGo7j4XSnKQoK3MfvkzqKCi0nVe/D9I9IjwTNYdb/fxYHpjrluHVOgw0AF6jrRFGMPHdfuidR09tIDiIvnaSg==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+    es-abstract "^1.18.2"
+
 on-finished@^2.3.0, on-finished@~2.3.0:
   version "2.3.0"
   resolved "https://registry.yarnpkg.com/on-finished/-/on-finished-2.3.0.tgz#20f1336481b083cd75337992a16971aa2d906947"
@@ -8159,6 +8884,15 @@ postcss@8.1.7:
     nanoid "^3.1.16"
     source-map "^0.6.1"
 
+postcss@8.2.13:
+  version "8.2.13"
+  resolved "https://registry.yarnpkg.com/postcss/-/postcss-8.2.13.tgz#dbe043e26e3c068e45113b1ed6375d2d37e2129f"
+  integrity sha512-FCE5xLH+hjbzRdpbRb1IMCvPv9yZx2QnDarBEYSN0N0HYk+TcXsEhwdFcFb+SRWOKzKGErhIEbBK2ogyLdTtfQ==
+  dependencies:
+    colorette "^1.2.2"
+    nanoid "^3.1.22"
+    source-map "^0.6.1"
+
 postcss@^6.0.9:
   version "6.0.23"
   resolved "https://registry.yarnpkg.com/postcss/-/postcss-6.0.23.tgz#61c82cc328ac60e677645f979054eb98bc0e3324"
@@ -8396,6 +9130,13 @@ queue-microtask@^1.2.2:
   resolved "https://registry.yarnpkg.com/queue-microtask/-/queue-microtask-1.2.3.tgz#4929228bbc724dfac43e0efb058caf7b6cfb6243"
   integrity sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==
 
+queue@6.0.2:
+  version "6.0.2"
+  resolved "https://registry.yarnpkg.com/queue/-/queue-6.0.2.tgz#b91525283e2315c7553d2efa18d83e76432fed65"
+  integrity sha512-iHZWu+q3IdFZFX36ro/lKBkSvfkztY5Y7HMiPlOUjhupPcG2JMfst2KKEpu5XndviX/3UhFbRngUPNKtgvtZiA==
+  dependencies:
+    inherits "~2.0.3"
+
 quick-lru@^4.0.1:
   version "4.0.1"
   resolved "https://registry.yarnpkg.com/quick-lru/-/quick-lru-4.0.1.tgz#5b8878f113a58217848c6482026c73e1ba57727f"
@@ -8480,7 +9221,7 @@ react-dom@16.13.0:
     prop-types "^15.6.2"
     scheduler "^0.19.0"
 
-react-dom@~17:
+react-dom@^17.0.2, react-dom@~17:
   version "17.0.2"
   resolved "https://registry.yarnpkg.com/react-dom/-/react-dom-17.0.2.tgz#ecffb6845e3ad8dbfcdc498f0d0a939736502c23"
   integrity sha512-s4h96KtLDUQlsENhMn1ar8t2bEa+q/YAtj8pPPdIjPDGBDIVNsrD9aXNWqspUe6AzKCIG0C1HZZLqLV7qpOBGA==
@@ -8521,6 +9262,11 @@ react-is@16.13.1, react-is@^16.6.0, react-is@^16.8.1:
   resolved "https://registry.yarnpkg.com/react-is/-/react-is-16.13.1.tgz#789729a4dc36de2999dc156dd6c1d9c18cea56a4"
   integrity sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==
 
+react-is@17.0.2:
+  version "17.0.2"
+  resolved "https://registry.yarnpkg.com/react-is/-/react-is-17.0.2.tgz#e691d4a8e9c789365655539ab372762b0efb54f0"
+  integrity sha512-w2GsyukL62IJnlaff/nRegPQR94C/XXamvMWmSHRJ4y7Ts/4ocGRmTHvOs8PSE6pB3dWOrD/nueuU5sduBsQ4w==
+
 react-lifecycles-compat@^3.0.0:
   version "3.0.4"
   resolved "https://registry.yarnpkg.com/react-lifecycles-compat/-/react-lifecycles-compat-3.0.4.tgz#4f1a273afdfc8f3488a8c516bfda78f872352362"
@@ -8567,7 +9313,7 @@ react@16.13.0:
     object-assign "^4.1.1"
     prop-types "^15.6.2"
 
-react@~17:
+react@^17.0.2, react@~17:
   version "17.0.2"
   resolved "https://registry.yarnpkg.com/react/-/react-17.0.2.tgz#d0b5cc516d29eb3eee383f75b62864cfb6800037"
   integrity sha512-gnhPt75i/dq/z3/6q/0asP78D0u592D5L1pd7M8P+dck6Fu/jJeL6iVVK23fptSUZj8Vjf++7wXA8UNclGQcbA==
@@ -8817,6 +9563,14 @@ regenerator-transform@^0.14.2:
   dependencies:
     "@babel/runtime" "^7.8.4"
 
+regexp.prototype.flags@^1.3.1:
+  version "1.3.1"
+  resolved "https://registry.yarnpkg.com/regexp.prototype.flags/-/regexp.prototype.flags-1.3.1.tgz#7ef352ae8d159e758c0eadca6f8fcb4eef07be26"
+  integrity sha512-JiBdRBq91WlY7uRJ0ds7R+dU02i6LKi8r3BuQhNXn+kmeLN+EfHhfjqMRis1zJxnlu88hq/4dx0P2OP3APRTOA==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+
 regexpp@^3.0.0, regexpp@^3.1.0:
   version "3.1.0"
   resolved "https://registry.yarnpkg.com/regexpp/-/regexpp-3.1.0.tgz#206d0ad0a5648cffbdb8ae46438f3dc51c9f78e2"
@@ -8931,6 +9685,14 @@ resolve@^1.0.0, resolve@^1.1.6, resolve@^1.10.0, resolve@^1.13.1, resolve@^1.17.
     is-core-module "^2.2.0"
     path-parse "^1.0.6"
 
+resolve@^2.0.0-next.3:
+  version "2.0.0-next.3"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-2.0.0-next.3.tgz#d41016293d4a8586a39ca5d9b5f15cbea1f55e46"
+  integrity sha512-W8LucSynKUIDu9ylraa7ueVZ7hc0uAgJBxVsQSKOXOyle8a93qXhcz+XAXZ8bIq2d6i4Ehddn6Evt+0/UwKk6Q==
+  dependencies:
+    is-core-module "^2.2.0"
+    path-parse "^1.0.6"
+
 restore-cursor@^1.0.1:
   version "1.0.1"
   resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-1.0.1.tgz#34661f46886327fed2991479152252df92daa541"
@@ -9004,7 +9766,7 @@ run-parallel@^1.1.9:
   dependencies:
     queue-microtask "^1.2.2"
 
-rxjs@^6.3.3, rxjs@^6.5.3, rxjs@^6.6.0:
+rxjs@^6.3.3, rxjs@^6.5.3, rxjs@^6.6.0, rxjs@^6.6.7:
   version "6.6.7"
   resolved "https://registry.yarnpkg.com/rxjs/-/rxjs-6.6.7.tgz#90ac018acabf491bf65044235d5863c4dab804c9"
   integrity sha512-hTdwr+7yYNIT5n4AMYp85KA6yw2Va0FLa3Rguvbpa4W3I5xynaBZo41cM3XM+4Q6fRMj3sBYIR1VAmZMXYJvRQ==
@@ -9052,7 +9814,7 @@ semver@^6.0.0, semver@^6.3.0:
   resolved "https://registry.yarnpkg.com/semver/-/semver-6.3.0.tgz#ee0a64c8af5e8ceea67687b133761e1becbd1d3d"
   integrity sha512-b39TBaTSfV6yBrapU89p5fKekE2m/NwnDocOVruQFS1/veMgdzuPcnOM34M6CwxW8jH/lxEa5rBoDeUwu5HHTw==
 
-semver@^7.1.1, semver@^7.1.3, semver@^7.2.1, semver@^7.3.2, semver@^7.3.4:
+semver@^7.1.1, semver@^7.1.3, semver@^7.2.1, semver@^7.3.2, semver@^7.3.4, 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==
@@ -9175,6 +9937,15 @@ slice-ansi@0.0.4:
   resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-0.0.4.tgz#edbf8903f66f7ce2f8eafd6ceed65e264c831b35"
   integrity sha1-7b+JA/ZvfOL46v1s7tZeJkyDGzU=
 
+slice-ansi@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-3.0.0.tgz#31ddc10930a1b7e0b67b08c96c2f49b77a789787"
+  integrity sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==
+  dependencies:
+    ansi-styles "^4.0.0"
+    astral-regex "^2.0.0"
+    is-fullwidth-code-point "^3.0.0"
+
 slice-ansi@^4.0.0:
   version "4.0.0"
   resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-4.0.0.tgz#500e8dd0fd55b05815086255b3195adf2a45fe6b"
@@ -9446,6 +10217,20 @@ string-width@^4.1.0, string-width@^4.2.0:
     is-fullwidth-code-point "^3.0.0"
     strip-ansi "^6.0.0"
 
+string.prototype.matchall@^4.0.5:
+  version "4.0.5"
+  resolved "https://registry.yarnpkg.com/string.prototype.matchall/-/string.prototype.matchall-4.0.5.tgz#59370644e1db7e4c0c045277690cf7b01203c4da"
+  integrity sha512-Z5ZaXO0svs0M2xd/6By3qpeKpLKd9mO4v4q3oMEQrk8Ck4xOD5d5XeBOOjGrmVZZ/AHB1S0CgG4N5r1G9N3E2Q==
+  dependencies:
+    call-bind "^1.0.2"
+    define-properties "^1.1.3"
+    es-abstract "^1.18.2"
+    get-intrinsic "^1.1.1"
+    has-symbols "^1.0.2"
+    internal-slot "^1.0.3"
+    regexp.prototype.flags "^1.3.1"
+    side-channel "^1.0.4"
+
 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"
@@ -9600,6 +10385,17 @@ stylis@3.5.4, stylis@^3.5.0:
   resolved "https://registry.yarnpkg.com/stylis/-/stylis-3.5.4.tgz#f665f25f5e299cf3d64654ab949a57c768b73fbe"
   integrity sha512-8/3pSmthWM7lsPBKv7NXkzn2Uc9W7NotcwGNpJaa3k7WMM1XDCA4MgT5k/8BIexd5ydZdboXtU90XH9Ec4Bv/Q==
 
+subscriptions-transport-ws@^0.9.18:
+  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"
+
 supports-color@^2.0.0:
   version "2.0.0"
   resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7"
@@ -9633,7 +10429,7 @@ supports-color@^8.0.0, supports-color@^8.1.1:
   dependencies:
     has-flag "^4.0.0"
 
-symbol-observable@^1.1.0:
+symbol-observable@^1.0.4, symbol-observable@^1.1.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==
@@ -9760,7 +10556,7 @@ through2@^4.0.0:
   dependencies:
     readable-stream "3"
 
-through@2, "through@>=2.2.7 <3", through@^2.3.4, through@^2.3.6:
+through@2, "through@>=2.2.7 <3", through@^2.3.4, through@^2.3.6, through@^2.3.8:
   version "2.3.8"
   resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5"
   integrity sha1-DdTJ/6q8NXlgsbckEV1+Doai4fU=
@@ -9811,6 +10607,11 @@ to-regex-range@^5.0.1:
   dependencies:
     is-number "^7.0.0"
 
+toggle-selection@^1.0.6:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/toggle-selection/-/toggle-selection-1.0.6.tgz#6e45b1263f2017fa0acc7d89d78b15b8bf77da32"
+  integrity sha1-bkWxJj8gF/oKzH2J14sVuL932jI=
+
 toidentifier@1.0.0:
   version "1.0.0"
   resolved "https://registry.yarnpkg.com/toidentifier/-/toidentifier-1.0.0.tgz#7e1be3470f1e77948bc43d94a3c8f4d7752ba553"
@@ -9943,7 +10744,7 @@ tslib@^2.0.3, tslib@^2.1.0:
   resolved "https://registry.yarnpkg.com/tslib/-/tslib-2.2.0.tgz#fb2c475977e35e241311ede2693cee1ec6698f5c"
   integrity sha512-gS9GVHRU+RGn5KQM2rllAlR3dU6m7AcpJKdtH8gFvQiC4Otgk98XnmMU+nZenHt/+VhnBPWwgrJsyrdcw6i23w==
 
-tsutils@^3.17.1:
+tsutils@^3.17.1, tsutils@^3.21.0:
   version "3.21.0"
   resolved "https://registry.yarnpkg.com/tsutils/-/tsutils-3.21.0.tgz#b48717d394cea6c1e096983eed58e9d61715b623"
   integrity sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==
@@ -10039,6 +10840,11 @@ typescript@^4.2.3:
   resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.2.3.tgz#39062d8019912d43726298f09493d598048c1ce3"
   integrity sha512-qOcYwxaByStAWrBf4x0fibwZvMRG+r4cQoTjbPtUlrWjBHbmCAww1i448U0GJ+3cNNEtebDteo/cHOR3xJ4wEw==
 
+typescript@^4.3.5:
+  version "4.3.5"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-4.3.5.tgz#4d1c37cc16e893973c45a06886b7113234f119f4"
+  integrity sha512-DqQgihaQ9cUrskJo9kIyW/+g0Vxsk8cDtZ52a3NGh0YNTfpUSArXSohyUGnvbPazEPLu398C0UxmKSOrPumUzA==
+
 u2f-api@0.2.7:
   version "0.2.7"
   resolved "https://registry.yarnpkg.com/u2f-api/-/u2f-api-0.2.7.tgz#17bf196b242f6bf72353d9858e6a7566cc192720"
@@ -10092,6 +10898,11 @@ ual-scatter@^0.3.0:
     eosjs "21.0.1-rc1"
     universal-authenticator-library "0.3.0"
 
+uc.micro@^1.0.1, uc.micro@^1.0.5:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/uc.micro/-/uc.micro-1.0.6.tgz#9c411a802a409a91fc6cf74081baba34b24499ac"
+  integrity sha512-8Y75pvTYkLJW2hWQHXxoqRgV7qb9B+9vFEtidML+7koHUFapnVJAZ6cKs+Qjz5Aw3aZWHMC6u0wJE3At+nSGwA==
+
 uglify-js@^3.1.4:
   version "3.13.3"
   resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-3.13.3.tgz#ce72a1ad154348ea2af61f50933c76cc8802276e"
@@ -10114,7 +10925,7 @@ umask@^1.1.0:
   resolved "https://registry.yarnpkg.com/umask/-/umask-1.1.0.tgz#f29cebf01df517912bb58ff9c4e50fde8e33320d"
   integrity sha1-8pzr8B31F5ErtY/5xOUP3o4zMg0=
 
-unbox-primitive@^1.0.0:
+unbox-primitive@^1.0.0, 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==
@@ -10328,6 +11139,11 @@ vm-browserify@1.1.2, vm-browserify@^1.0.1:
   resolved "https://registry.yarnpkg.com/vm-browserify/-/vm-browserify-1.1.2.tgz#78641c488b8e6ca91a75f511e7a3b32a86e5dda0"
   integrity sha512-2ham8XPWTONajOR0ohOKOHXkm3+gaBmGut3SRuu75xLd/RRaY6vqgh8NBYYk7+RW3u5AtzPQZG8F10LHkl0lAQ==
 
+vscode-languageserver-types@^3.15.1:
+  version "3.16.0"
+  resolved "https://registry.yarnpkg.com/vscode-languageserver-types/-/vscode-languageserver-types-3.16.0.tgz#ecf393fc121ec6974b2da3efb3155644c514e247"
+  integrity sha512-k8luDIWJWyenLc5ToFQQMaSrqCHiLwyKPHKPQZ5zz21vM+vIVUSvsRpcbiECH4WR88K2XZqc4ScRcZ7nk/jbeA==
+
 warning@^4.0.3:
   version "4.0.3"
   resolved "https://registry.yarnpkg.com/warning/-/warning-4.0.3.tgz#16e9e077eb8a86d6af7d64aa1e05fd85b4678ca3"
@@ -10464,6 +11280,15 @@ wrap-ansi@^3.0.1:
     string-width "^2.1.1"
     strip-ansi "^4.0.0"
 
+wrap-ansi@^6.2.0:
+  version "6.2.0"
+  resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-6.2.0.tgz#e9393ba07102e6c91a3b221478f0257cd2856e53"
+  integrity sha512-r6lPcBGxZXlIcymEu7InxDMhdW0KDxpLgoFLcguasxCaJ/SOIZwINatK9KY/tf+ZrlywOKU0UDj3ATXUBfxJXA==
+  dependencies:
+    ansi-styles "^4.0.0"
+    string-width "^4.1.0"
+    strip-ansi "^6.0.0"
+
 wrap-ansi@^7.0.0:
   version "7.0.0"
   resolved "https://registry.yarnpkg.com/wrap-ansi/-/wrap-ansi-7.0.0.tgz#67e145cff510a6a6984bdf1152911d69d2eb9e43"
@@ -10530,6 +11355,11 @@ write-pkg@^4.0.0:
     type-fest "^0.4.1"
     write-json-file "^3.2.0"
 
+"ws@^5.2.0 || ^6.0.0 || ^7.0.0":
+  version "7.5.3"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.5.3.tgz#160835b63c7d97bfab418fc1b8a9fced2ac01a74"
+  integrity sha512-kQ/dHIzuLrS6Je9+uv81ueZomEwH0qVYstcAQ4/Z93K8zeko9gtAbttJWzoC5ukqXY1PpoouV3+VSOqEAFt5wg==
+
 ws@^6.1.0:
   version "6.2.1"
   resolved "https://registry.yarnpkg.com/ws/-/ws-6.2.1.tgz#442fdf0a47ed64f59b6a5d8ff130f4748ed524fb"
@@ -10542,6 +11372,11 @@ ws@^7.4.3:
   resolved "https://registry.yarnpkg.com/ws/-/ws-7.4.4.tgz#383bc9742cb202292c9077ceab6f6047b17f2d59"
   integrity sha512-Qm8k8ojNQIMx7S+Zp8u/uHOx7Qazv3Yv4q68MiWWWOJhiwG5W3x7iqmRtJo8xxrciZUY4vRxUTJCKuRnF28ZZw==
 
+ws@^8.0.0:
+  version "8.0.0"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-8.0.0.tgz#550605d13dfc1437c9ec1396975709c6d7ffc57d"
+  integrity sha512-6AcSIXpBlS0QvCVKk+3cWnWElLsA6SzC0lkQ43ciEglgXJXiCWK3/CGFEJ+Ybgp006CMibamAsqOlxE9s4AvYA==
+
 xtend@^4.0.0, xtend@^4.0.2, xtend@~4.0.1:
   version "4.0.2"
   resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.2.tgz#bb72779f5fa465186b1f438f674fa347fdb5db54"